学习笔记 matlab入门02

1.matlab中的矩阵

1.1矩阵的创建方法

（1）直接输入法

• 适用于矩阵中元素数量较少的情况。
• 输入矩阵时要以中括号"[ ]"作为标识符号，矩阵的所有元素都包含在中括号内。
• 矩阵的同行元素之间用空格或逗号分隔，行与行之间用分号或回车键分隔。

  a=[1 2 3;4 5 6]
  %等价于
  a=[1 2 3
     4 5 6]

（2）函数创建法

• zeros，ones，eye 用来创建全为0的矩阵、全为1的矩阵和单位矩阵
  • zeros(n) 用来创建一个全为0的n阶方阵
  • zeros(m,n) 用来创建一个m行n列全为0的矩阵
  • ones(n) 用来创建一个全为1的n阶方阵
  • ones(m,n) 用来创建一个m行n列全为1的矩阵
  • eye(n) 用来创建一个n阶单位矩阵

  • a=zeros(3)
    % 0 0 0
    % 0 0 0
    % 0 0 0
    
    b=zeros(2,3)
    % 0 0 0
    % 0 0 0
    
    c=ones(3)
    % 1 1 1 
    % 1 1 1
    % 1 1 1
    
    d=ones(2,3)
    % 1 1 1
    % 1 1 1
    
    e=eye(3)
    % 1 0 0
    % 0 1 0
    % 0 0 1 
    

• rand，randi，randn 创建均匀分布的随机数，均匀分布的随机整数和标准正态分布的随机数
  • rand函数用来创建区间0和1内均匀分布的随机数
    • rand(n) 创建一个n行n列的随机数矩阵
    • rand(m,n) 创建一个m行n列的随机数矩阵
  • randi函数用来创建均匀分布的随机整数
    • randi([imin,imax],m,n) 创建一个m行n列的随机数矩阵，随机数矩阵中的每个元素都是从区间[imin,imax]内随机抽取的整数。
    • 若imin等于1，那么可以简写为randi(imax,m,n)
    • 若m=n,即生成一个m行n列的方针，那么可以直接写为randi([imin,imax],n)
  • randn函数用来创建标准正态分布的随机数（以0为均值，1为标准差）
    • randn(n) 创建一个n行n列的随机数矩阵
    • rand(m,n) 创建一个m行n列的随机数矩阵
  • 因为生成的是随机数，所以每次运行的结果可能会变化
• diag和blkdiag
  • diag函数可以用来创建对角矩阵或者获取矩阵的对角元素
    • 输入的第一个参数是向量，则表示创建对角矩阵
      • diag(v,k)将向量v的元素放置在第k条对角线上，其他位置元素为0
      • k=0，表示主对角线，函数可以直接写为diag(v)；k>0,表示位于主对角线上方；k<0，表示位于主对角线下方。

        diag([1,2,3])
        % 1 0 0
        % 0 2 0
        % 0 0 3
        diag([1,2,3],-1)
        % 0 0 0 0
        % 1 0 0 0
        % 0 2 0 0
        % 0 0 3 0
        diag([1,2,3],2)
        % 0 0 1 0 0 
        % 0 0 0 2 0 
        % 0 0 0 0 3 
        % 0 0 0 0 0
        % 0 0 0 0 0 
        

    • 输入的第一个参数是矩阵，则表示获取矩阵的对角元素
      • diag(A,k) 返回A的第k条对角线上元素的构成的列向量。

        A=[1,2,3,4;
           5,6,7,8;
           9,10,11,12;
           13,14,15,16]
        diag(A)
        % 1
        % 6
        % 11
        % 16
        diag(A,-1)
        % 5
        % 10
        % 15
        diag(A,1)
        % 2
        % 7
        % 12

• blkdiag函数可以用来创建分块对角矩阵（对角线的元素是矩阵）

