Матрицы
«Увы, невозможно объяснить, что такое матрица. Ты должен увидеть это сам.»
Морфеус (Матрица, 1999)
Матрица выглядит как таблица чисел, записанных в определенном порядке. Например, вот так:
\[ \boldsymbol{A}= \begin{pmatrix} 1 & 6 & 11 \\ 2 & 7 & 13 \\ 3 & 8 & 15 \\ 4 & 9 & 18 \\ 5 & 0 & 19 \end{pmatrix} \]
В данном случае это прямоугольная матрица \(\boldsymbol{A}\). Матрицы обозначаются заглавными буквами (иногда еще и полужирным написанием, чтобы отличать от обычных переменных). Количество строк и столбцов определяет размер матрицы. То есть данная матрица имеет размер 5×3 — \(\boldsymbol{A}_{5×3}\). При указании размера сначала указывается количество строк, затем — число столбцов.
Ну, и, собственно, всё. Это и есть матрица.
Матрицы возникают при решении систем линейных уравнений. Рассмотрим систему.
\[ \begin{cases}a_{11}x_1 + a_{12}x_2 + \ldots + a_{1m}x_m = b_1 \\a_{21}x_1 + a_{22}x_2 + \ldots + a_{2m}x_m = b_2 \\ \dots \dots \dots \dots \dots \dots \dots \dots \dots \dots \\a_{n1}x_1 + a_{n2}x_2 + \ldots + a_{nm}x_m = b_n \end{cases} \]
Система состоит из \(n\) линейных уравнений относительно \(m\) неизвестных. Её можно переписать в матричном виде:
\[ \boldsymbol{A}\boldsymbol{x}= \boldsymbol{b}, \]
где
\[ \boldsymbol{A}= \begin{pmatrix} a_{11} & a_{12} & \dots & a_{1m} \\ a_{21} & a_{22} & \dots & a_{2m} \\ \vdots & \vdots & \ddots & \vdots \\ a_{n1} & a_{n2} & \dots & a_{nm} \end{pmatrix} ; \quad \boldsymbol{x}= \begin{pmatrix} x_1 \\ x_2 \\ \vdots \\ x_m \end{pmatrix} ; \quad \boldsymbol{b}= \begin{pmatrix} b_1 \\ b_2 \\ \vdots \\ b_n \end{pmatrix} \]
Здесь мы видим матрицу коэффициентов системы \(\boldsymbol{A}\). Размер этой матрицы \(n × m\). Также мы видим две особых матрицы \(\boldsymbol{x}\) и \(\boldsymbol{b}\). Количество столбов у них равно единице. Такие матрицы носят название векторов.
Но ведь мы можем написать вектор всего с одной строкой. Например, некоторый вектор \(\boldsymbol{c}\):
\[ \boldsymbol{c}= \begin{pmatrix} c_1 & c_2 & \dots & c_k \end{pmatrix} \]
Для большей точности принята следующая терминология: векторы вида \(\boldsymbol{x}\) называют «вектор-столбец», а векторы вида \(\boldsymbol{c}\) называют «вектор-строка». Векторы часто также обозначаются полужирным начертанием, чтобы отличать их от отдельных значений.
Так как отдельные столбцы матрица мы можем представить в виде векторов, то матрицу \(\boldsymbol{A}\) можно написать еще одним способом: \[ \boldsymbol{A}= \begin{pmatrix} \boldsymbol{A}_1 & \boldsymbol{A}_2 & \dots & \boldsymbol{A}_m \end{pmatrix}, \]
где
\[ \boldsymbol{A}_i = \begin{pmatrix} a_{1i} \\ a_{2i} \\ \vdots \\ a_{ni} \end{pmatrix}, \quad 0<i \leq m \]
Ок, но остается вопрос: почему матричная запись равносильна причной нам записи системы?
Деталь 1
Есть две замечательные матрицы: единичная матрица \(\boldsymbol{E}\) (иногда \(\boldsymbol{I}\)) и нулевая матрица \(\boldsymbol{O}\): \[ \boldsymbol{E}= \begin{pmatrix} 1 & 0 & \dots & 0 \\ 0 & 1 & \dots & 0 \\ \vdots & \vdots & \ddots & \vdots \\ 0 & 0 & \dots & 1 \end{pmatrix} ; \quad \boldsymbol{O}= \begin{pmatrix} 0 & 0 & \dots & 0 \\ 0 & 0 & \dots & 0 \\ \vdots & \vdots & \ddots & \vdots \\ 0 & 0 & \dots & 0 \end{pmatrix} \]
Деталь 2
Матрица размером \(n × n\) называется квадратной матрицей.
Квадратная матрица, все элементы которой, кроме стоящих на главной диагонали, равны нулю, называется диагональной матрицей
.Сложение матриц
Сложение определено только для матриц одинакового размера.
\[ \boldsymbol{A}_{n×m} + \boldsymbol{B}_{n×m} = \begin{pmatrix} a_{11} + b_{11} & a_{12} + b_{12} & \dots & a_{1m} + b_{1m} \\ a_{21} + b_{21} & a_{22} + b_{22} & \dots & a_{2m} + b_{2m} \\ \vdots & \vdots & \ddots & \vdots \\ a_{n1} + b_{n1} & a_{n2} + b_{n2} & \dots & a_{nm} + b_{nm} \end{pmatrix} \]
Свойства сложения матриц:
- \(\boldsymbol{A}+ \boldsymbol{B}= \boldsymbol{B}+ \boldsymbol{A}\) (коммутативность)
- \((\boldsymbol{A}+ \boldsymbol{B}) + \boldsymbol{C}= \boldsymbol{A}+ (\boldsymbol{B}+ \boldsymbol{C})\) (ассоциативность)
- \(\boldsymbol{A}+ \boldsymbol{O}= \boldsymbol{A}\) (существование нулевого элемента)
- \(\boldsymbol{A}+ (-\boldsymbol{A}) = \boldsymbol{O}\) (существование противоположного элемента)
Все, описанное выше, справедливо для векторов.
Умножение матрицы на число
Умножение на вещественное число определено для любой матрицы \(n × m\).
\[ \lambda \boldsymbol{A}= \begin{pmatrix} \lambda a_{11} & \lambda a_{12} & \dots & \lambda a_{1m} \\ \lambda a_{21} & \lambda a_{22} & \dots & \lambda a_{2m} \\ \vdots & \vdots & \ddots & \vdots \\ \lambda a_{n1} & \lambda a_{n2} & \dots & \lambda a_{nm} \end{pmatrix}, \; \forall \lambda \in \mathbb{R} \]
Свойства умножения матрицы на число:
- \(1 \cdot \boldsymbol{A}= \boldsymbol{A}\)
- \(-1 \cdot \boldsymbol{A}= -\boldsymbol{A}\)
- \(\lambda(\mu \boldsymbol{A}) = (\lambda \mu) \boldsymbol{A}\) (ассоциативность)
- \((\lambda + \mu) \boldsymbol{A}= \lambda \boldsymbol{A}+ \mu \boldsymbol{A}\) (дистрибутивность)
- \(\lambda (\boldsymbol{A}+ \boldsymbol{B}) = \lambda \boldsymbol{A}+ \lambda \boldsymbol{B}\) (дистрибутивность)
Все, описанное выше, справедливо для векторов.
Скаларное произведение определено для векторов одинаковой размерности как сумма произведений их соответствующих координат.
\[ \boldsymbol{a}= \begin{pmatrix} a_1 & a_2 & \dots & a_n \end{pmatrix} \\ \boldsymbol{b}= \begin{pmatrix} b_1 & b_2 & \dots & b_n \end{pmatrix}\\ \] \[ \boldsymbol{a}\cdot \boldsymbol{b}= a_1 b_1 + a_2 b_2 + \dots + a_n b_n \]
мы рассматривать не будем 🙂
Ну, вот и начался треш.
Умножение определено для матриц \(\boldsymbol{A}_{n × k}\) и \(\boldsymbol{B}_{k × m}\), то количество столбцов матрицы, стоящей слева от знака умножения, должно быть равно количество строк матрицы, стоящей справа от знака умножения.
Произведением матрицы \(\boldsymbol{A}_{n × k}\) на матрицу \(\boldsymbol{B}_{k × m}\) называется матрица \(\boldsymbol{C}_{n × m}\), элемент которой \(c_{ij}\) равен скалярному произведению \(i\)-го вектора-строки матрицы \(\boldsymbol{A}\) и \(j\)-го вектора-столбца матрицы \(\boldsymbol{B}\).
Пусть \[ \boldsymbol{A}= \begin{pmatrix} \boldsymbol{a}_1 \\ \boldsymbol{a}_2 \\ \vdots \\ \boldsymbol{a}_n \end{pmatrix} = \begin{pmatrix} a_{11} & a_{12} & \dots & a_{1k} \\ a_{21} & a_{22} & \dots & a_{2k} \\ \vdots & \vdots & \ddots & \vdots \\ a_{n1} & a_{n2} & \dots & a_{nk} \end{pmatrix}, \\ \boldsymbol{B}= \begin{pmatrix} \boldsymbol{b}_1 & \boldsymbol{b}_2 & \dots \boldsymbol{b}_m \end{pmatrix} = \begin{pmatrix} b_{11} & b_{12} & \dots & b_{1m} \\ b_{21} & b_{22} & \dots & b_{2m} \\ \vdots & \vdots & \ddots & \vdots \\ b_{k1} & b_{k2} & \dots & b_{km} \end{pmatrix} \]
Тогда,
\[ \boldsymbol{A}\times \boldsymbol{B}= \begin{pmatrix} \boldsymbol{a}_1 \cdot \boldsymbol{b}_1 & \boldsymbol{a}_1 \cdot \boldsymbol{b}_2 & \dots & \boldsymbol{a}_1 \cdot \boldsymbol{b}_m \\ \boldsymbol{a}_2 \cdot \boldsymbol{b}_1 & \boldsymbol{a}_2 \cdot \boldsymbol{b}_2 & \dots & \boldsymbol{a}_2 \cdot \boldsymbol{b}_m \\ \vdots & \vdots & \ddots & \vdots \\ \boldsymbol{a}_n \cdot \boldsymbol{b}_1 & \boldsymbol{a}_n \cdot \boldsymbol{b}_2 & \dots & \boldsymbol{a}_n \cdot \boldsymbol{b}_m \\ \end{pmatrix} = \\ = \begin{pmatrix} (a_{11} b_{11} + a_{12} b_{21} + \dots + a_{1k}b_{k1}) & (a_{11} b_{12} + a_{12} b_{22} + \dots + a_{1k}b_{k2}) & \dots & (a_{11} b_{1m} + a_{12} b_{2m} + \dots + a_{1k}b_{km}) \\ (a_{21} b_{11} + a_{22} b_{21} + \dots + a_{2k}b_{k1}) & (a_{21} b_{12} + a_{22} b_{22} + \dots + a_{2k}b_{k2}) & \dots & (a_{21} b_{1m} + a_{22} b_{2m} + \dots + a_{2k}b_{km}) \\ \vdots & \vdots & \ddots & \vdots \\ (a_{n1} b_{11} + a_{n2} b_{21} + \dots + a_{nk}b_{k1}) & (a_{n1} b_{12} + a_{n2} b_{22} + \dots + a_{nk}b_{k2}) & \dots & (a_{n1} b_{1m} + a_{n2} b_{2m} + \dots + a_{nk}b_{km}) \end{pmatrix} = \\ = \begin{pmatrix} c_{11} & c_{12} & \dots & c_{1m} \\ c_{21} & c_{22} & \dots & c_{2m} \\ \vdots & \vdots & \ddots & \vdots \\ c_{n1} & c_{n2} & \dots & c_{nm} \end{pmatrix} = \boldsymbol{C} \]
\[ c_{ij} = \sum_{t=1}^k a_{it} b_{tj} \]
Вот так вот.
Cвойства произведения матриц:
- \(\boldsymbol{A}(\boldsymbol{B}\boldsymbol{C}) = (\boldsymbol{A}\boldsymbol{B}) \boldsymbol{C}\) (ассоциативность)
- \(\lambda (\boldsymbol{A}\boldsymbol{B}) = (\lambda \boldsymbol{A}) \boldsymbol{B}= (\lambda \boldsymbol{B}) \boldsymbol{A}\) (ассоциативность)
- \(\boldsymbol{A}(\boldsymbol{B}+ \boldsymbol{C}) = \boldsymbol{A}\boldsymbol{B}+ \boldsymbol{A}\boldsymbol{C}\) (дистрибутивность)
- \((\boldsymbol{A}+ \boldsymbol{B}) \boldsymbol{C}= \boldsymbol{A}\boldsymbol{C}+ \boldsymbol{B}\boldsymbol{C}\) (дистрибутивность)
- \(\boldsymbol{A}\boldsymbol{B}\neq \boldsymbol{B}\boldsymbol{A}\) (отсутствие коммутативности)
- \(\boldsymbol{E}\boldsymbol{A}= \boldsymbol{A}; \, \boldsymbol{A}\boldsymbol{E}= \boldsymbol{A}\) (умножение на единичный элемент)
- \(\boldsymbol{O}\boldsymbol{A}= \boldsymbol{O}; \, \boldsymbol{A}\boldsymbol{O}= \boldsymbol{O}\) (умножение на нулевой элемент)
- \(\boldsymbol{A}\boldsymbol{A}^{-1} = \boldsymbol{A}^{-1} \boldsymbol{A}= \boldsymbol{E}\) (умножение на обратную матрицу — только для некоторых квадратных матриц)
Матричное умножение определено для векторов-столбцов (матриц-столбцов) и векторов-строк (матриц-строк) и выполняется по тем же правилам. \mathrm{T}\)
Чтобы проверить ответ, введите в соответствующее поле значения элементов матрицы построчно. Элементы одной строки разделяйте пробелами, строки разделяйте запятыми.
Ассемблер ARM64 | Умножение матриц с помощью сопроцессора Neon
Последнее обновление: 21.01.2023
Умножение матриц является довольно распространенной задачей, которая применяется в самых различных вычислениях. И использование сопроцессора Neon позволяет оптимизировать умножение матриц. Так, матрица размером 3×3 фактически представляет три операции умножения матрицы на вектор:
Ccol1 = A ∗ Bcol1 Ccol2 = A ∗ Bcol2 Ccol3 = A ∗ Bcol3
Если поместить числа a, d и g в отдельные дорожки регистра V сопроцессора Neon, а числа b, e и h в соответствующие дорожки второго регистра, а числа c, f и i в соответствующие дорожки третьего регистра, то можно вычислить столбец результирующей матрицы
Итак, определим в файле main. s следующую программу
// Программа для умножения 2 матриц 3x3 с помощью сопроцессора NEON // // Используемые регистры: // D0 - первый столбец матрицы A // D1 - второй столбец матрицы A // D2 - третий столбец матрицы A // D3 - первый столбец матрицы B // D4 - второй столбец матрицы B // D5 - третий столбец матрицы B // D6 - первый столбец матрицы C // D7 - второй столбец матрицы C // D8 - третий столбец матрицы C .global main main: STP X19, X20, [SP, #-16]! STR LR, [SP, #-16]! // загружаем матрицу A в регистры D0, D1, D2 LDR X0, =A // адрес матрицы A LDP D0, D1, [X0], #16 LDR D2, [X0] // загружаем матрицу B в регистры D3, D4, D5 LDR X0, =B // адрес матрицы B LDP D3, D4, [X0], #16 LDR D5, [X0] // макрос для умножения матриц .macro mulcol ccol bcol MUL \ccol\().4H, V0.4H, \bcol\(). 4H[0] MLA \ccol\().4H, V1.4H, \bcol\().4H[1] MLA \ccol\().4H, V2.4H, \bcol\().4H[2] .endm mulcol V6, V3 // обрабатываем первый столбец mulcol V7, V4 // обрабатываем второй столбец mulcol V8, V5 // обрабатываем третий столбец LDR X1, =C // адрес матрицы C STP D6, D7, [X1], #16 // сохраняем данные в матрицу С STR D8, [X1] // выводим матрицу C на консоль // проходим по 3 строкам и печатаем за раз числа из трех стоблцов MOV W19, #3 // счетчик 3 строк LDR X20, =C // адрес результирующей матрицы printloop: LDR X0, =prtstr // загружаем строку форматирования // для вывода транспонируем матрицы, перейдя к стандартному расположению по столбцам // прибавляем к адресу 2 для перехода к первому элементу следующей строки // к адресу во второй инструкции ldrh добавляем 6, то есть 2+6=8=размер строки // аналогично в третьей инструкции ldh прибавляем к адресу 2+14=16 байт, что представляет размер 2-й строки LDRH W1, [X20], #2 // первый элемент текущей строки LDRH W2, [X20, #6] // второй элемент текущей строки LDRH W3, [X20, #14] // третий элемент текущей строки BL printf // вызываем функцию printf SUBS W19, W19, #1 // уменьшаем счетчик строк B. NE printloop // пока не напечатаем все строки MOV X0, #0 // код возврата LDR LR, [SP], #16 LDP X19, X20, [SP], #16 RET .data // первая матрица A: .short 1, 4, 7, 0 .short 2, 5, 8, 0 .short 3, 6, 9, 0 // вторая матрица B: .short 9, 6, 3, 0 .short 8, 5, 2, 0 .short 7, 4, 1, 0 //результирующая матрица C: .fill 12, 2, 0 prtstr: .asciz "%3d %3d %3d\n"
Здесь обе матрицы — A и B хранятся в порядке расположения столбцов, а матрица C генерируется также в порядке расположения столбцов, что позволяет упростить вычисления, поскольку так проще загружать данные в регистры NEON. Однако вывода на консоль в цикле данные печатаются в порядке расположения строк.
Основная работа выполняется в макросе. Сначала выполняем скалярное произведение
MUL \ccol\().4H, V0.4H, \bcol\().4H[0]
Данная инструкция после макроподстановок превращается в
MUL V6. 4H, V0.4H, V3.4H[0]
Набор символов \() представляет разделитель между именем параметра и последующими символами. Здесь \()
после имени параметра макроса
позволяет отделить название параметра от «.4H», иначе имя параметра будет рассматриваться как «ccol.4H».
Таким образом, перемножаем каждую дорожку в регистре V0 на число из соответствующей дорожки из регистра V3. Для доступа к значению в определенной дорожке применяются квадратные скобки, в которых указывается номер дорожки:
[номер_дорожки]
Отсчет дорожек начинается с нуля.
Последующие две инструкции макроса выполняют умножени с прибавлением:
MLA \ccol\().4H, V1.4H, \bcol\().4H[1] MLA \ccol\().4H, V2.4H, \bcol\().4H[2]
После определения макроса вызываем его три раза — по одному разу для каждого столбца
mulcol V6, V3 // обрабатываем первый столбец mulcol V7, V4 // обрабатываем второй столбец mulcol V8, V5 // обрабатываем третий столбец
Скомпилируем программу с помощью компилятора gcc и запустим на выполнение. В итоге консоль должна вывести матрицу С построчно
30 24 18 84 69 54 138 114 90
НазадСодержаниеВперед
python — умножение вектора матрицы numpy
Простейшее решение
Используйте numpy.dot
или a.dot(b)
. Смотрите документацию здесь.
>>> a = np.array([[ 5, 1,3], [ 1, 1 ,1], [ 1, 2 ,1]]) >>> b = np.массив ([1, 2, 3]) >>> напечатать a.dot(b) массив([16, 6, 8])
Это происходит потому, что массивы numpy не являются матрицами, а стандартные операции *, +, -, /
работают с массивами поэлементно.
Обратите внимание, что, хотя вы можете использовать numpy.matrix
(по состоянию на начало 2021 г.), где *
будет рассматриваться как стандартное матричное умножение, numpy.matrix
устарело и может быть удалено в будущих выпусках. . См. примечание в его документации (воспроизведено ниже):
Больше не рекомендуется использовать этот класс, даже для линейной алгебры. Вместо этого используйте обычные массивы. В будущем класс может быть удален.
Спасибо @HopeKing.
Другие решения
Также знайте, что есть и другие варианты:
Как указано ниже, при использовании python3.5+ и numpy v1.10+ оператор
@
работает так, как вы ожидаете:>>> печать (а @ б) массив([16, 6, 8])
Если вы хотите переборщить, вы можете использовать
numpy.einsum
. Документация даст вам представление о том, как это работает, но, честно говоря, я не совсем понимал, как его использовать, пока не прочитал этот ответ и не поиграл с ним самостоятельно.>>> np.einsum('ji,i->j', а, б) массив([16, 6, 8])
По состоянию на середину 2016 года (numpy 1.10.1) вы можете попробовать экспериментальный
numpy.matmul
, который работает какnumpy.dot
с двумя основными исключениями: нет скалярного умножения, но он работает со стеками матриц.>>> np.matmul(a, b) массив([16, 6, 8])
numpy.inner
работает так же, какnumpy.dot
для умножения матрицы на вектор, но ведет себя иначе для умножения матрицы-матрицы и тензора (см. Википедию о различиях между внутренним продуктом и точечным продуктом в целом или см. этот ответ SO относительно реализаций numpy).>>> np.inner(a, b) массив([16, 6, 8]) # Остерегайтесь использования для умножения матрицы на матрицу! >>> б = а.Т >>> нп.точка (а, б) массив([[35, 9, 10], [9, 3, 4], [10, 4, 6]]) >>> np.inner(a, b) массив([[29, 12, 19], [7, 4, 5], [8, 5, 6]])
Если у вас есть несколько 2D-массивов от до
точек
вместе, вы можете рассмотреть функциюnp.linalg.multi_dot
, которая упрощает синтаксис многих вложенныхnp.dot
s. Обратите внимание, что это работает только с двумерными массивами (т. е. не для умножения матрицы на вектор).>>> np.dot(np.dot(a, a.T), a).dot(a.T) массив([[1406, 382, 446], [382, 106, 126], [446, 126, 152]]) >>> np.linalg.multi_dot((а, а.Т, а, а.Т)) массив([[1406, 382, 446], [382, 106, 126], [446, 126, 152]])
Более редкие варианты для крайних случаев
Если у вас есть тензоры (массивы размерности больше или равные единице), вы можете использовать
numpy.tensordot
с необязательным аргументомaxes=1
:>>> np.tensordot(a, b, оси=1) массив([16, 6, 8])
Не используйте
numpy.vdot
, если у вас есть матрица комплексных чисел, так как матрица будет сведена к одномерному массиву, тогда он попытается найти комплексно-сопряженное скалярное произведение между вашей сглаженной матрицей и вектором (что не удастся из-за несоответствия размеран*м
противн
).
Обзор (Financial Toolbox)
Обзор (Financial Toolbox)Набор финансовых инструментов |
Умножение матриц
Умножение матриц , а не работает поэлементно. Он работает по правилам линейной алгебры. При перемножении матриц полезно помнить одно ключевое правило: внутренние размеры должны быть одинаковыми. То есть, если первая матрица равна м на 3, второй должен быть 3 на n . Результирующая матрица имеет размер
Умножение матриц также является , а не коммутативным; т. е. не зависит от порядка. A*B делает , а не равным B*A. Правило размерности иллюстрирует это свойство. Если A 1 на 3, а B 3 на 1, A * B дает скаляр (1 на 1), но B * A дает матрицу 3 на 3.
Умножение векторов
Умножение векторов следует тем же правилам и помогает проиллюстрировать принципы. Например, портфель акций состоит из трех разных акций, и их цена закрытия сегодня составляет
.Портфель содержит указанное количество акций каждой акции.
Чтобы найти стоимость портфеля, просто перемножьте векторы
, что дает
Векторы 1 на 3 и 3 на 1; результирующий вектор 1 на 1, скаляр. Таким образом, умножение этих векторов означает умножение каждой цены закрытия на соответствующее количество акций и суммирование результата.
Чтобы проиллюстрировать зависимость порядка, поменяйте порядок векторов
, который показывает стоимость закрытия 100, 500 и 300 акций каждой акции — не стоимость портфеля и не имеет смысла для этого примера.
Вычисление скалярных произведений векторов
В матричной алгебре, если X и Y являются векторами одинаковой длины
затем скалярное произведение
— это скалярное произведение двух векторов. Это исключение из коммутативного правила. Чтобы вычислить скалярное произведение в MATLAB, используйте сумма
(X .* Y)
или сумма(Y .* X)
. Просто убедитесь, что два вектора имеют одинаковые размеры. Чтобы проиллюстрировать, используйте предыдущие векторы.
Как и ожидалось, значение в этих случаях точно такое же, как PortfValue, вычисленное ранее.
Умножение векторов и матриц
Умножение векторов и матриц следует правилам и процессу умножения матриц. Например, матрица портфеля содержит цены закрытия за неделю. Вторая матрица (вектор) содержит количество акций в портфеле.
Чтобы увидеть стоимость портфеля закрытия за каждый день, просто умножьте
Матрица цен имеет размер 5 на 3, матрица количества (вектор) имеет размер 3 на 1, поэтому результирующая матрица (вектор) имеет размер 5 на 1.
Умножение двух матриц
Умножение матриц также следует правилам матричной алгебры. В нотации матричной алгебры, если A представляет собой m n матрицу, а B представляет собой n p матрицу
, тогда C = A * B представляет собой матрицу размером м на p ; а элемент c ij в строке i th и j столбце C равен
Для иллюстрации предположим, что есть два портфеля из трех указанных выше акций, но с разным количеством.
Умножение матрицы цен закрытия недели 5 на 3 на матрицу портфелей 3 на 2 дает матрицу 5 на 2, показывающую стоимость закрытия каждого дня для обоих портфелей.
Значения понедельника являются результатом умножения цены закрытия каждого понедельника на соответствующее количество акций и суммирования результата для первого портфеля, а затем выполнения того же самого для второго портфеля. Значения вторника получаются путем умножения цены закрытия каждого вторника на соответствующее количество акций и суммирования результата для первого портфеля, а затем для второго портфеля.