Matlab简单入门

文章目录

  • 一、基础阶段
    • (一)数据类型
      • 1.数值类型
      • 2.逻辑类型
      • 3.字符和字符串
      • 4.函数句柄
      • 5.单元数组类型
      • 6.结构体类型
    • (二)运算符
      • 1.算数运算符
      • 2.关系运算符
      • 3.逻辑运算符
      • 4.运算优先级
  • 二、数组和矩阵分析
    • (一)数组及其函数
      • 1.数组的建立
      • 2.数组元素的引用
      • 3.算数运算
      • 4.关系运算
      • 5.逻辑运算
      • 6.相关函数
    • (二)矩阵及其函数
      • 1.矩阵的创建
        • 直接创建
        • 函数创建
          • 全零矩阵zeros( )
          • 全一矩阵ones( )
          • 单位矩阵eye( )
          • 0~1间均匀分布的随机矩阵rand( )
          • 标准正态分布随机矩阵randn( )
          • 魔方矩阵magic( )
          • 范得蒙矩阵vander(V)
      • 2.矩阵元素的引用(见二(一)2)
      • 3.矩阵的基本操作
        • 矩阵的扩展
        • 矩阵的块操作
        • 矩阵元素的删除
        • 矩阵的转置
        • 矩阵的翻转
        • 矩阵尺寸的改变
      • 4.矩阵的基本数值运算
        • 矩阵的加减运算
        • 矩阵的乘法运算
        • 矩阵的除法运算
        • 矩阵的元素查找
        • 矩阵元素的排序
        • 矩阵元素的求和
        • 矩阵元素的求积

一、基础阶段

(一)数据类型

MATLAB中有15种基本的数据类型,分别是:8种数据整型、单精度浮点型、双精度浮点型、逻辑型、字符串型、单元数组、结构体类型和函数句柄。

如下表所示:

基本数据类型 说明
int8、int16、int32、int64 有符号整型(分别占1、2、4、8字节)
uint8、uint16、uint32、uint64 无符号整型(分别占1、2、4、8字节)
Single 单精度浮点型(占4字节)
Double 双精度浮点型(占8字节)
Logical 逻辑型(1字节)
Char 字符串型(占2字节)
Cell 单元数组型
struct 结构体型
Function_handle 函数句柄型

其中,双精度浮点型为默认的数据类型,数据类型可以通过函数进行转换。

1.数值类型

我们将整数浮点数统称为数值类型。

整数分为有符号整数(型)无符号整数(型),浮点数分为单精度浮点数(型)双精度浮点数(型)

默认的数值类型为双精度浮点型,一般通过整型函数将浮点型数据转换为整型数据。

>> x = 1

>> y = int8(x)

>> whos
  Name      Size            Bytes  Class     Attributes

  x         1x1                 8  double              
  y         1x1                 1  int8 

当我们对浮点数进行取整操作时,可以采用不同的方法将小数转换为整数。

如下表介绍了四种浮点数的取整函数

函数 作用
round 向最接近的整数取整,若小数为0.5,则取绝对值大的整数
fix 向0取整
floor 取不大于该数的最接近整数
ceil 取不小于该数的最接近整数

复数

复数也属于数值类型,是对实数的扩展,包含实部和虚部两部分。

在MATLAB中,采用ij来表示虚部的单位。

产生复数的两种方法:

  1. 采用赋值语句直接产生复数: z1=3+4j
  2. 采用函数complex( )产生复数: z2=complex(3,4)

复数的常用函数如下表所示:

函数 作用
complex(a, b) 创建复数,a为 实部,b为 虚部
real(z) 得到复数z的 实部
imag(z) 得到复数z的 虚部
abs(z) 得到复数z的 模
angle(z) 得到复数z的 角度
conj(z) 得到复数z的 共轭复数

2.逻辑类型

逻辑类型数据只有逻辑真逻辑假两种。