A1=[1,2,3;4,5,6]
% 1 2 3
% 4 5 6 
A2=[7,8;9,10]
% 7 8
% 9 10
A3=[11,12;13,14;15,16]
% 11 12
% 13 14 
% 15 16
blkdiag(A1,A2,A3)
% 1 2 3 0 0 0 0
% 4 5 6 0 0 0 0
% 0 0 0 7 8 0 0
% 0 0 0 9 10 0 0
% 0 0 0 0 0 11 12
% 0 0 0 0 0 13 14
% 0 0 0 0 0 15 16

• matlab可以读取本地的文件，支持的常见格式如下
  • .txt、.dat、.csv（适用于带分隔符的文本文件）
  • .xls、.xlsb、.xlsm、.xlsx、.xltm、.xltx、.ods（适用于电子表格文件）

1.2矩阵元素的引用

• 引用矩阵的某一个元素 a（row_ind,column_ind）
  • row_ind引用元素的行索引，column_ind引用元素的列索引。若行索引和列索引是一个常数，则表示提取矩阵中的单个元素；若行索引和列索引是包含多个元素的向量，则表示同时提取多个位置的元素。end也可以在函数中替代最后一个元素的索引，通常与冒号法连用。

    a=randi([2,10],4,5)     %生成一个从2到10的4行5列的随机数矩阵
    a(1,2)    %取第一行第二列的元素
    a(2,end)    %取第二行最后一列的元素
    a(2，[1 3])    %取第二行，第一、三列元素
    a(3,1:5)    %取第三行，第一至五列的元素
    a([1 3],[1 3 5])    %取第一三行，第一三五列的元素
    a(1:2:end,1:2:end)    %取奇数行奇数列的元素
    

• 用size函数来计算一个矩阵的大小
  • size（A）返回一个行向量，其元素是A的各维度的长度。若A是一个3X4的矩阵，则size（A）返回向量[3 4];若让[r c]=size（A）,则r=3，c=4。
  • size（A，dim）返回在维度dim上的长度。dim=1时表示行；dim=2时表示列。若A是一个3X4的一个矩阵，则size（A，1）返回3，size（A，2）返回4。
  • length函数和numel函数也可以用在矩阵上。length函数会返回行和列的较大值，eg.length（A）=4；numel函数会返回矩阵中元素的总数，numel（A）返回12。
• 取出矩阵的某一行或者某一列
  • A=(1,1:end)表示取第一行的所有元素，即row_ind取1表示第一行，column_ind取1:end表示从1到最后一列的索引。可以简写为A=(1,:)。
  • 同理，取第一列的所有元素，可以用A(:,1)。
  • A=(:,n)表示矩阵A的第n列的所有元素
  • A=(m,:)表示矩阵A的第m行的所有元素

    A=randi(10,5,7)    %生成一个从1到10的5行7列的随机数矩阵
    A(:,[2,5])    %取出第二、五列的所有元素
    A(:,end)    %取出最后一列的所有元素
    A=(2:2:end,:)    %取出偶数行的元素
    A(1:2:end,3:3:end)    %取出奇数行，3的倍数列的所有元素

• 线性索引：使用单下标的索引方法
  • 在matlab中对矩阵数据的存储是单列的，矩阵是由各列顺次连接形成的。

        %列 
    %行 1,1  1,2  1,3
    %   2,1  2,2  2,3
    %   3,1  3,2  3,3
    
    %线性索引
        1  4  7
        2  5  8
        3  6  9
    
    

  • 用A(:)命令可以将A中的所有元素按照线性索引的顺序重构成一个列向量。

A=randi(100,2,3)   
% 59 31 24
% 21 48 85
A(:)
%59
%21
%31
%48
%24
%85

%对向量也适用
a=[2 5 8 1]
a(:)
% 2
% 5
% 8
% 1 

• sub2ind和ind2sub函数可用于在矩阵的原始索引（双下标）和线性索引之间进行转换
  • sub2ind将矩阵下标转换为线性索引；
  • ind2sub将线性索引转换为下标
  • ind=sub2ind(sz,row,col)针对大小为sz的矩阵返回由row和col指定的行列下标的对应线性索引ind。此处，sz是包含两个元素的向量，其中sz(1)指定行数，sz(2)指定列数。
  • [row,col]=ind2sub(sz,ind)返回数组row和col，表示对sz矩阵线性索引为ind的元素对应的行下标和列下标。sz是包含两个元素的向量，其中sz(1)指定行数，sz(2)指定列数。

    ind=sub2ind([3,3],2,2)    % 5
    ind=sub2ind([3,3],1,3)    % 7
    [row,col]=ind2sub([3,3],5)    %row=2,col=2
    [row,col]=ind2sub([3,3],7)    %row=1,col=3

 1.3矩阵元素的修改和删除

