矩阵

删除例题2中第1、3、5、7行以及第3、8列。

clc;clear;
a=ones(10);  
for i=2:10    
     a(i,:)=i; 
 end
 a( 1:2:7 , :)  = [ ];
 a( : , [3 8] ) = [ ]; %体会[]与：的运用
 a

矩阵与某数字相加，所有元素全部加上这个数字，构成新矩阵。数字相减也是一样
数字与矩阵相乘，也是所有元素全部乘以这个数字，构成新矩阵。除法也是

创建、串联和扩展矩阵

创建、串联和扩展矩阵
串联矩阵
可以使用方括号将现有矩阵连接在一起。这种创建矩阵的方法称为串联。
要串联两个矩阵，它们的大小必须兼容。也就是说，水平串联矩阵时，它们的行数必须相同。垂直串联矩阵时，它们的列数必须相同。
串联矩阵的另一种方法是使用串联函数，如 horzcat，它可以水平串联两个兼容的输入矩阵。

扩展矩阵

通过将一个或多个元素置于现有行和列索引边界之外，可以将它们添加到矩阵中。MATLAB 会自动用 0 填充矩阵，使其保持为矩形。例如，创建一个 2×3 矩阵，然后在 (3,4) 的位置插入一个元素，使矩阵增加一行一列。
1
2
3
4
5
6
7
8
9
A = [10 20 30; 60 70 80]
%A = 2×3
10 20 30
60 70 80
A(3,4) = 1
%A = 3×4
10 20 30 0
60 70 80 0
0 0 0 1

可以通过在现有索引范围之外插入新矩阵来扩展其大小。

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

要重复扩展矩阵的大小，例如在 for 循环中，通常最好要为预计创建的最大矩阵预分配空间。如果没有预分配空间，MATLAB 必须在每次大小增加时分配内存，因此会降低操作速度。例如，通过将矩阵的元素初始化为零，预分配一个最多容纳 10000 行和 10000 列的矩阵。A = zeros(10000,10000);
如果之后还要预分配更多元素，可以通过在矩阵索引范围之外指定元素或将另一个预分配的矩阵与 A 串联来进行扩展。
- 就是先定义一个大小矩阵

基本运算的兼容数组大小

基本运算的兼容数组大小
大多数二元（两个输入）运算符和函数都支持具有兼容大小的数值数组。对于每个维度，如果两个输入的维度大小相同或其中一个为 1，则这些输入将具有兼容的大小。以最简单的情况为例，如果两个数组大小完全相同或其中一个为标量，则这两个数组大小是兼容的。执行按元素运算或函数时，MATLAB 会将大小兼容的数组隐式扩展为相同的大小。

大小不兼容的输入

不兼容的输入的大小无法隐式扩展为相同的大小。例如：
- 其中一个维度大小不相等，并且维度大小均不为 1。
  - A: 3-by-2
  - B: 4-by-2
- 两个长度不相同的非标量行向量。
  - A: 1-by-3
  - B: 1-by-4

大小兼容的输入

二维输入

以下是一些具有兼容大小的标量、向量和矩阵的组合：

多维数组

空数组

对于空数组或维度大小为零的数组，规则是相同的。不等于 1 的维度大小确定输出的大小。这意味着，大小为零的维度必须与另一个数组中大小为 1 或 0 的维度进行配对，并且输出的维度大小为 0。
- A: 1-by-0
- B: 3-by-1
- Result: 3-by-0

attention

要简化向量-矩阵运算，请对维函数（例如 sum、mean、min 以及其他）使用隐式扩展。
行向量和列向量相加
- 行向量和列向量的大小兼容，当您对它们执行运算时，结果为一个矩阵。

使用关系运算符进行数组比较

文档
关系运算符使用“小于”、“大于”和“不等于”等运算符对操作数进行定量比较。- 关系比较的结果是一个逻辑数组，指示关系为 true 的位置。

数组比较

数值数组