MATLAB中用1代表逻辑真,用函数true表示;用0代表逻辑假,用函数false表示。逻辑真和逻辑假都占用1个字节的存储空间。

>> a=true

a =

  logical

   1

>> b=false

b =

  logical

   0

>> c=true(3,4)

c =

  3×4 logical 数组

   1   1   1   1
   1   1   1   1
   1   1   1   1

>> d=false(4)

d =

  4×4 logical 数组

   0   0   0   0
   0   0   0   0
   0   0   0   0
   0   0   0   0

>> whos
  Name      Size            Bytes  Class      Attributes

  a         1x1                 1  logical              
  b         1x1                 1  logical              
  c         3x4                12  logical              
  d         4x4                16  logical              

>> 

还可以采用函数logical( )数值型 转换逻辑型,任何非0数值转换为逻辑真(即1);数值0转换为逻辑假(即0)。

>> a=[0:5;3,4,0,0,0,1]

a =

     0     1     2     3     4     5
     3     4     0     0     0     1

>> a=logical(a)

a =

  2×6 logical 数组

   0   1   1   1   1   1
   1   1   0   0   0   1

>> 

3.字符和字符串

在MATLAB中,字符型数据类型用char表示。字符和字符串不进行区分,都用一对单引号括起来。字符串中的每个字符占用2个字节的存储空间。

>> A='my name is 张三'

A =

    'my name is 张三'

>> B=char(0x59dc)  % unicode码16进制

B =

    '姜'

>> C=int8('JXQ')

C =

  1×3 int8 行向量

   74   88   81    % Unicode码10进制

>> 

4.函数句柄

函数句柄包含了函数的路径、函数名、类型以及可能存在的重载方法。通过函数句柄来间接调用函数,函数句柄的数据类型为function_handle。

函数句柄可以通过符号@后面跟函数命令来创建,例如程序fhandle=@cos,创建了函数cos( )函数句柄,以后就可以通过函数句柄fhandle间接调用函数cos( )

>> C = int8('A')

C =

  int8

   65

>> B='你好'

B =

    '你好'

>> fhandle=@int8

fhandle =

  包含以下值的 function_handle:

    @int8

>> fhandle(B)

ans =

  1×2 int8 行向量

   127   127

>> 

使用函数句柄的好处:

  1. 提高运行速度。

    因为matlab对函数的调用每次都是搜索所有的路径,从path中我们可以看到,路径是非常多的,所以如果一个函数在你的程序中如果经常被使用,使用函数句柄,对运行速度会有提高

  2. 使用可以与变量一样方便。

    比如说,我在这个目录中创建了本目录中的一个函数句柄,当我转到其他目录下的时候,创建的函数句柄还是可以直接使用的,而不需要把那个函数文件拷贝过来,因为函数句柄中已经包含了路径

函数句柄的常用函数

函数 作用
func2str(fhandle) 将函数句柄转换为字符串
str2func(str) 将字符串转换为函数句柄
functions(fhandle) 返回函数句柄包含的函数信息的结构体变量
isa(a, ‘function_handle’) 判断a是否为函数句柄
isequal(fhandle1, fhandle2) 检测两个函数句柄是否对应同一个函数

5.单元数组类型

单元数组是一种比较特殊的数据类型,每个元素都以单元的形式存在。

在MATLAB中,采用大括号{}建立单元数组,也可以采用函数cell( )来建立单元数组。

在获取单元数组的元素时,也采用大括号表示下标

创建单元数组:

  1. 直接创建

    >> a={1,'hello','中国'}
    
    a =
    
      1×3 cell 数组
    
        {[1]}    {'hello'}    {'中国'}
    
    >> 
    
  2. 函数创建

    >> a = cell(3)
    
    a =
    
      3×3 cell 数组
    
        {0×0 double}    {0×0 double}    {0×0 double}
        {0×0 double}    {0×0 double}    {0×0 double}
        {0×0 double}    {0×0 double}    {0×0 double}
    
    >> 
    

