Умножение вектор на матриц: C# .Net: Умножение матрицы на вектор

Содержание

Матрицы

«Увы, невозможно объяснить, что такое матрица. Ты должен увидеть это сам.»
Морфеус (Матрица, 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)

Набор финансовых инструментов

Умножение матриц

Умножение матриц , а не работает поэлементно. Он работает по правилам линейной алгебры. При перемножении матриц полезно помнить одно ключевое правило: внутренние размеры должны быть одинаковыми. То есть, если первая матрица равна м на 3, второй должен быть 3 на n . Результирующая матрица имеет размер

m 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, показывающую стоимость закрытия каждого дня для обоих портфелей.

Значения понедельника являются результатом умножения цены закрытия каждого понедельника на соответствующее количество акций и суммирования результата для первого портфеля, а затем выполнения того же самого для второго портфеля. Значения вторника получаются путем умножения цены закрытия каждого вторника на соответствующее количество акций и суммирования результата для первого портфеля, а затем для второго портфеля.