关系运算符会在两个数组之间执行按元素比较。数组的大小必须兼容以便于执行运算。执行计算时，具有兼容大小的数组会隐式扩展为相同的大小。以最简单的情况为例，两个操作数为大小相同的数组，或者其中一个操作数为标量。
将一个 1×N 行向量与一个 M×1 列向量进行比较，则 MATLAB 会在执行比较之前将每个向量都扩展为一个 M×N 矩阵。生成的矩阵包含这些向量中元素的每个组合的比较结果。
1
2
3
4
5
6
7
8
9
10
11
A = 1:3
%A =
1 2 3
B = [2; 3]
%B =
2
3
A >= B
%ans =
0 1 1
0 0 1
关系运算符可用于其中有任一维度大小为零的数组，只要两个数组的大小兼容。

数组索引

文档
-

A = [1 2 3 4; 5 6 7 8; 9 10 11 12; 13 14 15 16]
%A = 4×4
     1     2     3     4
     5     6     7     8
     9    10    11    12
    13    14    15    16

%可以在一个向量中指定多个元素的索引，从而一次引用多个元素。例如，访问 A 的第二行中的第一个和第三个元素。
r = A(2,[1 3])
%r = 1×2
     5     7

使用逻辑值进行索引

使用 true 和 false 逻辑指示符也可以对数组进行索引，在处理条件语句时尤其便利

矩阵 A 中的元素是否小于另一个矩阵 B 中的对应元素。当 A 中的元素小于 B 中的对应元素时，小于号运算符返回元素为 1 的逻辑数组。

clc,clear;
A = [1 2 6
    4 3 6];
B = [0 3 7
    3 7 5];
ind = A<B
%现在已经知道满足条件的元素的位置，可以使用 ind 作为索引数组来检查各个值。MATLAB 将 ind 中值 1 的位置与 A 和 B 中的对应元素进行匹配，并在列向量中列出它们的值。
Avals = A(ind)
Bvals = B(ind)

%ans
ind =
     0     1     1
     0     1     0
Avals =
     2
     3
     6
Bvals =
     3
     7
     7

MATLAB 中的 is 函数(前面带is的函数)还返回逻辑数组，指示输入中的哪些元素满足特定条件。

查找符合条件的数组元素

文档

应用单个条件

clc,clear;
a = [1 2
    3 4 
    5 6
    7 8];
b = a > 5
a(b)
i = find(a > 5)
a(i)
%answer
b =
     0     0
     0     0
     0     1
     1     1
ans =
     7
     6
     8
i =
     4
     7
     8
ans =
     7
     6
     8

结果为一个逻辑矩阵。b 中的每个值都表示为逻辑值 1 (true) 或逻辑值 0 (false) 的状态，以指示 a 的对应元素是否符合条件 a>5。

虽然 b 包含有关 a 中哪些元素大于 5 的信息，但它不会指出这些元素的具体值是多少。您可以使用 b 创建 a 的索引，而不必逐元素比较这两个矩阵。
结果为一个由 a 中大于 5 的元素组成的列向量。由于 b 为逻辑矩阵，因此该运算称为逻辑索引
find函数结果为一个由线性索引组成的列向量。每个索引描述a 中一个大于5的元素的位置，因此实际上 a(i) 与 a(b) 返回的结果相同。差别在于 a(b) 使用逻辑索引，而 a(i) 使用线性索引。

应用多个条件

可以使用逻辑 and、or 和 not 运算符将任意多个条件应用于一个数组；条件的数量并不局限于一个或两个。

逻辑索引

clc,clear;
a = [1 2
    3 4 
    5 6
    7 8
    9 10];
b = a(a > 5& ~mod(a, 2))
c = a(a > 5& ~mod(a, 2)&a ~= 8)
t = find(a > 5& ~mod(a, 2)&a ~= 8);
d = a(t)
e = a(a > 2&a <5)
f = a(2<a<5)
%结果为 a 中同时符合这两个条件的元素的列表。
%务必使用单独的语句指定每个条件，并用逻辑运算符连接起来。
%例如，不能通过 a(2 < a < 5) 指定以上条件，因为其计算结果为 A(2<A | A<5)。
%ans
b =
     6
     8
    10
c =
     6
    10
d =
     6
    10
e =
     3
     4