单元数组的引用:

>> a={1,'a','b',2}

a =

  1×4 cell 数组

    {[1]}    {'a'}    {'b'}    {[2]}

>> a{1,1}

ans =

     1

>> a{1,2}

ans =

    'a'

>> 

6.结构体类型

结构体是按照成员变量名组织起来的不同数据类型数据集合

结构体类似于C语言结构体数据。每个成员变量用指针操作符“.”表示,例如A.name表示结构体变量Aname成员变量。

创建结构体变量:

>> struct('field1',1,'field2',2)  % 格式为:Struct('键1', 值1, '键2', 值2 ... )


ans = 

  包含以下字段的 struct:

    field1: 1
    field2: 2

>> 

引用结构体成员:

>> S=struct('A','a','B','b')

S = 

  包含以下字段的 struct:

    A: 'a'
    B: 'b'

>> x=S.A

x =

    'a'

>> 

结构体成员的更改、添加:

>> S=struct('A','a','B','b')

S = 

  包含以下字段的 struct:

    A: 'a'
    B: 'b'

>> S.C = 'c'

S = 

  包含以下字段的 struct:

    A: 'a'
    B: 'b'
    C: 'c'
    
>> S.C = 'cc'

S = 

  包含以下字段的 struct:

    A: 'a'
    B: 'b'
    C: 'cc'

>> 

我们不难发现,对结构体成员进行操作遵循的是“有则更改,无则添加”规则,所以我们可以利用这一规则直接进行结构体创建:

>> A.name = 'LiHua'; A.age=20; A.sex='man'

A = 

  包含以下字段的 struct:

    name: 'LiHua'
     age: 20
     sex: 'man'

>> 

(二)运算符

在MATLAB中,提供了丰富的运算符,其功能主要包括算数运算、关系运算和逻辑运算。

算数运算用于数值计算。关系运算和逻辑运算的返回值为逻辑型变量,其中1代表逻辑真,0代表逻辑假。

1.算数运算符

MATLAB提供的基本算术运算有:加(+)、减(-)、乘(*)、除(/)和乘方(^)。

对于数组和矩阵,是以元素为单元进行运算,将会在后面进行详细的介绍。

标量 矩阵和数组 作用
+ +
- -
* .*
/ ./ 左除右
\ .\ 右除左
^ .^ 乘方
.’ 转置

2.关系运算符

关系运算用于比较两个操作数的大小,返回值为逻辑型变量。

当2个操作数都是数组或矩阵时,这2个操作数的维数必须相同,否则会显示出错信息。

关系运算符 作用 对应函数
< 小于 lt( )
<= 小于等于 le( )
> 大于 gt( )
>= 大于等于 ge( )
== 恒等于 eq( )
~= 不等于 ne( )
>> a=1;b=2;
>> c=a>2

c =

  logical

   0

>> c=b>a

c =

  logical

   1

>> c=ge(b,a)

c =

  logical

   1

>> 

3.逻辑运算符

分为3类,分别是逐个元素的逻辑运算快速逻辑运算逐位逻辑运算

逐个元素的逻辑运算有3种,分别是逻辑与(&)、逻辑或(|)和逻辑非(~),如下表所示。

运算符 函数 作用
& and( ) 逻辑 与
| or( ) 逻辑 或
~ not( ) 逻辑 非
xor( ) 逻辑 异或

需要注意的是,在进行两个数组或矩阵的逻辑与和逻辑或时,它们必须具有相同的维数。

快速逻辑运算符有两种,逻辑与(&&)和逻辑或(||)。

  • &&运算符,在参与运算的第一个操作数为假时,立即返回假,不再计算第二个操作数。
  • || 运算符,在参与运算的第一个操作数为真时,立即返回真,不再判断第二个操作数。

逐位逻辑运算,是将数据先转化为二进制,再进行逐位逻辑运算,其运算结果自动转换为十进制数。