• 矩阵元素的修改
• 等号赋值

  A=[1:4,2:5,:3:6]
  % 1 2 3 4
  % 2 3 4 5
  % 3 4 5 6
  A(2,3)=10
  % 1 2 3 4
  % 2 3 10 5
  % 3 4 5 6
  A(3,:)=100
  % 1 2 3 4
  % 2 3 4 5
  % 100 100 100
  A([1,3],[2,3])=[8 88 888 8888]
  % 1 8 88 4
  % 2 3 4 5
  % 3 888 8888 6

• 线性索引

  A=[1:4,2:5,:3:6]
  % 1 2 3 4
  % 2 3 4 5
  % 3 4 5 6
  A(4)=10
  % 1 10 3 4
  % 2 3 4 5
  % 3 4 5 6
  A(1:2:end)=0
  % 0 10 0 4
  % 2 0 4 0
  % 0 4 0 6
  A([3,5,6])=[8 88 888]
  % 0 10 0 4
  % 2 88 4 0
  % 8 888 0 6
  

• 如果赋值时将一个或多个元素置于矩阵现有的行和列索引的边界之外，则会将矩阵的大小进行拓展，matlab会将没有赋值的位置的元素自动用0填充。
• 还可通过在现有索引范围之外插入一个新的矩阵来拓展原始矩阵的大小

  A=[10 20 30
     60 70 80]
  A(3,4)=88
  % 10 20 30 0
  % 60 70 80 0 
  % 0  0  0  88
  
  A(4:5,5:6)=[2 3;4 5]
  % 10 20 30 0  0  0
  % 60 70 80 0  0  0
  % 0  0  0  88 0  0
  % 0  0  0  0  2  3
  % 0  0  0  0  4  5

• 删除矩阵元素
• 矩阵删除只能对整行或整列进行操作，否则会报错 

  A=[1:4,2:5,:3:6]
  % 1 2 3 4
  % 2 3 4 5
  % 3 4 5 6
  A(:,1)=[]     %删除第一列
  % 2 3 4
  % 3 4 5
  % 4 5 6
  A(:,[2,end])=[]    %删除第二列和最后一列
  % 1 3 
  % 2 4 
  % 3 5 
  A(2,2)=[]    %matlab报错；空赋值只能具有一个非冒号索引
  A([1,3],[1,2])=[]    %matlab报错；空赋值只能具有一个非冒号索引

• 用线性索引删除矩阵元素
  • 使用线性索引删除后，matlab会将矩阵中剩下的元素按照线性索引的顺序放入一个向量中。
  • 使用线性索引删除矩阵元素，可以删除任意位置的元素，不需要删除矩阵的一整行或者一整列。 

    A=[1:4,2:5,:3:6]
    % 1 2 3 4
    % 2 3 4 5
    % 3 4 5 6
    A(1:3)=[]
    % 2 3 4 3 4 5 4 5 6
    A(1:4)=[]
    % 3 4 3 4 5 4 5 6 

1.4矩阵的拼接和重复 

• 横向拼接要求矩阵的行数相同；纵向拼接要求矩阵的列数相同。
• 横向拼接  [A,B] 或 [A B] 或 horzcat(A,B) 或 cat(2,A,B)
• 纵向拼接 [A;B] 或vertcat(A,B) 或 cat(1,A,B)
• cat函数
  • cat(dim,A,B)表示沿着维度dim方向将矩阵B拼接到矩阵A的末尾
  • dim=1时表示沿着行方向从上往下拼接，即纵向拼接，则cat(1,A,B)=vertcat(A,B)
  • dim=2时表示沿着列方向从左往右拼接，即横向拼接，则cat(2,A,B)=horzcat(A,B)