f =
     1
     3
     5
     7
     9
     2
     4
     6
     8
    10

查找 a 中大于 5 且为偶数的元素。
结果为 a 中大于5的所有偶数元素的列表。使用逻辑 NOT 运算符 ~ 将矩阵 mod(A,2) 转换为逻辑矩阵，并在可被 2 整除的元素位置放置逻辑值 1 (true)。

替换符合条件的值

有时，同时更改多个现有数组元素的值会很有用。将逻辑索引与简单的赋值语句一起使用，可替换数组中符合条件的值。

将 a 中大于 10 的所有值替换为数值 10。

clc,clear;
a = [1 2 3 4
    5 6 7 8
    9 10 11 12
    12 13 14 15];
a(a>10) = 10
%将 a 中不等于 10 的所有值替换为 NaN 值。
a(a~=10) = nan
%将 a中的所有 NaN 值替换为 0，并应用逻辑 NOT 运算符 ~A。
a(isnan(a)) = 0
c = ~a

%ans
a =
     1     2     3     4
     5     6     7     8
     9    10    10    10
    10    10    10    10
a =
   NaN   NaN   NaN   NaN
   NaN   NaN   NaN   NaN
   NaN    10    10    10
    10    10    10    10
a =
     0     0     0     0
     0     0     0     0
     0    10    10    10
    10    10    10    10
c =
     1     1     1     1
     1     1     1     1
     1     0     0     0
     0     0     0     0

生成的矩阵用逻辑值 1 (true) 取代 NaN 值，用逻辑值 0 (false) 取代 10。逻辑 NOT 运算 ~a 将数值数组转换为逻辑数组，因此 a&c 返回逻辑值 0 (false) 的矩阵，a|c 返回逻辑值 1 (true) 的矩阵。

数组与矩阵运算

注意matlab版本
MATLAB® 具有两种不同类型的算术运算：数组运算和矩阵运算。您可以使用这些算术运算来执行数值计算，例如两数相加、计算数组元素的给定次幂或两个矩阵相乘。
矩阵运算遵循线性代数的法则。与之不同，数组运算则是执行逐元素运算并支持多维数组。句点字符 (.) 将数组运算与矩阵运算区别开来。但是，由于矩阵运算和数组运算在加法和减法的运算上相同，因此没有必要使用字符组合 .+ 和 .-。
数组与矩阵运算

数组运算

数组运算可针对向量、矩阵和多维数组的对应元素执行逐元素运算。如果操作数的大小相同，则第一个操作数中的每个元素都会与第二个操作数中同一位置的元素匹配。如果操作数的大小兼容，则每个输入都会根据需要进行隐式扩展以匹配另一个输入的大小。
如果一个操作数是标量，而另一个操作数不是标量，则 MATLAB 会将该标量隐式扩展为与另一个操作数具有相同的大小。例如，您可以计算一个标量和一个矩阵的按元素乘积。
1
2
3
4
5
6
7
8
A = [1 2 3; 1 2 3]
%A =
1 2 3
1 2 3
3.*A
%ans =
3 6 9
3 6 9

如果从一个 3×3 矩阵中减去一个 1×3 向量，隐式扩展仍然会起作用，因为它们的大小是兼容的。当您执行减法运算时，该向量将隐式扩展为一个 3×3 矩阵。

A = [1 1 1; 2 2 2; 3 3 3]
%A =
     1     1     1
     2     2     2
     3     3     3
m = [2 4 6]
%m =
     2     4     6
A - m
%ans =
    -1    -3    -5
     0    -2    -4
     1    -1    -3

行向量和列向量的大小兼容。如果您将一个 1×3 向量与一个 2×1 向量相加，则每个向量都会在 MATLAB 执行按元素加法之前隐式扩展为一个 2×3 矩阵。
1
2
3
4
5
6
7
8
9
10
11
x = [1 2 3]
%x =
1 2 3
y = [10; 15]
%y =
10
15
x + y
%ans =
11 12 13
16 17 18
如果两个操作数的大小不兼容，则将会收到错误消息。

矩阵运算

矩阵运算遵循线性代数的法则，与多维数组不兼容

矩阵