函数 作用
bitand(a, b) 逐位逻辑与
bitor(a, b) 逐位逻辑或
bitcmp(a, b) 逐位逻辑非
bitxor(a, b) 逐位逻辑异或

4.运算优先级

在进行运算时,按照运算符的优先级,从高到低进行运算。对于相同优先级的运算符,按照从左到右的顺序进行。

Matlab简单入门_第1张图片


二、数组和矩阵分析

(一)数组及其函数

1.数组的建立

  1. 直接创建

    [ ]来创建数组,数组中同一行元素之间用逗号空格进行分割,不同行之间用分号进行分割。

    >> a=[1, 2, 3, 4; 5, 6, 7, 8]
    
    a =
    
         1     2     3     4
         5     6     7     8
    
    >> 
    

    空数组是MATLAB中最特殊的数组,不含有任何元素,可以用于数组的声明或者清空等。

    a = []  % 创建空数组
    
  2. 冒号创建

    格式: X=N1:step:N2N1起始值N2终止值step步长。当不指定step时,系统默认step1

    >> a=2:6
    
    a =
    
         2     3     4     5     6
    
    >> b=[1:5]
    
    b =
    
         1     2     3     4     5
    
    >> 
    

    加不加中括号均可。

  3. 函数linspace()创建一维数组

    格式: x=linspace(x1,x2,N),创建行向量,起始值x1,终止值x2,总共N个元素的等差数列,不指定N时,默认100个元素。

    >> s=linspace(1,10,5)
    
    s =
    
        1.0000    3.2500    5.5000    7.7500   10.0000
    
    >> 
    
  4. 函数logspace()创建一维数组

    格式: x=logspace(x1,x2,N),创建行向量,起始值为10的x1次方终止值为10的x2次方,总共N个元素的等比数列,不指定N时,默认50个元素。

    >> s=logspace(1,2,2)
    
    s =
    
        10   100
    
    >> 
    