• 若横向拼接时矩阵行数不同，或纵向拼接时矩阵列数不同，那么matlab运行时会报错。（维度不一致）
• 若要拼接的矩阵的个数大于2，也能用上面的方法进行拼接

  A=ones(2)
  B=zeros(2)
  C=eye(2)
  % A= 1 1    B= 0 0    C= 1 0
  %    1 1       0 0       0 1
  [A,B,C]
  [A B C]
  cat(2,A,B,C)
  horzcat(A,B,C)
  % 1 1 0 0 1 0
  % 1 1 0 0 0 1
  [A;B;C]
  [A
   B 
   C]
  cat(1,A,B,C)
  vertcat(A,B,C)
  % 1 1
  % 1 1
  % 0 0
  % 0 0
  % 1 0
  % 0 1

•  对同一个矩阵进行重复的堆叠 repmat(A,m,n)

  A=[1 2
     3 4]
  B=repmat(A,2,3)
  % 1 2 1 2 1 2
  % 3 4 3 4 3 4
  % 1 2 1 2 1 2
  % 3 4 3 4 3 4

• 对向量或矩阵的元素进行重复 repelem
  • 重复向量v中的元素：repelem(v,n)
    • n为一个正整数，表示把向量v中的每一个元素都重复n次
    • n为一个向量，长度必须与v的长度相同，将v中第i个位置的元素v(i)重复n(i)次，其中n(i)表示n中第i个位置的元素。

      v=[5,3,8]
      repelem(v,2)    % 5 5 3 3 8 8
      repelem(v,[2,1,4])    % 5 5 3 8 8 8 8

  • 重复矩阵A中的元素：repelem(A,m,n)
    • m和n分别表示沿着行方向（从上至下）以及沿着列方向（从左至右）将矩阵元素重复的次数。m和n可以是正整数，也可以是向量。
    • 若m是向量，则m的长度要和矩阵A的行数相同。
    • 若n是向量，则n的长度要和矩阵A的列数相同。

      A=[2,3,5;
         8,4,7]
      repelem(A,3,2)
      % 2 2 3 3 5 5
      % 2 2 3 3 5 5
      % 2 2 3 3 5 5
      % 8 8 4 4 7 7
      % 8 8 4 4 7 7
      % 8 8 4 4 7 7
      repelem(A,2,[1,2,3])
      % 2 3 3 5 5 5
      % 2 3 3 5 5 5
      % 8 4 4 7 7 7
      % 8 4 4 7 7 7
      repelem(A,[2,3],[1,2,3])
      % 2 3 3 5 5 5
      % 2 3 3 5 5 5
      % 8 4 4 7 7 7
      % 8 4 4 7 7 7
      % 8 4 4 7 7 7

1.5矩阵的重构和重新排列

（1）reshape函数 

• 改变矩阵的形状
• reshape(A,m,n) 或者 reshape(A,[m,n])
• 可将矩阵A的形状更改为m行n列，前提是转换前后的两个矩阵的元素总数相同。
• reshape函数是按矩阵的线性索引来重新组织矩阵元素的，因此，转换后B矩阵中的元素与A矩阵中的元素是完全相同的。
• matlab会自动计算转换后的矩阵大小
  • 可以只给出转换后的行数/列数，另一个变量用空向量[ ]代替

    A=randi(10,2,6)
    % 2 2 10 3 5 1
    % 4 1 4 4 7 9
    B=reshape(A,3,4)
    % 2 1 3 7
    % 4 10 4 1
    % 2 4 5 9
    A=randi(10,3,6)
    B=reshape(A,5,8)    %3X6≠5X8，元素总数不匹配，无法转换
    A=randi(10,3,6)
    B=reshape(A,[],8)    %3X6不等于8的倍数，无法转换出整数倍的行数
    

（2）sort函数 

