Публичный аккаунт Сяочжи:WeaponZhi
предисловие
В прошлой статье мы представили некоторую базовую информацию об Octave.Вы уже должны иметь базовое представление об Octave.Я думаю, что друзья, прочитавшие эту статью, уже установили Ocatve на свои компьютеры. Матричные операции — главная особенность Octave. В этом разделе я опишу некоторые операции Octave над матрицами, надеюсь, вы сможете следить за кодом во время чтения статьи, чтобы углубить свое впечатление.
Генерация матрицы
В Octave мы используем квадратную скобку для обозначения матрицы и точку с запятой для разделения каждой строки, даже если она не находится в той же строке при вводе ее следующим образом:
>> A = [1 2; 3 4; 5 6]
A =
1 2
3 4
5 6
>> A = [1 2;
> 3 4;
> 5 6]
A =
1 2
3 4
5 6
>> A = [1,2; 3,4; 5,6]
A =
1 2
3 4
5 6
Обратите внимание, что вы можете использовать запятые для разделения каждого элемента в каждой строке, но мы обычно не используем это, поэтому это выглядит не очень ясно. Так что, если вы хотите представить вектор? Мы знаем, что вектор-строка и вектор-столбец представляют собой матрицы с одной строкой и тремя столбцами и тремя строками и одним столбцом соответственно.Вы должны знать, как определить его, выводя другие факты?
>> A = [1 2 3]
A =
1 2 3
>> A = [1; 2; 3]
A =
1
2
3
Вектор-строка с прогрессивными правилами может быть реализован с помощью двоеточий.Число между двумя двоеточиями представляет размер прогрессивного шага, который легко понять и немного похож на работу Python.
>> A = 1:0.1:1.5
A =
1.0000 1.1000 1.2000 1.3000 1.4000 1.5000
>> A = 1:5
A =
1 2 3 4 5
Некоторые специальные матрицы могут быть быстро сгенерированы некоторыми функциями.
>> ones(2,3)
ans =
1 1 1
1 1 1
>> 2*ones(2,3)
ans =
2 2 2
2 2 2
>> zeros(2,3)
ans =
0 0 0
0 0 0
>> eye(3)
ans =
Diagonal Matrix
1 0 0
0 1 0
0 0 1
>> rand(2,3)
ans =
0.480397 0.505024 0.056767
0.336853 0.774152 0.535887
>> magic(3)
ans =
8 1 6
3 5 7
4 9 2
one() создает матрицу всех единиц, вы можете использовать числа для умножения матрицы, сгенерированной с помощью one(), это то же самое, что и zeros() и rand(), первый параметр - это количество строк, а второй параметр номер столбца. zeros() создает матрицу со всеми нулями, а rand() генерирует матрицу со случайными числами в диапазоне от 0 до 1. eye() может генерировать единичную матрицу.Друзья, знакомые с линейной алгеброй, могут быть знакомы с единичной матрицей.Это очень полезно, но знание линейной алгебры не является предметом этой статьи. Формально это можно понимать как матрицу, все диагонали которой равны единицам.
magic (n) генерирует матрицу порядка n. Характеристика этой матрицы заключается в том, что независимо от горизонтальной линии, вертикальной линии или диагональной линии добавленное значение одинаково, число не может повторяться, оно должно быть квадратным от 1 до n, очень весело.
Операции над матрицей
Прежде чем описывать работу матрицы, давайте сначала определим матрицу A 3x2, чтобы мы могли понять код
>> A = [1 2; 3 4; 5 6]
A =
1 2
3 4
5 6
Мы можем получить информацию о размерах матрицы через функции размера и длины
>> size(A)
ans =
3 2
>> size(A,1)
ans = 3
>> size(A,2)
ans = 2
>> length(A)
ans = 3
size(A) возвращает вектор-строку, представляющую размерность A, где результат 3 2 означает, что A является матрицей с 3 строками и 2 столбцами. size() также может добавить второй параметр, size(A,1) выводит число первого измерения A, которое является количеством строк, а 2 представляет количество столбцов. length(A) возвращает размер наибольшего измерения в матрице A, поэтому количество строк в A равно 3. Как правило, мы используем length() для векторов, чтобы напрямую вернуть длину вектора.
Давайте посмотрим на различные операции чтения матриц.
>> A(3,2)
ans = 6
>> A(:)
ans =
1
2
3
4
5
6
>> A(1:6)
ans =
1 3 5 2 4 6
A(3,2) представляет собой элемент третьей строки и второго столбца матрицы A, который легче понять. A(:) преобразует матрицу в вектор-столбец, а A(1:6) выводит элементы матрицы A с 1-го по 6-й в порядке столбцов. Они относительно просты, а последние два чаще используются при суммировании, о чем мы поговорим позже.
Давайте взглянемТяньсюдействовать
>> A(:,2)
ans =
2
4
6
>> A(2,:)
ans =
3 4
>> A([2,3],:)
ans =
3 4
5 6
>> A(:,2) = [1; 3; 5]
A =
1 1
3 3
5 5
>> A = [A,[1; 2; 3]]
A =
1 1 1
3 3 2
5 5 3
>> B = 5*ones(3)
B =
5 5 5
5 5 5
5 5 5
>> [A B] % [A,B] % 号是注释
ans =
1 1 1 5 5 5
3 3 2 5 5 5
5 5 3 5 5 5
>> [A; B]
ans =
1 1 1
3 3 2
5 5 3
5 5 5
5 5 5
Давай, посмотрим. A(:,2) выводит второй столбец A, A(2,:) выводит вторую строку A, A([2,3],:) выводит вторую и третью строки, вы можете заменить двоеточие на число так, чтобы первые несколько элементов этих строк могли быть выведены. A(:,2) = [1; 3; 5] заменяет второй столбец A вектором-столбцом [1; 3; 5]. [A B] имеет то же значение, что и [A, B], объединяя B справа от A. [A; B] объединяет B под A.
Матричные операции
В этом разделе будет рассказано о некоторых матричных операциях, требующих некоторых знаний о генерации строк.Если у вас есть какие-либо сомнения, вы можете просмотреть их самостоятельно.Возможно, вам нужно только знать, как работают умножение матриц и обратная матрица. Первый взгляд на кусок кода
>> A = [1 2; 3 4; 5 6];
>> B = [1 1 1;2 2 2;];
>> C = [11 12; 13 14; 15 16];
>> A * B
ans =
5 5 5
11 11 11
17 17 17
>> A .* C
ans =
11 24
39 56
75 96
Сначала мы определили три матрицы, помните, добавление точки с запятой в конце не напечатает их. A * B представляет собой произведение матриц A и B, которое является математическим методом произведения, поэтому матрица с тремя строками и двумя столбцами умножается на матрицу с двумя строками и тремя столбцами, а матрица с тремя строками и тремя столбцами будет получиться, что здесь не конкретно.Поговорим о правилах умножения. A .* C умножит совмещенные элементы A и C, что означает, что A и C должны иметь одинаковые размеры.
Рассмотрим операции над матрицами и числами.
>> A + 1
ans =
2 3
4 5
5 6
>> A * 2
ans =
2 4
6 8
10 12
>> A .^ 2
ans =
1 4
9 16
25 36
>> A / 2
ans =
0.50000 1.00000
1.50000 2.00000
2.50000 3.00000
>> 1 ./ A
ans =
1.00000 0.50000
0.33333 0.25000
0.20000 0.16667
A+1 добавляет каждый элемент, A * 2 умножает каждый элемент в A на 2, конечно, 2 * A тоже может, результат тот же, мы использовали 5 * единиц (3) выше, чтобы быстро сгенерировать матрицу A третьего порядка все 5-ки. A .^ 2 представляет собой степенную операцию над каждым элементом A. A / и ./ означают одно и то же, но 1 / A выдаст ошибку
>> 1 / A
error:operator /:nonconformat arguments
>> 1 / [2]
ans = 0.50000
>> 1 / 2
ans = 0.50000
Делитель должен быть матрицей 1x1 или числом, одним словом, это настоящая арифметическая операция деления.
Конечно, есть также некоторые операции, которые работают с элементами, например, log(A) — это логарифм каждого элемента, exp(A) — показатель степени e для каждого элемента, abs(A) — абсолютное значение и Их конечно много, по одному не перечислить. Вы можете проверить документацию непосредственно через команду справки.
Давайте посмотрим, как представлены транспонированная матрица и обратная матрица.
>> A'
ans =
1 3 5
2 4 6
>> (A')'
ans =
1 2
3 4
5 6
>> flipud(A)
ans =
5 6
3 4
1 2
>> B = pinv(A)
B =
-1.33333 -0.33333 0.66667
1.08333 0.33333 -0.41667
>> A * B % B * A
ans =
1.00000 0.00000
-0.00000 1.00000
Используйте одинарные кавычки ' для обозначения транспонирования матрицы. flipud(A) переворачивает матрицу Эта функция обычно используется для переворота матрицы диапазонов flipud(eye(n)), чтобы можно было получить антидиагональную единичную матрицу.
pinv(A) представляет обратную матрицу A. Произведение обратной матрицы и исходной матрицы является единичной матрицей.Стоит отметить, что не каждая матрица имеет обратную матрицу, но pinv() всегда может получить результат На самом деле, pinv() Вы получаете псевдообратную матрицу, но это не имеет значения, вы можете думать о pinv() как об обратной матрице, поэтому я не буду вдаваться здесь в подробности.
Пока что работа с матрицей относительно проста, по сравнению с ней следующая операция немногоЦветочное шоу.
>> max(A)
ans =
5 6
>> max(A,[],1)
ans =
5 6
>> max(A,[],2)
ans =
2
4
6
>> [val, ind] = max(A)
val =
5 6
ind =
3 3
>> max(A,[3 3; 3 3; 3 3])
ans =
3 3
3 4
5 6
>> A > 3
ans =
0 0
0 1
1 1
>> find([1 2 3] > 1)
ans =
2 3
>> [r,c] = find(A > 3)
r =
3
2
3
c =
1
2
2
max(A) найдет максимальное значение каждого столбца и выведет его в виде вектора-строки. Форма по умолчанию эквивалентна max(A,[],1).Чтобы найти максимальное значение каждого столбца, измените третий параметр на 2. При получении с [val, ind] значением val является максимальное значение, а ind — индексная позиция этого значения в столбце. max(A,B) возьмет больший элемент A и B в каждой позиции. Минимальные и максимальные операции одинаковы.
A > 3 выводит матрицу той же размерности, 1, если условие выполнено, и 0, если условие не выполнено. В функции find(), если это вектор, он вернет позицию индекса, соответствующую условиям.Если это матрица, используйте [r,c], чтобы вернуть индекс элемента, r представляет номер строки, а c представляет номер столбца, как в первом примере в примере. Соответствующее значение A(3,1) равно 5, что действительно больше 3.
Наконец, посмотрите на примирение
>> sum(A,1)
ans =
9 12
>> sum(A,2)
ans =
3
7
11
>> sum(sum(A))
ans = 21
Сумма такая же, как и максимальная.По умолчанию это операция столбца и вывод вектора-строки, но когда параметр установлен на 2, это сумма строк и вывод вектора-столбца. Как и в примере, если мы запрашиваем сумму всех элементов матрицы, нам нужно выполнить только сумму (сумма (А)) дважды.
Суммировать
Это все для ознакомления с Октавной матрицей.Я много писал.Это заметка.На самом деле операций много.Вы можете использовать команду справки или посмотреть официальную документацию,чтобы узнать.
Добро пожаловать, чтобы обратить внимание на мой общедоступный номер