2.数组元素的引用

  1. 下标法引用

    在MATLAB中,数组元素的下标是从1开始的。

    通过下标访问一维数组元素的格式如下:

    A(j)
    

    A是数组名,j是列号。

    通过下标访问二维数组元素的格式如下:

    A(i,j)
    

    A是数组名,i是行号,j是列号。

    需要注意的是: ij都必须是大于等于1整数,而且不能超过数组的总行数和总列数。如果想访问最后一行或者最后一列的元素,可以将下标设置为end

    >> a=[1:5;6:10]
    
    a =
    
         1     2     3     4     5
         6     7     8     9    10
    
    >> b=a(end,end)
    
    b =
    
        10
    
    >> 
    
    >> a(end,end-2)  % 访问倒数第三个元素
    
    ans =
    
         8
    
    >> 
    
  2. 索引法引用

    所谓索引,就是元素在数组中存放的顺序号

    对于一维数组,元素从前往后挨着存储,下标为1的元素存放在第一个位置,此时索引就为1;下标为2的元素存放在第二个位置,此时索引就为2;以此类推。

    但我们需要关注的是多维数组的情况,比如二维数组由行和列构成,此时元素的存放顺序是按行存储还是按列存储呢?

    在MATLAB中,二维数组的元素是按列存储的。比如下面这个二维数组

    >> a=[1,2,3;4,5,6;7,8,9]
    
    a =
    
         1     2     3
         4     5     6
         7     8     9
    
    >> 
    

    它的元素、索引、下标的对应关系如下表所示:

    下标 元素 索引
    (1, 1) 1 1
    (1, 2) 2 4
    (1, 3) 3 7
    (2, 1) 4 2
    (2, 2) 5 5
    (2, 3) 6 8
    (3, 1) 7 3
    (3, 2) 8 6
    (3, 3) 9 9

    对于三维数组:先列后行然后页

    所以通过索引访问数组元素的格式如下:

    A(index)
    
    • A数组名,它可以是一维数组,也可以是多维数组。
    • index索引,它是一个整数,取值范围是0~numel(A)(numel这个函数用来求数组元素的个数)。

    下标也可以放在另一个数组(向量)中,这样子得到的元素将以数组的形式返回:

    A([i,j,k...])
    
  3. 布尔法引用

    MATLAB允许使用一个布尔类型矩阵来指明每个数组元素去留(保留或删除),具体的用法为:

    A(X)
    

    X是一个由0和1组成的布尔类型矩阵,且size(A) = size(X),对应位置为1留下该数据,为0去掉该数据,最后按照A存储顺序,返回一个列向量

    size()函数用来返回数组的尺寸,也就是行数列数

    对于一维数组来说,数组的行数就是1,列数就是数组元素的个数(可用numel函数计算得出)。

    >> a=[1,2,3;4,5,6;7,8,9]
    
    a =
    
         1     2     3
         4     5     6
         7     8     9
    
    >> b=[0 0 1;0 1 0;1 0 0]
    
    b =
    
         0     0     1
         0     1     0
         1     0     0
    
    >> a(b)
    数组索引必须为正整数或逻辑值。
     
    >> b=logical(b)  % 转换为布尔类型
    
    b =
    
      3×3 logical 数组
    
       0   0   1
       0   1   0
       1   0   0
    
    >> a(b)
    
    ans =
    
         7
         5
         3
    
    >> 
    

    我们还可以直接选择输出符合一些运算条件的元素:

    >> a(a>5)
    
    ans =
    
         7
         8
         6
         9
    
    >> 
    

    它的原理是:

    >> x=a>5  % 因为有了比较语句,所以返回的是布尔类型数组,符合条件的元素对应位置为1,否则为0
    
    x =
    
      3×3 logical 数组
    
       0   0   0
       0   0   1
       1   1   1
    
    >>a(x)
    
    ans =
    
         7
         8
         6
         9
    
    >> 
    

3.算数运算

运算规则:数组A和B的维数相同,则可以执行算数运算是相应元素进行运算。如果A和B的维数不相同,则MATLAB将给出错误信息,提示用户两个数组的维数不匹配。

4.关系运算

MATLAB提供了6种关系运算符:<(小于lt)、<=(小于或等于le)、>(大于gt)、>=(大于或等于ge)、==(恒等于eq)、~=(不等于ne)。

运算结果是与原数组相同维数的由0, 1组成的数组。(布尔类型)

两个原则:

  1. 当参与比较的量是两个维数相同的数组时,比较两数组相同位置的元素,并给出比较结果。
  2. 当参与比较的一个是标量,而另一个是数组时,则把标量与数组的每一个元素逐个比较。

5.逻辑运算

在MATLAB中,提供了3种逻辑运算符,分别是&(逻辑与)、|(逻辑或)和~(逻辑非)。

在逻辑运算中,如果为非零元素则为逻辑真,用1表示,零元素为逻辑假,用0表示。

6.相关函数

函数 作用
isempty(A) 检测数组是否为空,如果为空,返回值为1,否则,返回值为0。
isscalar(A) 检测数组是否为单个元素的标量。
isvector(A) 检测数组是否为行向量或列向量。
isrow( ) 检测数组是否为列向量。
iscolum( ) 检测数组是否为行向量。
issparse( ) 检测数组是否为稀疏矩阵。
size( ) 获取数组的行数和列数。
length( ) 获取一维数组的长度,如果是二维数组,则返回行数和列数中的较大者 。
ndims( ) 计算数组的维度。
find( ) 返回关系表达式为真的元素的下标。
sort( ) 默认按照升序排列,返回值为排序后的数组,和原数组维数相同。

(二)矩阵及其函数

矩阵就是二维数组,但矩阵内只能是数字。