• 对向量或矩阵进行排序
• 对向量排序        
  • sort(v)  将向量v按照从小到大的顺序进行升序排列
  • sort(v,'descend') 将向量v按照从大到小的顺序进行降序排列
  • [sort_v,ind]=sort(v) sort_v是排序后的向量，ind是排序后的向量中每个元素在原向量中的索引

    v=[10 24 16 8 50 40]
    v1=sort(v)    % 8 10 16 24 40 50
    v2=sort(v,'descend')    % 50 40 24 16 10 8
    [sort_v,ind]=sort(v)    %sort_v=[8 10 16 24 40 50]
                            %ind=[4 1 3 2 6 5]
    v=[5;-5;7;0;4;5]    
    v1=sort(v)    
    % -5
    %  0
    %  4
    %  5
    %  5
    %  7
    
    

• 对矩阵排序
  • sort(A,dim)
    • dim=1时，沿着行方向（从上至下）对矩阵的每一列升序排列
    • dim=2时，沿着列方向（从左至右）对矩阵的每一行升序排列
      • 当dim=1时，sort(A,1)可以直接写成sort(A)
      • 默认时升序排列，可以在最后面加入一个参数“descend”来降序排列
      • 可以有两个返回值，与向量的返回值类似，表示排序后的元素在原矩阵所在行或所在列中的索引

A=randi(10,4,6)
%4 1 8 7 8 2
%3 7 8 6 4 2
%8 7 8 4 7 6
%1 6 3 1 8 5

sort(A)
sort(A,1)    %对每一列的元素进行升序排列
% 1 1 3 1 4 2
% 3 6 8 4 7 2
% 4 7 8 6 8 5
% 8 7 8 7 8 6

sort(A,2)     %对每一行的元素进行升序排列
% 1 2 4 7 8 8
% 2 3 4 6 7 8 
% 4 6 7 7 8 8
% 1 1 3 5 6 8

sort(A,'descend')    %对每一行的元素进行降序排列
% 8 8 7 4 2 1
% 8 7 6 4 3 2
% 8 8 7 7 6 4
% 8 6 5 3 1 1

A=[ 4 1 8 7 8 2;
    3 7 8 6 4 2;
    8 7 8 4 7 6;
    1 6 3 1 8 5;]
[sort_A,ind]=sort(A)     %返回两个值
% sort_A=
%     1 1 3 1 4 2
%     3 6 8 4 7 2
%     4 7 8 6 8 5
%     8 7 8 7 8 6
% ind=
%    4 1 4 4 2 1
%    2 4 1 3 3 2
%    1 2 2 2 1 4
%    3 3 3 1 4 3

（3）sortrows 函数

• 基于矩阵的某一列对矩阵进行排序，排序后的新矩阵的同一行元素不会改变。
• sortrows(A) 基于第一列的元素按升序排序。若第一列元素相同，则基于第二列的元素升序排序，若第二列还相同，则基于第三列的元素升序排序，以此类推。等价于sortrows(A,1:size(A,2))
• sortrows(A,n) 基于第n列的元素按升序排列。当第n列的元素相同时，保持其在矩阵中出现的先后顺序。
• sortrows(A,[m,n]) 基于第m列的元素按升序排列。当第m列的元素相同时，则基于第n列的元素升序排序,若第m列和第n列元素相同时，保持其在矩阵中出现的先后顺序。
• 默认时升序排列，可以在最后面加入一个参数“descend”来降序排列，即sortrows(A,n,'descend');可以是用元胞数组分别表示多个列的方向,即sortrows(score,[1,3],{'descend','ascend'})
• [ sort_A,ind]=sortrows(A,n)  ind表示基于第n列排序的新矩阵对应元素在原矩阵中的行索引

  score=[95 80 85 79;
         95 67 78 90;
         95 67 78 75;
         95 67 64 73;
         86 85 82 84;
         86 87 84 88;]
  
  sort_score1=sortrows(score)
  %等价于sortrows(score,1:size(score,2)),即sortrows(score,[1,2,3,4])
  % 86 85 82 84
  % 86 87 84 88
  % 95 67 64 73
  % 95 67 78 75
  % 95 67 78 90
  % 95 80 85 79
  
  sort_score2=sortrows(score，2)
  % 95 67 78 90
  % 95 67 78 75
  % 95 67 64 73
  % 95 80 85 79
  % 86 85 82 84
  % 86 87 84 88
  
  sort_score3=sortrows(score，[1,3])
  % 86 85 82 84
  % 86 87 84 88
  % 95 67 64 73
  % 95 67 78 90
  % 95 67 78 75
  % 95 80 85 79
  
  sort_score4=sortrows(score,[1,3],'descend')
  % 95 80 85 79
  % 95 67 78 90
  % 95 67 78 75
  % 95 67 64 73
  % 86 87 84 88
  % 86 85 82 84
  
  sort_score5=sortrows(score,[1,3],{'descend','ascend'})
  % 95 67 64 73
  % 95 67 78 90
  % 95 67 78 75
  % 95 80 85 79
  % 86 85 82 84
  % 86 87 84 88
  
  [sort_score6,ind6]=sortrows(score,1)
  % sort_score6=        ind6=
  %    86 85 82 84        5
  %    86 87 84 88        6
  %    95 80 85 79        1
  %    95 67 78 90        2
  %    95 67 78 75        3
  %    95 67 64 73        4
  