1.矩阵的创建

  1. 直接创建

    例如: 生成一个2x3的矩阵:

    >> a=[1,2,3;4,5,6]
    
    a =
    
         1     2     3
         4     5     6
    
    >> b=[2:3:11;4:2:10]
    
    b =
    
         2     5     8    11
         4     6     8    10
    
  2. 函数创建

    • 全零矩阵zeros( )

      A=zeros(N):该函数产生N行N列的全零矩阵。

      >> a=zeros(3)
      
      a =
      
           0     0     0
           0     0     0
           0     0     0
      

      A=zeros(M, N):该函数产生M行N列的全零矩阵。

      A=zeros(size(B)):该函数产生和矩阵B维数相同的全零矩阵。

    • 全一矩阵ones( )

      该函数的调用格式和函数zeros( )一致。

      >> a=ones(3)
      
      a =
      
           1     1     1
           1     1     1
           1     1     1
      
    • 单位矩阵eye( )

      A=eye(N):该函数产生N行N列的单位矩阵。

      >> a=eye(3)
      
      a =
      
           1     0     0
           0     1     0
           0     0     1
      

      A=eye(M, N):该函数产生M行N列的矩阵,对角线元素为1,其余元素均为0

      A=eye(size(B)):该函数产生和矩阵B维数相同的单位矩阵。

    • 0~1间均匀分布的随机矩阵rand( )

      A=rand(N):产生N行N列的0~1之间均匀分布的随机矩阵。

      >> a=rand(3)
      
      a =
      
          0.8147    0.9134    0.2785
          0.9058    0.6324    0.5469
          0.1270    0.0975    0.9575
      

      A=rand(M, N):产生M行N列的0~1之间均匀分布的随机矩阵。

      A=rand(size(B)):产生和矩阵B维数相同的0~1之间均匀分布的随机矩阵。

    • 标准正态分布随机矩阵randn( )

      采用函数randn( )产生均值为0方差为1标准正态分布随机矩阵。该函数的调用格式和函数rand( )基本一致。

      >> a=randn(3)
      
      a =
      
          2.7694    0.7254   -0.2050
         -1.3499   -0.0631   -0.1241
          3.0349    0.7147    1.4897
      
    • 魔方矩阵magic( )

      魔方矩阵中每行每列及两条对角线上的元素和都相等。对于n阶魔方阵,其元素由1,2,3,…,n2组成,共n2个整数。

      >> a = magic(3)
      
      a =
      
           8     1     6
           3     5     7
           4     9     2
      
    • 范得蒙矩阵vander(V)

      范得蒙矩阵最后一列全为1倒数第二列为一个指定的向量,其他各列是其后列与倒数第二列点乘积。可以用一个指定向量生成一个范得蒙矩阵。

      >> a=vander([1,2,3,4,5])
      
      a =
      
           1     1     1     1     1
          16     8     4     2     1
          81    27     9     3     1
         256    64    16     4     1
         625   125    25     5     1
      

2.矩阵元素的引用(见二(一)2)

需要注意的是: 对矩阵中的元素进行赋值,如果行或者列超出矩阵的大小,则MATLAB自动扩充矩阵的大小,然后再进行赋值,扩充部分用填充。

3.矩阵的基本操作

  1. 矩阵的扩展

    可以通过矩阵的扩展,将多个小矩阵转换为大的矩阵。进行矩阵连接的函数有函数cat( )、函数vertcat( )和函数horzcat( )

    • C=cat(DIM, A, B):该函数在DIM维度上进行矩阵A和B的连接,返回值为连接后的矩阵。(DIM=1水平方向连接;DIM=2垂直方向连接。)
    • C=vertcat(A, B):该函数在水平方向上连接数组A和B,相当于cat(1, A, B)
    • C=horzcat(A, B):该函数在垂直方向上连接数组A和B,相当于cat(2, A, B)
  2. 矩阵的块操作

    通过函数repmat( )、函数blkdiag( )和函数kron( )进行矩阵的块操作

    repmat( ):进行数据块的复制,该函数的调用格式为:

    • B=repmat(A, m, n):该函数产生大的矩阵B,把矩阵A当作单个元素,产生由m行和n列的矩阵A组成的大矩阵B。
    • B=repmat(A, m):该函数产生大的矩阵B,把矩阵A当作单个元素,产生m行和m列的矩阵A组成的大矩阵B。

    blkdiag( ):将多个矩阵作为对角块,产生新的矩阵。调用格式为:

    • Y=blkdiag(A, B):该函数将矩阵A和B作为对角块,产生新的矩阵Y。
    • Y=blkdiag(A, B, …):该函数将多个矩阵作为对角块,产生新的矩阵。

    kron( ):将其中一个矩阵中每个元素乘以另一个矩阵。

    • 调用格式: Y=kron(a,b)

    • 如果a2行2列的矩阵,则:

       Y=
           a(1,1)*b      a(1,2)*b
           a(2,1)*b      a(2,2)*b
      
  3. 矩阵元素的删除

    利用空矩阵删除矩阵的元素,空矩阵为一对方括号[]

    矩阵赋值为空矩阵的语句为X=[]

    注意:X=[]clear X不同,clear是将X工作空间中删除,而空矩阵则存在于工作空间中,只是维数为0

    >> b=[2:3:11;4:2:10]
    
    b =
    
         2     5     8    11
         4     6     8    10
     
    >> b(:,2)=[]  % 删除第二列元素
    
    b =
    
         2     8    11
         4     8    10
    
    >> 
    
  4. 矩阵的转置

    最简单的是采用转置操作符,从而实现矩阵A转置为A’。如果矩阵中含有复数,则进行矩阵转置后,复数转化为共轭复数

    还有一种转置是A.’,即使为复数,也不转换为共轭。也可以采用函数transpose(A)来实现,两者完全一致。

  5. 矩阵的翻转

    左右翻转: fliplr(A)

    上下翻转: flipud(A)

    此外,还可以采用函数flipdim( )进行矩阵的翻转。

    该函数的调用格式为flipdim(A, k),该函数在指定的方向k进行矩阵的翻转。

    • k=1时,相当于flipud(A)
    • k=2时,相当于fliplr(A)
  6. 矩阵尺寸的改变

    在矩阵总元素保持不变的前提下,用函数reshape()改变矩阵的尺寸。

    该函数的调用格式为:Y=reshape(X, m, n),将矩阵转换为m行n列的二维矩阵。矩阵的总元素数不变。

    b =
    
         2     8    11
         4     8    10
     
    >> Y=reshape(b,3,2)
    
    Y =
    
         2     8
         4    11
         8    10
    