• sortrows函数与sort函数区别
  • sort函数对矩阵的每一列分别进行排序；常用于向量排序。
  • sortrows函数是基于某一列进行排序的，排序后的新矩阵的同一行的元素不会改变；常用于表格数据或矩阵排序

%sort和sortrows的区别
A=randi(10,4,6)
% 4 1 8 7 8 2
% 3 7 8 6 4 2
% 8 7 8 4 7 6
% 1 6 3 1 8 5

sort(A)
% 1 1 3 1 4 2
% 3 6 8 4 7 2
% 4 7 8 6 8 5
% 8 7 8 7 8 6

sortrows(A) %sortrows(A,1:6)
% 1 6 3 1 8 5
% 3 7 8 6 4 2
% 4 1 8 7 8 2
% 8 7 8 4 7 6

（4）flip/fliplr/flipud函数 

• 对向量或矩阵进行翻转操作
• flip(A)
  • 如果A=向量，flip(A)将翻转向量中各元素的顺序，向量的方向不变。
  • 如果A=矩阵，flip(A)将矩阵进行上下翻转

    A=[5 2 7 8 9]
    flip(A)    %A(end:-1:1)    9 8 7 2 5
    
    A=[5;2;7;8;9]
    flip(A) 
    % 9
    % 8
    % 7
    % 2
    % 5
    
    A=[5 8 7;
       4 2 6;
       3 5 8;
       6 4 1]
    flip(A) 
    % 6 4 1
    % 3 5 8
    % 4 2 6
    % 5 8 7

• flip(A,dim)
• flip(A,dim)沿维度dim翻转A中元素的顺序
  • dim为1时表示行，flip(A,1)将沿着行方向对矩阵A上下翻转
  • dim为2时表示行，flip(A,2)将沿着列方向对矩阵A左右翻转

    A=[5 8 7;
       4 2 6;
       3 5 8;
       6 4 1]
    flip(A,1)
    % 6 4 1
    % 3 5 8
    % 4 2 6
    % 5 8 7
    flip(A,2)
    % 7 8 5
    % 6 2 4
    % 8 5 3
    % 1 4 6

• 上下翻转：flip(A)、flip(A,1)、flipud(A)
• 左右翻转：flip(A,2)、fliplr(A)

（5）rot90函数

• 对矩阵进行旋转的函数，按90度或其倍数逆时针旋转矩阵
• rot90(A,k)将矩阵A按逆时针方向旋转k*90度，其中k是一个整数；没有k时，默认k=1。

  A=[5 8 7;
     4 2 6;
     3 5 8;
     6 4 1]
  
  rot90(A)    %等价于rot90(A,1),旋转90°
  % 7 6 8 1
  % 8 2 5 4
  % 5 4 3 6
  
  rot90(A,2)    %旋转180°
  % 1 4 6
  % 8 5 3
  % 6 2 4
  % 7 8 5
  
  rot90(A,3)    %旋转270°，等价于顺时针旋转90°
  % 6 3 4 5
  % 4 5 2 8
  % 1 8 6 7