4.矩阵的基本数值运算

  1. 矩阵的加减运算

    假定有两个矩阵AB,则可以由A+BA-B实现矩阵的加减运算,要求矩阵AB维数必须相同

    矩阵的加法减法是矩阵中对应元素加减。如果运算中有一个为标量,则将矩阵中的每一个元素和该标量进行加减运算

    >> a=[1,3;2,4;5,6];b=[2,3;4,1;7,2];
    >> c=a+b
    
    c =
    
         3     6
         6     5
        12     8
    
    >> d=a-b
    
    d =
    
        -1     0
        -2     3
        -2     4
    
    >> e=a+1
    
    e =
    
         2     4
         3     5
         6     7
    
  2. 矩阵的乘法运算

    A*B: 要求矩阵A列数和矩阵B行数必须相等

    >> a=[1,2;3,4;5,6];b=[4 5 6;7 8 9];
    >> c=a*b
    
    c =
    
        18    21    24
        40    47    54
        62    73    84
    

    A.*B: 表示矩阵AB对应元素相乘,要求矩阵A和B具有相同的维数,返回结果和原矩阵有相同的维数

    >> a=[1,2; 3,4; 5,6];b=[4 5; 6 7; 8 9];
    >> c=a.*b
    
    c =
    
         4    10
        18    28
        40    54
    
  3. 矩阵的除法运算

    X=A\B: 矩阵A和B的左除,表示方程组A*X=B的解。

    X=B/A: 矩阵A和B的右除,表示线性方程组X*A=B的解。

    此外,还有矩阵的点除,采用“./”“.\”表示,表示两个矩阵中对应元素相除

  4. 矩阵的元素查找

    采用函数find( )进行矩阵元素的查找。

    函数find( )通常和关系运算逻辑运算相结合,能够对矩阵中的元素进行查找。

    该函数的调用格式为:

    • i=find(A):该函数查找矩阵中的非零元素,函数返回这些元素的索引。

    • [i,j]=find(A):该函数查找矩阵中的非零元素,函数返回这些元素的下标,i是行,j是列。

      >> a=[0,1,2;0 0 0]
      
      a =
      
           0     1     2
           0     0     0
      
      >> [i,j]=find(a)
      
      i =
      
           1
           1
      
      
      j =
      
           2
           3
           
      % 将i与j综合看,第一行第二列、第一行第三列的元素非零。
      
  5. 矩阵元素的排序

    sort( ):默认按照升序排列,返回排序后的矩阵。

    • Y=sort(X):对矩阵按照升序进行排列,此时就等于Y=sort(X, 1)

    • Y=sort(X, DIM):该函数返回在给定的维数上的按照由小到大的顺序排序后的结果。

      DIM=1时,每一发生排序。

      >> a=magic(3)
      
      a =
      
           8     1     6
           3     5     7
           4     9     2
      
      >> Y=sort(a,1)
      
      Y =
      
           3     1     2
           4     5     6
           8     9     7
      

      DIM=2时,每一发生排序。

      >> a=magic(3)
      
      a =
      
           8     1     6
           3     5     7
           4     9     2
      
      >> Y=sort(a,2)
      
      Y =
      
           1     6     8
           3     5     7
           2     4     9
      
    • Y=sort(X, DIM, ‘MODE’):参数MODE默认值为ascend,即按照升序进行排列;当MODE为descend时,对矩阵进行降序排列。

  6. 矩阵元素的求和

    Y=sum(X, DIM):该函数返回在给定的维数DIM上的元素的和。(DIM不写默认为1)

    DIM=1时,计算矩阵各元素的和。

    >> e
    
    e =
    
         2     4
         3     5
         6     7
    
    >> b=sum(e)
    
    b =
    
        11    16
    

    DIM=2时,得到矩阵各元素的和。

    >> e
    
    e =
    
         2     4
         3     5
         6     7
    
    >> b=sum(e,2)
    
    b =
    
         6
         8
        13
    

    函数cumsum( )的调用格式和函数sum( )类似,不同之处是函数cumsum( )的返回值为矩阵。

    >> a=magic(3)
    
    a =
    
         8     1     6
         3     5     7
         4     9     2
    
    >> b=cumsum(a)
    
    b =
    
         8     1     6
        11     6    13
        15    15    15
    
    >> b=cumsum(a,2)
    
    b =
    
         8     9    15
         3     8    15
         4    13    15
    
  7. 矩阵元素的求积

    Y=prod(X, DIM):该函数返回在给定的维数上的元素的积。(DIM不写默认为1)

    DIM=1时,计算矩阵各元素的积。

    DIM=2时,得到矩阵各元素的积。

    >> e
    
    e =
    
         2     4
         3     5
         6     7
    
    >> f=prod(e)
    
    f =
    
        36   140
    
    >> f=prod(e,2)
    
    f =
    
         8
        15
        42
    

    函数cumprod( )的调用格式和函数prod( )类似,不同之处是函数cumprod( )的返回值为矩阵。

    >> f=cumprod(e)
    
    f =
    
         2     4
         6    20
        36   140
    

你可能感兴趣的:(matlab)