Матрицами работа с: определения, свойства и примеры решения задач, формулы и онлайн калькуляторы

arr = np. array([[3,3,3],[2,5,5]], str)

temp = arr[:,2]

print(temp) #

В результате будет выведено сообщение [‘3’ ‘5’].

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

arr = np.array([[3,3,3],[2,5,5]], str)

temp = arr[1][2]

prínt(temp) #

В результате будет выведено сообщение 5.

Для того чтобы выполнить операцию сложения матриц, следует просуммировать все их соответствующие компоненты. В Python для обозначения операции сложения применяется стандартный оператор «+». Приведем пример операции сложения матриц:

arr1 = np.array([[3,3,3],[2,5,5]])

arr2 = np.array([[2,4,2],[1,3,8]])

temp = arr1 + arr2

prínt(temp)

Результат сложения матриц будет следующим:

[[ 5 7 5]

[ 3 8 13]]

Здесь следует заметить, что суммировать можно только те матрицы, которые имеют равное количество строк и столбцов. В противном случае программа на Python выдаст ошибку ValueError.

Операция умножения матриц обладает сильными отличиями от сложения. Нельзя просто взять и выполнить перемножение соответствующих элементов двух матриц. Прежде всего матрицы обязаны являться согласованными, что означает равенство количества столбцов одной матрицы количеству строк другой и наоборот. В противном случае программа выпадет в ошибку. Умножение в библиотеке NumPy может быть исполнено при помощи метода dot(). Ниже приведен пример реализации операции умножения:

arr1 = np.array([[3,3],[2,5]])

arr2 = np.array([[2,4],[1,3]])

temp = arr1.dot(arr2)

prínt(temp)

В результате исполнения этого кода будет выдано сообщение: [[ 9 21]

[ 9 23]]

Функциональное программирование на примере работы с матрицами из теории линейной алгебры / Хабр

Вступление

В основе работы с матрицами (в данной статье мы будем рассматривать только двумерные матрицы) лежит мощная математическая теория из области линейной алгебры. Одно определение или действие следует из другого, одна функция вызывает другую. Поэтому для программной реализации функционала математических операций над матрицами функциональные языки подходят очень хорошо. В рамках данной статьи мы рассмотрим конкретные примеры на языке F# и дадим подробные комментарии, как это работает. Так как F# входит в семейство .NET, то полученный функционал можно без каким либо проблем использовать в других императивный языках, например C#.

Определение матрицы и реализация на F#

Матрицы являются базовой и важнейшей частью линейной алгебры. Матрицы часто используются в программировании, например в 3D-моделировании или гейм-девелопинге. Разумеется, велосипед уже давно изобретен и необходимые фреймворки для работы с матрицами уже готовы, и их можно и нужно использовать. Данная статья не ставит своей целью изобретение нового фреймворка, но показывает реализацию базовых математических операций для работы с матрицами в функциональном стиле с использованием языка программирования F#. По мере рассмотрения материала мы будем обращаться к математической теории матриц и смотреть, как ее можно реализовать в коде.

Для начала вспомним, что такое матрица? Теория говорит нам следующее

Прямоугольная таблица чисел, содержащая m строк и n столбцов, называется матрицей размера m x n

Матрицы, как правило, обозначаются прописными буквами латинского алфавита и записываются в виде

Или коротко

Для работы с матрицами в F# создадим запись, основанную на двумерной таблице, которую в дальнейшем будем расширять полезными методами для того, чтобы совершать необходимые математические операции над ней.

type Matrix = { values: int[,] }
    with
        // здесь будем добавлять методы
    end

Добавим вспомогательный метод для инициализации записи двумерным массивом

static member ofArray2D (values: int [,]) = 
    { values = values }

Входным аргументом функции будет двумерный массив, а на ее выходе — запись типа Matrix. Ниже приведем пример инициализации записи.

let a = array2D [[1;0;2]
                 [3;1;0]]
let A = Matrix.ofArray2D a

Две матрицы A=(aij) и B=(bij) называются равными, если они совпадают поэлементно, т.е. aij=bij для всех i=1,2…,m и j=1,2…n

Для реализации этого правила будем использовать переопределенный оператор == и добавим пару полезных функций, которые также понадобятся нам в дальнейшем.

static member sizes matrix =
    let rows = matrix.values.[*,0].Length
    let cols = matrix.values.[0,*].Length
    (rows, cols)
static member isEquallySized matrix1 matrix2 =
    let dim1 = Matrix.sizes matrix1
    let dim2 = Matrix.sizes matrix2
    (dim1 = dim2)
static member (==) (matrix1, matrix2) =
    if not (Matrix.isEquallySized matrix1 matrix2) then false
    else
        not (matrix1.values
               |> Array2D.mapi (fun x y v -> if matrix2. values.[x, y] <> v then false else true)
               |> Seq.cast<bool>
               |> Seq.contains false)

Давайте подробнее рассмотрим код выше. Как можно заметить, здесь есть три функции. Первая функция sizes возвращает размерность матрицы в виде кортежа. Так как мы работаем только с прямоугольными матрицами, то для получения количества строк мы берем полный срез первой колонки и возвращаем ее длину.

let rows = matrix.values.[*,0].Length

Аналогичным способом работает определение количества колонок — получаем полный срез первой строки и возвращаем ее длину.

Следующая функция isEquallySized сравнивает размерность двух матриц и возвращает true если они равны. Для этого она использует уже готовую функцию sizes и просто сравнивает результаты.

Оператор == для поэлементного сравнения двух матриц кажется сложнее, но сейчас вы увидите, что он также простой.

Перед тем, как сравнивать две матрицы, сравним их размерность. Если они не равны, то нет дальше смысла проводить проверку, так как уже понятно, что и матрицы будут не равны.

if not (Matrix.isEquallySized matrix1 matrix2) then false

Далее, на основе исходных матриц matrix1 и matrix2 мы формируем новую матрицу, заполненную true или false, в зависимости от того, совпадают ли соответствующие ячейки обеих матриц.

matrix1.values
|> Array2D.mapi (fun x y v -> if matrix2.values.[x, y] <> v then false else true

Функция Array2D.mapi перебирает все элементы matrix1 и передает в обработчик три параметра
x — индекс строки
y — индекс колонки
v — содержимое ячейки
Содержимое ячейки v мы сравниваем с соответствующей ячейкой matrix2 и если они равны, то пишем true, иначе — false.

Если есть хоть одна ячейка с элементом false, то это означает, что матрицы не равны между собой.

Так как Array2D не содержит в себе методов для фильтрации или поиска, то реализуем это сами. Для этого разложим матрицу в линейный список

|> Seq.cast<bool>

И найдем хоть одно несовпадение

|> Seq.contains false

Функция Seq.contains вернет true если в разложенном списке будет найдено хоть одно значение false. Поэтому нам нужно инвертировать полученный результат, чтобы оператор == работал так, как мы хотим

else
    not (matrix1.values
           |> Array2D.mapi (fun x y v -> if matrix2.values.[x, y] <> v then false else true)
           |> Seq.cast<bool>
           |> Seq.contains false)

Матрица O называется нулевой или нуль-матрицей, если все ее элементы равны нулю.

static member O rows cols =
    let array2d = Array2D.zeroCreate rows cols
    { values = array2d }

Пример использования этой функции

let AO = Matrix.O 5 5

Полагаю, что здесь нет ничего сложного, что требует пояснений, поэтому продолжаем.

Матрица, число строк которой равно числу столбцов и равно n, называется квадратной матрицей порядка n

Таким образом, квадратная матрица имеет вид.

В рамках этого правила мы создадим функцию, которая прямоугольную матрицу трансформирует в квадратную путем отсечения всех элементов, которые не попадают в квадрат.

static member toSquare matrix =
    // получаем размерность исходной матрицы
    let dim = Matrix.sizes matrix
    // получаем количество колонок
    let colCount: int = snd dim
    // получаем количество строк
    let rowCount: int = fst dim
    // находим размер минимальной стороны
    let length = System. Math.Min (colCount, rowCount)
    // создаем пустой квадратный массив с размерностью
    // равной наименешей стороне исходной матрицу
    let zero = Array2D.zeroCreate length length
    // копируем исходную матрицу в квадратную
    let square = zero |> Array2D.mapi (fun x y _ -> matrix.values.[x, y])
    // позвращаем полученную матрицу
    { values = square }

Комментариев в исходном коде поясняют принцип работы функции, поэтому продолжим.

Квадратная матрица называется треугольной, если все ее элементы ниже главной диагонали равны нулю, т.е. треугольная матрица имеет вид

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

static member T matrix =
    let values = matrix.values |> Array2D.mapi (fun x y v -> if y < x then 0 else v)
    { values = values }

Функция Array2D.mapi преобразовывает исходный двумерный массив в новый при помощи обработчика, который принимает три параметра

x — номер строки
y — номер колонки
v — содержимое ячейки

if y < x then 0 else v

Здесь мы делаем проверку, находится ли элемент ниже главной диагонали и если да, то заполняем ячейку 0. В противном случае — исходным значение из входной матрицы.

Ниже приведен пример использования этой функции.

let a = array2D [[1;2;3]
                 [4;5;6]
                 [7;8;9]
                 [10;11;12]]
let A = Matrix.ofArray2D a
let R = Matrix.triangular A
printfn "origin = \n %A" A.values
printfn "triangular = \n %A" R.values

Получаем следующий результат

origin = 
 [[1; 2; 3]
 [4; 5; 6]
 [7; 8; 9]
 [10; 11; 12]]
triangular = 
 [[1; 2; 3]
 [0; 5; 6]
 [0; 0; 9]
 [0; 0; 0]]

Квадратная матрица называется диагональной, если все ее элементы, расположенные вне главной диагонали, равны нулю

static member D matrix =
    let diagonal = matrix. values |> Array2D.mapi (fun x y v -> if x <> y then 0 else v)
    { values = diagonal }

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

let a = array2D [[1;2;3]
                 [4;5;6]
                 [7;8;9]
                 [10;11;12]]
let A = Matrix.ofArray2D a
let R = Matrix.D A
printfn "origin = \n %A" A.values
printfn "diagonal = \n %A" R.values

origin = 
 [[1; 2; 3]
 [4; 5; 6]
 [7; 8; 9]
 [10; 11; 12]]
diagonal = 
 [[1; 0; 0]
 [0; 5; 0]
 [0; 0; 9]
 [0; 0; 0]]

Диагональная матрица является единичной и обозначается E, если все ее элементы, расположенные на главной диагонали, равны единице

Реализация такой матрицы на F# выглядит так

static member E rows cols =
    let array2d = Array2D.init rows cols (fun x y -> if x = y then 1 else 0)
    { values = array2d }

Операции над матрицами при помощи F#

Над матрицами, как и над числами, можно производить ряд действий, причем некоторые из них аналогичны операциям над числами, а некоторые — специфические.

Суммой двух матриц Amn=(aij)и Bmn=(bij)одинаковых размеров называется матрица того же размера A+B=Cmn=(cij), элементы которой равны сумме элементов матриц A и B, расположенных на соответствующих местах

Пример, для заданных матриц A и B находим сумму A+B

Рассмотрим код для сложения двух матриц

static member (+) (matrix1, matrix2) =
    if Matrix.isEquallySized matrix1 matrix2 then
        let array2d = matrix1.values |> Array2D.mapi (fun x y v -> matrix2.values.[x, y] + v)
        { values = array2d }
    else failwith "matrix1 is not equal to matrix2"

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

let a = array2D [[2;3]
                 [1;-5]
                 [0;6]]
let A = Matrix. ofArray2D a
let b = array2D [[-3;3]
                 [1;7]
                 [2;0]]
let B = Matrix.ofArray2D b
let R = A+B
printfn "A+B =\n %A" R.values

A+B =
 [[-1; 6]
 [2; 2]
 [2; 6]]

Произведением матрицы A=(aij) на число k называется матрица kA=(kaij) такого же размера, что и матрица A, полученная умножением всех элементов матрицы A на число k

Пример, для заданной матрицы A находим матрицу 3A

static member (*) (value, matrix) = 
    let array2d = matrix.values |> Array2D.mapi (fun _ _ v -> v * value)
    { values = array2d }

Матрицу -A=(-1)*A будем называть противоположной матрице A. Из этого определения плавно переходим к следующему

Разностью матриц A и B одинаковых размеров называется сумма матрицы A и матрицы, противоположной к B

static member (-) (matrix1: Matrix, matrix2: Matrix) = 
    if Matrix. isEquallySized matrix1 matrix2 then
        matrix1 + (-1)*matrix2
    else failwith "matrix1 is not equal to matrix2"

Две матрицы называются согласованными, если число столбцов первой равны числу строк второй

static member isMatched matrix1 matrix2 = 
    let row1Count = matrix1.values.[0,*].Length
    let col2Count = matrix2.values.[*,0].Length
    row1Count = col2Count

Проверка согласованности матриц требуется для их перемножения.

Произведением AB согласованных матриц Amn=(aij) и Bnp=(bjk) называется матрица Cmn=(cik), элемент cik которой вычисляется как сумма произведений элементов i-й строки матрицы A и соответствующих элементов k-го столбца матрицы B

Вычислить произведение матриц

Решение по определению произведения матриц

Рассмотрим код для умножения двух матриц

static member (*) (matrix1, (matrix2: Matrix)) =
    if Matrix. isMatched matrix1 matrix2 then
        let row1Count = matrix1.values.[*,0].Length
        let col2Count = matrix2.values.[0,*].Length
        let values = Array2D.zeroCreate row1Count col2Count
        for r in 0..row1Count-1 do
            for c in 0..col2Count-1 do
                let row = Array.toList matrix1.values.[r,*]
                let col = Array.toList matrix2.values.[*,c]
                let cell = List.fold2 (fun acc val1 val2 -> acc + (val1 * val2)) 0 row col
                values.[r,c] <- cell
        { values = values }
    else failwith "matrix1 is not matched to matrix2"

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

if Matrix.isMatched matrix1 matrix2 then

Итоговая матрица будет иметь размерность, в которой количество строк такое же, как у первой матрицы и количество столбцов такое же, как у второй матрицы

let row1Count = matrix1. values.[*,0].Length
let col2Count = matrix2.values.[0,*].Length
// формируем пустой двумерный массив для сохранения результатов умножения
let values = Array2D.zeroCreate row1Count col2Count

После этого мы последовательно перебираем все строки и все столбцы исходных матриц

for r in 0..row1Count-1 do
    for c in 0..col2Count-1 do
        let row = Array.toList matrix1.values.[r,*]
        let col = Array.toList matrix2.values.[*,c]

Вычисляем итоговое значение каждой ячейки

let cell = List.fold2 (fun acc val1 val2 -> acc + (val1 * val2)) 0 row col

Функция List.fold2 на вход получает два списка (строку и колонку) и передает в обработчик следующие параметры

acc — аккумулятор, содержащий результат предыдущего вычисления
val1 — содержимое ячейки из первого массива. В нашем случае это строка из первой матрицы
val2 — содержимое ячейки из второго массива, то есть колонки второй матрицы

Так как матрицы являются согласованными, то мы уверены, что у нас не произойдет выхода за пределы массивов.

Обработчик добавляет к аккумулятору произведение ячеек из строк и столбца и полученное значение будет передано следующей итерации. Таким образом конечным итогом работы функции List.fold2 будет итоговое значение произведений двух матриц. Остается только заполнить им предварительно созданную пустую матрицу

values.[r,c] <- cell

Которая вернется как результат

{ values = values }

Ниже приведем пример использования данной функции

let a = array2D [[1;0;2]
                 [3;1;0]]
let A = Matrix.ofArray2D a
let b = array2D [[-1;0]
                 [5;1]
                 [-2;0]]
let B = Matrix.ofArray2D b
let R = A*B
printfn "A*B =\n %A" R.values

A1*B1 =
 [[-5; 0]
 [2; 1]]

Если k ∈ N, то k-й степенью квадратной матрицы Aназывается произведение k матриц A

Рассмотрим код на F# для произведения матрицы в степень. Здесь будет использоваться хвостовая рекурсия для того, чтобы не переполнить стек при больших значениях степеней. Хвостовая рекурсия — это такая рекурсия, которая компилятором в итоге преобразуется в цикл. По возможности рекомендуется всегда использовать именно хвостовую рекурсию вместо обычной, но для этого нужно чтобы каждый кадр рекурсии возвращал итоговое вычисленное значение. Это значение обычно называется аккумулятором и передается в следующий кадр рекурсии. То есть, в отличие от обычной рекурсии, которая возвращает вычисленное значение вверх по стеку, хвостовая рекурсия передает вычисленное значение вниз по стеку. Каждый новый кадр рекурсии делает свои вычисления и добавляет их к уже ранее вычисленному значению, которое хранится в аккумуляторе. После того, как последний кадр рекурсии отработал, в аккумуляторе уже есть вычисленное значение, которое просто возвращается как результат.

Таким образом, компилятор может оптимизировать код и преобразовать его в обычный цикл.

// возводим матрицу в степень
// matrix - исходная матрица
// value - значение степени
static member (^^) (matrix, value) =
    // внутренняя функция, которая реализует хвостовую рекурсию
    // m - матрица
    // p = значение степени
    let inRecPow m p =
        // рекурсивная функция
        // acc - накопленный аккумулятор.  имеет тип Matrix
        // p - значение степени для текущего кадра
        // с каждым кадром рекурсии это значение уменьшается на единицу
        let rec recPow acc p =
            // сравниваем текущую степень
            match p with
            | x when x > 0 ->
                // вычисляем новое значение аккумулятора
                // умножаем исходную матрицу на старый аккумулятор, то есть возводим в следующую степень
                let nextAcc = acc*m
                // рекурсивно вызываем функцию и передаем ей уменьшенное на единицу значение степени
                recPow nextAcc (x-1)
            // если степень достигла нуля, то возвращаем вычисленный аккумулятор
            | _ -> acc
        // создаем единичную матрицу, чтобы передать ее в качестве аккумулятор для вычисления степени
        let dim = Matrix.sizes matrix
        let colCount = snd dim
        let rowCount = fst dim
        let u = Matrix.E rowCount colCount
        // вызываем рекурсивную функцию и передаем ей единичную матрицу в качестве аккумулятора
        recPow u p
    // вызываем функцию, реализующую хвостовую рекурсию для получения результата
    let powMatrix = inRecPow matrix value
    // возвращаем итоговую матрицу
    { values = powMatrix. values }

Код содержит подробные комментарии о том, как он работает. Требует небольшого пояснения, зачем используется единичная матрица? Она нужна для первого кадра рекурсии и служит в качестве базового значения аккумулятора, в котором будет накапливаться итоговый результат.
Ниже рассмотрим пример использования нашей функции

Вычислим следующее произведение

Где E — это единичная матрица. Так как мы не можем к матрице прибавить число, то мы должны прибавлять 3E.

// возвращает сумму матрицы и числа
static member (+) (matrix, (value: int)) =
    let dim = Matrix.sizes matrix
    let r = fst dim
    let c = snd dim
    // создаем единичную матрицу
    let unit = Matrix.E r c
    // умножаем единичную матрицу на число и прибавляем к входной матрице
    value*unit + matrix

let a = array2D [[1;0]
                 [2;-1]]
let A = Matrix. 2 + 3 =
 [[1; 0]
 [4; -3]]

Матрица A^T, столбцы которой составлены из строк матрицы A с теми же номерами и тем же порядком следования элементов, называется транспонированной к матрице A

static member transpose matrix =
    let dim = Matrix.sizes matrix
    let rows = fst dim
    let cols = snd dim
    // создаем нулевую матрицу для вычисления результатов
    let tMatrix = Matrix.O cols rows
    // копируем в нее данные из исходной матрицы
    matrix.values |> Array2D.iteri(fun x y v -> tMatrix.values.[y, x] <- v)
    // возвращаем результат
    tMatrix

Пример использования

let a = array2D [[1;2;3]
                 [4;5;6]
                 [7;8;9]
                 [10;11;12]]
let A = Matrix.ofArray2D a
let R6 = Matrix.T A
printfn "origin = \n %A" A.values
printfn "transpose = \n %A" R.values

origin = 
 [[1; 2; 3]
 [4; 5; 6]
 [7; 8; 9]
 [10; 11; 12]]
transpose = 
 [[1; 4; 7; 10]
 [2; 5; 8; 11]
 [3; 6; 9; 12]]

Итоги

В этот статье мы рассмотрели примеры реализации и использования матриц из теории линейной алгебры. А также основных математических операций над ними, с использованием функционального подхода на языке F#. Я надеюсь, что читатель смог оценить ту гибкость, которую дают функциональные языки.

Полный исходный код модуля матриц, фрагменты которого были рассмотрены в рамках статьи, вы сможете найти на гитхабе.

Github Matrix.fs

Работа с векторами и матрицами в MathCad

Похожие презентации:

3D печать и 3D принтер

Системы менеджмента качества требования. Развитие стандарта ISO 9001

Операционная система. Назначение и основные функции

Adobe Photoshop

AutoCAD история и возможности

Microsoft Excel

Облачные технологии

Корпорация Microsoft и ее особенности

Веб-дизайн

Тема 2. Пакеты прикладных программ

Работа с векторами и
матрицами
в MathCad
Массивы
одномерные
(векторы)
двумерные
(матрицы)
тензоры
a «My Name»
(многоиндексные)
1
M
V2 ( 1 2 3 )
V1 2
3
Индекс – порядковый номер элемента
1 2 3
4 5 6
7 8 9
Заполнение массивов
1. С помощью шаблона:
2. Поэлементно
m0 0 0
m1 0 3
m0 1 1
m1 0 3 m1 1 4 m1 2 5
m0 2 2
0 1 2
m
m1 2 5
3 4 5
m1 1 4
1 2
3. С использованием
и функций пользователя
0 переменных
m
00 33
i 0 1
j j
3
4T 5
0 1 2 3
T
ViV
i
0.50.5
i i 1 1 VV ( (11 1.5
MM
j j M
1.5))
i ji
j i i
1 0 1 2
4. Применение встроенных функций
6. Создание программ-функций
5. Чтение из внешнего файла
Матричные вычисления
элементарные действия
использование
программирования
создание, сложение,
использование
умножение,
суммирование
специальных функций элементов вложенного
извлечение данных
Реализация: операторы и встроенных алгоритмов
массива
панели Math: Calculator,
матричной алгебры
Matrix, Symbolic
ранг, единичная матрица,
сортировка
Реализация: главное меню
Insert (Вставка) Function
(Функция) (или
)
раздел Vector and Matrix
(Векторы и матрицы)
Операторы и функции для работы
с векторами и матрицами
V – вектор, M – матрица,
Z – скаляр
Векторные и матричные функции
Векторные функции
Функция
length(V)
Описание
Возвращает длину вектора
last(V)
Возвращает индекс последнего элемента
max(V)
Возвращает максимальный по значению элемент
min(V)
Возвращает минимальный по значению элемент
Re(V)
Возвращает вектор действительных частей
вектора с комплексными элементами
Im(V)
Возвращает вектор мнимых частей вектора с
комплексными элементами
Векторные и матричные функции
Функции для работы с матрицами
Функция
Описание
augment(M1,M2)
Объединяет в одну матрицы М2 и М2, имеющие
одинаковое число строк (объединение «бок о бок»)
stack(M1,M2)
Объединяет в одну матрицы М1 и М2, имеющие
одинаковое число столбцов, располагая М1 над М2
Создает единичную квадратную матрицу
identity(n)
размером n×n
Возвращает субматрицу, состоящую из всех
submatrix(M,ir,jr,ic,jc) элементов, содержащихся в строках с ir по jr и
столбцов с ic по jc
diag(V)
Re(M)
Im(M)
Создает диагональную матрицу, элемент главной
диагонали которой – вектор V
Возвращает матрицу действительных, мнимых
частей матрицы M с комплексными элементами
Векторные и матричные функции
Функции для работы с матрицами
Функция
Описание
Выводит значения того элемента матрицы N, который
lookup(r,M,N) занимает в ней такое же положение, что и скаляр r в
матрице M
Ищет в векторе или матрице A заданное значение z и
match(z,M) возвращает индексы его позиций в A
Функции, возвращающие специальные
характеристики матриц
Функция
Описание
cols(M)
Возвращает число столбцов матрицы М
rows(M)
Возвращает число строк матрицы М
rank(M)
Возвращает ранг матрицы М
tr(M)
Возвращает след (сумму диагональных элементов)
квадратной матрицы М
mean(M)
Возвращает среднее значение элементов массива М
median(M)
eigenvals(M)
Возвращает медиану элементов массива М
Возвращает вектор собственных значений квадратной
матрицы M
Функции сортировки
Функция
Описание
sort(V)
Сортировка элементов вектора в порядке возрастания
их значений
reverse(V)
Перестановка элементов вектора в обратном порядке
csort(M,n)
Перестановка строк матрицы М таким образом,
чтобы отсортированным оказался n-й столбец
rsort(M,n)
Перестановка столбцов матрицы М таким образом,
чтобы отсортированной оказалась n-я строка
Примеры
1 2
m1
3 1
1 2
m2
3 2
1 2
m1
1
m10 1 2
7 2
m1 m2
6 4
m11 0 3
1 4
( m1 m2)
9 2
Примеры
2
v 3
7
length( v) 3
last ( v) 2
max( v) 7
min( v) 2
Примеры
1 2
m1
3 1
1 2
m2
3 2
1 2 1 2
augment ( m1 m2)
3 1 3 2
1
3
M stack ( m1 m2)
1
3
3 1
submatrix( M 1 2 0 1)
1 2
2
1
2
2
3
submatrix( M 1 2 0 0)
1
Примеры
1 2
m1
3 1
1 2
m2
3 2
lookup ( 3 m1 m2) ( 3 )
1
lookup ( 1 m1 m2)
2
0
0
0
match ( 1 m1 ) 0
1
match ( 1 m1)
1
1
1
1
match ( 3 m2)
0
Примеры
9
3
V
5
2
2
3
sort ( V)
5
9
2
5
reverse ( V)
3
9
9
5
reverse ( sort ( V) )
3
2
1 5 7 2
M
0
7
4
2
0 7 4 2
csort ( M 2)
1
5
7
2
7 2 1 5
rsort ( M 1)
4
2
0
7
{4,1}
{4,1}
{5,1}
{4,1}
main( D Ta i h)
{201,2}
{4,1}
{4,1}
{1,2}
0
{5,1}
main( D Ta i h) 5
{5,1}
{5,1}
0
20
main(D Ta i h)5 1 20
20
20
Формат → Результат → Параметры отображения

English     Русский Правила

Работа с матрицами

Компьютеры Работа с матрицами

просмотров — 92

Форматирование формул и текста

Ввод текста

Текст, помещенный в рабочий лист, содержит комментарии и описания и предназначен для ознакомления, а не для использования в расчетах. Программа MathCad определяет назначение текущего блока автоматически при первом нажатии клавиши ПРОБЕЛ. В случае если введенный текст не может быть интерпретирован как формула, блок преобразуется в текстовый и последующие данные рассматриваются как текст. Создать текстовый блок без использования автоматических средств позволяет команда insert > Text Region (Вставка > Текстовый блок).

Иногда требуется встроить формулу внутрь текстового блока. Для этого служит команда Insert > Math Region (Вставка > Формула).

Для форматирования формул и текста в программе MathCad используется панель инструментов Formatting (Форматирование). С ее помощью можно индивидуально отформатировать любую формулу или текстовый блок, задав гарнитуру и размер шрифта͵ а также полужирное, курсивное или подчеркнутое начертание символов. В текстовых блоках можно также задавать тип выравнивания и применять маркированные и нумерованные списки.

В качестве средств автоматизации используются стили оформления. Выбрать стиль оформления текстового блока или элемента формулы можно из списка Style (Стиль) на панели инструментов Formatting (Форматирование). Для формул и текстовых блоков применяются разные наборы стилей.

Чтобы изменить стиль оформления формулы или создать новый стиль, используется команда Format > Equation (Формат > Выражение). Изменение стандартных стилей Variables (Переменные) и Constants (Константы) влияет на отображение формул по всœему документу. Стиль оформления имени переменной учитывается при ее определœении. Так, переменные хил: рассматриваются как различные и не взаимозаменяемы.

При оформлении текстовых блоков можно использовать более обширный набор стилей. Настройка стилей текстовых блоков производится при помощи команды Format t Style (Формат > Стиль).

Векторы и матрицы рассматриваются в программе MathCad как одномерные и двумерные массивы данных. Число строк и столбцов матрицы задается в диалоговом окне Insert Matrix (Вставка матрицы), ĸᴏᴛᴏᴩᴏᴇ открывают командой Insert > Matrix (Вставка > Матрица). Вектор задается как матрица, имеющая один столбец.

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

Для матриц определœены следующие операции: сложение, умножение на число, перемножение и прочие. Допустимо использование матриц вместо скалярных выражений: в этом случае предполагается, что указанные действия должны быть применены к каждому элементу матрицы, и результат также представляется в виде матрицы. К примеру, выражение М+ 3, где М — матрица, означает, что к каждому элементу матрицы прибавляется число 3. В случае если требуется явно указать крайне важность поэлементного применения операции к матрице, используют знак векторизации, для ввода которого служит кнопка Vectorize (Векторизация) на панели инструментов Matrix (Матрица). К примеру:

— обычное произведение матриц.

— поэлементное произведение матриц с

использованием векторизации.

Для работы с элементами матрицы используют индексы элементов. Нумерация строк и столбцов матрицы начинается с нуля. Индекс элемента задается числом, переменной или выражением и отображается как нижний индекс. Он вводится после щелчка на кнопке Subscript (Индекс) на панели инструментов Matrix (Матрица).

Пара индексов, определяющих элемент матрицы, разделяется запятой. Иногда (к примеру, при построении графиков) требуется выделить вектор, представляющий собой столбец матрицы. Номер столбца матрицы отображается как верхний индекс, заключенный в угловые скобки, к примеру М^<0>. Для его ввода используется кнопка Matrix Column (Столбец) на панели инструментов Matrix (Матрица).

Чтобы задать общую формулу элементов матрицы, типа М_i,j : i + j,используют диапазоны. Диапазон фактически представляет собой вектор, содержащий арифметическую прогрессию, определœенную первым, вторым и последним элементами. Чтобы задать диапазон, следует указать значение первого элемента͵ через запятую значение второго и через точку с запятой значение последнего элемента. Точка с запятой при задании диапазона отображается как две точки (..). Диапазон можно использовать как значение переменной, к примеру х := 0,0.01..1.

В случае если разность прогрессии равна единице (то есть, элементы просто нумеруются), значение второго элемента и соответствующую запятую опускают. К примеру, чтобы сформировать по приведенной выше формуле матрицу размером 6×6, перед этой формулой нужно указать i:= 0..5 j := 0..5. При формировании матрицы путем присвоения значения ее элементам, размеры матрицы можно не задавать заранее. Всем неопределœенным элементам автоматически присваиваются нулевые значения. К примеру, формула М_5,5 := 1 создает матрицу М размером 6´6, у которой всœе элементы, кроме расположенного в правом нижнем углу, равны 0.

Глоссарий терминов, используемых в матричной алгебре: (жирный шрифт: наиболее важные для нас)

Возврат на главную страницу указателя

Совместимость:

Две матрицы совместимы (для умножения) если количество столбцов в первом равно количеству строк в второй. Это потому, что каждая строка (с j элементов) в первом матрица будет умножаться на каждый столбец (с i элементами) в вторая матрица. Чтобы поэлементный принцип работал, число элементов (столбцов) в первом должно быть равно количеству элементов (строк) во-вторых. Эвристика: m x n * o x p приводит к NO GO, если n < > o. Делать они совпадают, где они касаются?

Определитель (Det):

  Только квадратные матрицы . Дет А = · aij (-1)i+j Det M ij, где M ij — минор числа A с i-я строка и j-й столбец удалены. (Сумма по j для расширения по столбцам, что является обычным способом сделай это). Для больших матриц вычисление определителя выполняется по строке развязки. Определитель может сказать нам о количестве решений к набору уравнений (уникальных, бесконечных?) и различным другим полезным свойствам матрицы.

Характеристические корни системы уравнений. В матричной форме собственные значения (l) определены так, что Det( ​​ A — l I) = 0 [характеристическое уравнение]. Характеристическое уравнение будет многочлен от л степень n , где n — порядок (размер) матрицы. В демографии, доминирующим собственным значением является скорость роста населения, л , в то время как второе собственное значение дает коэффициент затухания (как быстро население вернется к равновесию после возмущения).

Вектор, u , такой, что A*u = l* u. Для матричных моделей правый и левый собственные векторы, соответствующие доминирующим собственным значением являются репродуктивных значения (левый собственный вектор, вектор-строка) и стабильное (st)возрастное распределение (правый собственный вектор, вектор-столбец).

Матрица обычно записывается как I , с 1 (единицы) на главной диагонали и нули в остальных местах.

А ^-1 * А = I . Обратной матрицей называется та матрица, которая при предварительно умноженный на A , дает единичную матрицу. Обратное существует только когда матрица сингулярна (то есть имеет определитель).

Эквивалентно «сильно связанным» на диаграмме теории (см. Кейфиц, стр. 30). Каждая точка на графике (или в матрице) можно добраться из любой другой точки либо напрямую, либо через промежуточные узлы.

Матрица возрастной классификации, используемая в анализе истории жизни. Оно имеет элементы только в верхнем ряду (плодовитость) и по поддиагональному (выживаемость). Чтобы получить стабильное возрастное распределение, матрица должна быть несокращаемый (сильно связанный) и примитивный .

см. Совместимость. Выполнено ряд за столбцом, элемент за элементом. Произведение матрицы r x c * c x s представляет собой матрицу порядок (= размер) r x s (количество строк в первом по количеству столбцы во втором). Итак, совместимость включает в себя два внутренних числа и «порядок» матрицы произведения включает два внешних числа.

Любая матрица, для которой А ^п (для некоторых произвольных n ) имеет только положительные элементы, называется примитивный. Примитивность неотрицательной неприводимой матрицы является достаточным условие стабильности. Для простой матрицы Лесли это означает, что при должны существовать как минимум две возрастные группы, у которых m i > 0 и которые имеют i относительно простые (например, для шестилетнего срока службы плодовитость только в возрастных классах 3 и 6 будет давать циклы, а не стабильную возрастное распределение).

Матрица, определитель которой равен нулю.

Нижний индекс:

Для матрицы A , a ij означает элемент в i-й строке и j-й столбец. A = {aij}, где {} означает «множество».

Матрица симметрична, если она равна своей транспонировать. То есть если А + А ‘.

Только квадратные матрицы . Сумма элементы главной диагонали.

Для матрицы А , транспонировать А ‘ = {arc}’ = {acr} (используйте i и j в качестве индексов, если хотите). То есть элементы в строках из первых становятся элементами столбцов транспонирования.

Рафгарден, Дж. 1979. Приложение 3, стр. 579-590 In : Теория популяционной генетики. и эволюционная экология: введение. Макмиллан, Нью-Йорк

Серл, С.Р. 1966. Матричная алгебра для биологических наук. Wiley and Sons, NY

2.1: Введение в матрицы — Mathematics LibreTexts

1. Последнее обновление

2. Сохранить как PDF

• Рупиндер Секон и Роберта Блум
• Колледж Де Анза

Цели обучения

В этом разделе вы научитесь:

1. Складывать и вычитать матрицы.
2. Умножить матрицу на скаляр.
3. Умножьте две матрицы.

Матрица представляет собой двумерный массив чисел, расположенных в строках и столбцах. Матрицы обеспечивают метод организации, хранения и работы с математической информацией. Матрицы имеют множество применений и использования в реальном мире. Матрицы представляют собой полезный инструмент для работы с моделями, основанными на системах линейных уравнений. Мы будем использовать матрицы в разделах 2.2, 2.3 и 2.4 для решения систем линейных уравнений с несколькими переменными в этой главе.

Матрицы используются в шифровании, которое мы рассмотрим в разделе 2.5, и в экономическом моделировании, рассмотренном в разделе 2.6. Мы снова используем матрицы в главе 4, в задачах оптимизации, таких как максимизация прибыли или дохода или минимизация затрат. Матрицы используются в бизнесе для планирования, маршрутизации транспорта и отгрузок, а также управления запасами.

Почти любое приложение, которое собирает данные и управляет ими, может применять матрицы. Использование матриц расширилось по мере увеличения доступности данных во многих сферах жизни и бизнеса. Они являются важными инструментами для организации данных и решения задач во всех областях науки, от физики и химии до биологии и генетики, метеорологии и экономики. В компьютерных науках за анимацией изображений в фильмах и видеоиграх стоит матричная математика.

Информатика анализирует диаграммы сетей, чтобы понять, как вещи связаны друг с другом, например, отношения между людьми на веб-сайте социальной сети, отношения между результатами линейного поиска и то, как люди ссылаются с одного веб-сайта на другой. Математика для работы с сетевыми диаграммами относится к области «теории графов»; он использует матрицы для организации информации в графах, которые отображают соединения и ассоциации в сети. Например, если вы используете Facebook, Linked-In или другие сайты социальных сетей, эти сайты используют сетевые графики и матрицы для организации ваших отношений с другими пользователями.

Знакомство с матрицами

Матрица представляет собой прямоугольный массив чисел. Матрицы полезны при организации и обработке больших объемов данных. Чтобы получить некоторое представление о том, что такое матрицы, мы рассмотрим следующий пример.

Пример \(\PageIndex{1}\)

Fine Furniture Company производит стулья и столы на своих фабриках в Сан-Хосе, Хейворде и Окленде. Общий объем производства трех заводов в сотнях за 2014 и 2015 годы указан в таблице ниже.

1. Представим производство за 2014 и 2015 годы в виде матриц A и B.
2. Найдите разницу в продажах между 2014 и 2015 годами.
3. Компания прогнозирует, что в 2020 году производство на этих заводах удвоится по сравнению с 2014 годом. Каким будет производство в 2020 году?

Решение

а) Матрицы следующие:

\[A=\left[\begin{array}{ll}
30 и 18 \\
20 и 12 \\
16 & 10
\ end{массив}\right] \nonumber \]

\[\mathrm{B}=\left[\begin{array}{ll}
36 и 20 \\
24 и 18 \\
20 и 12
\ end{array}\right] \nonumber \]

б) Ищем матрицу \(B — A\). Когда две матрицы имеют одинаковое количество строк и столбцов, матрицы можно складывать или вычитать поэлементно. Таким образом, мы получаем

\[\mathrm{B}-\mathrm{A}=\left[\begin{array}{ll}
36-30 и 20-18 \\
24-20 и 18-12 \\
20- 16 & 12-10
\end{массив}\right]=\left[\begin{array}{ll}
6 & 2 \\
4 & 6 \\
4 & 2
\end{массив}\right ] \nonumber \]

c) Нам нужна матрица, вдвое превышающая матрицу 2014, т. е. \(2A\).

Всякий раз, когда матрица умножается на число, каждая запись умножается на число.

\[2 \mathrm{A}=2\left[\begin{array}{ll}
30 и 18 \\
20 и 12 \\
16 и 10
\end{array}\right]=\left[\begin{array}{ll}
60 и 36 \\
40 & 24 \\
32 & 20
\end{array}\right] \nonumber \]

Прежде чем двигаться дальше, нам нужно ознакомиться с некоторыми терминами, связанными с матрицами. Числа в матрице называются элементами или элементами матрицы.

Всякий раз, когда мы говорим о матрице, нам нужно знать размер или размер матрицы. Размерность матрицы — это количество строк и столбцов в ней. Когда мы говорим, что матрица представляет собой «матрицу 3 на 4», мы говорим, что она имеет 3 строки и 4 столбца. Строки всегда упоминаются первыми, а столбцы — вторыми. Это означает, что матрица \(3 \times 4\) не имеет той же размерности, что и матрица \(4 \times 3\).

\[A=\left[\begin{array}{cccc}
1 & 4 & -2 & 0 \\
3 & -1 & 7 & 9 \\
6 & 2 & 0 & 5
\end{массив}\right] \nonumber \]

\[B=\left[\begin{array}{ccc}
2 & 9 & 8 \\
-3 & 0 & 1 \\
6 & 5 & ​​-2 \\
-4 & 7 & 8
\end{array}\right] \nonumber \]

Матрица \(A\) имеет размеры \(3 \times 4\) и матрицу \(B\ ) имеет размеры \(4 \times 3\).

Матрица, в которой количество строк равно количеству столбцов, называется квадратной матрицей . Матрица, в которой все элементы равны нулю, называется нулевой матрицей . Квадратная матрица с единицами вдоль главной диагонали и нулями в остальных местах называется единичной матрицей . Когда квадратная матрица умножается на единичную матрицу того же размера, матрица остается прежней.

\[I=\left[\begin{array}{lll}
1 & 0 & 0 \\
0 & 1 & 0 \\
0 & 0 & 1
\end{array}\right] \nonumber \]

Матрица \(I\) представляет собой \(3 \x 3\) единичную матрицу

Матрица только с одной строкой называется матрицей строк или вектор-строка, и матрица только с одним столбцом называется матрицей-столбцом или вектором-столбцом . Две матрицы равны , если они имеют одинаковый размер и соответствующие элементы равны.

Мы можем выполнять арифметические операции с матрицами. Далее мы определим и приведем примеры, иллюстрирующие операции сложения и вычитания матриц, скалярного умножения и умножения матриц. Обратите внимание, что умножение матриц сильно отличается от того, что вы интуитивно ожидаете, поэтому обратите особое внимание на объяснение. Также обратите внимание, что возможность выполнения матричных операций зависит от того, совместимы ли матрицы по размеру или размерам для этой операции. Определение совместимых размеров различается для разных операций, поэтому внимательно запишите требования для каждой из них.

Сложение и вычитание матриц

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

Пример \(\PageIndex{2}\)

Даны матрицы \(A\), \(B\), \(C\) и \(D\), ниже

\[A=\left [\begin{array}{lll}
1 & 2 & 4 \\
2 & 3 & 1 \\
5 & 0 & 3
\end{массив}\right] \quad B=\left[\begin{ array}{lll}
2&-1&3\
2&4&2\
3 & 6 & 1
\end{массив}\right] \quad C=\left[\begin{array}{l}
4 \\
2 \\
3
\end{массив}\right] \ quad D=\left[\begin{array}{r}
-2 \\
-3 \\
4
\end{array}\right] \nonumber \]

Найти, если возможно.

1. \(А+В\)
2. \(С — Г\)
3. \(А + Д.\)

Решение

Как мы упоминали ранее, сложение и вычитание матриц включают выполнение этих операций поэлементно.

а) Мы добавляем каждый элемент \(A\) к соответствующему элементу \(B\).

\[A+B=\left[\begin{array}{lll}
3 & 1 & 7 \\
4 & 7 & 3 \\
8 & 6 & 4
\end{array}\right] \nonumber \]

б) Так же, как и в задаче выше, мы выполняем вычитание элемент за элементом.

\[\mathrm{C}-\mathrm{D}=\left[\begin{array}{c}
6 \\
5 \\
-1
\end{array}\right] \nonumber \ ]

c) Сумма \(A + D\) не может быть найдена, потому что две матрицы имеют разные размеры.

Примечание. Две матрицы можно складывать или вычитать только , если они имеют одинаковую размерность.

Умножение матрицы на скаляр

Если матрица умножается на скаляр, каждая запись умножается на этот скаляр. Мы можем рассматривать скалярное умножение как умножение числа и матрицы для получения новой матрицы в качестве произведения.

Пример \(\PageIndex{3}\)

Имея матрицы \(A\) и \(C\) в приведенном выше примере, найдите \(2A\) и \(- 3C\).

Решение

Чтобы найти \(2A\), мы умножаем каждый элемент матрицы \(A\) на 2, а чтобы найти \(-3C\), мы умножаем каждый элемент C на -3. Результаты приведены ниже.

а) Умножаем каждую запись A на 2.

\[2 \mathrm{A}=\left[\begin{array}{ccc}
2 & 4 & 8 \\
4 & 6 & 2 \ \
10 & 0 & 6
\end{array}\right] \nonumber \]

b) Мы умножаем каждый элемент C на -3.

\[-3 C=\left[\begin{массив}{c}
-12 \\
-6 \\
-9
\end{array}\right] \nonumber \]

Умножение двух матриц

Умножить одну матрицу на другую не так просто, как сложение, вычитание, или скалярное умножение матриц. Из-за его широкого использования в прикладных задачах важно, чтобы мы хорошо его изучили. Поэтому постараемся изучить процесс поэтапно. Сначала начнем с нахождения произведения матрицы-строки и матрицы-столбца.

Пример \(\PageIndex{4}\)

Найти произведение \(AB\), заданное

\[A=\left[\begin{array}{lll}
2 & 3 & 4
\end{array}\right] \nonumber \]

и

\[B=\left[\begin{array}{l}
a \\
b \\
c
\end{array}\right]. \nonumber \]

Решение

Произведение представляет собой матрицу \(1 \times 1\), элементы которой получаются путем умножения соответствующих элементов и последующего формирования суммы.

\[\begin{align*}
\mathrm{AB} &=\left[\begin{array}{lll}
2 & 3 & 4
\end{массив}\right]\left[\begin{array}{l}
\mathrm{a} \\
\mathrm{b} \\
\mathrm{c}
\ end{массив}\right] \\[4pt] &=[2 (\mathrm{a}+3 \mathrm{b}+4 \mathrm{c})]
\end{align*} \nonumber \]

Обратите внимание, что \(AB\) является матрицей \(1 \times 1\), и ее единственный элемент — \(2a + 3b + 4c\).

Пример \(\PageIndex{5}\)

Найти произведение \(AB\), заданное

\[A=\left[\begin{array}{lll}
2 & 3 & 4
\end {массив}\справа] \номер\]

и

\[B=\left[\begin{array}{l}
5 \\
6 \\
7
\end{array}\right] \nonumber \]

Решение

Снова умножаем соответствующие записи и складываем.

\[\begin{align*} \mathrm{AB} &=\left[\begin{array}{lll}
2 & 3 & 4
\end{массив}\right]\left[\begin{массив }{l}
5 \\
6 \\
7
\end{массив}\right] \\[4pt] &=[2 \cdot 5+3 \cdot 6+4 \cdot 7]\\[4pt ] &=[10+18+28]\\[4pt] &=[56] \end{align*} \nonumber \]

Примечание. Чтобы произведение матрицы-строки и матрицы-столбца существовало, количество элементов в матрице-строке должно совпадать с количеством элементов в матрице-столбце.

Пример \(\PageIndex{6}\)

Найдите произведение AB, учитывая

\[A=\left[\begin{array}{lll}
2 & 3 & 4
\end{array}\ right] \nonumber \]

и

\[B=\left[\begin{array}{ll}
5 & 3 \\
6 & 4 \\
7 & 5
\end{array}\right ]. \номер\]

Решение

Мы знаем, как умножать матрицу-строку на матрицу-столбец. Чтобы найти произведение \(AB\), в этом примере мы умножим матрицу строк \(A\) на первый и второй столбцы матрицы \(B\), в результате чего получим \(1 \times 2\ ) матрица.

\[\mathrm{AB}=\left[\begin{array}{lll}
2 \cdot 5+3 \cdot 6+4 \cdot 7 и 2 \cdot 3+3 \cdot 4+4 \cdot 5
\end{массив}\right]=\left[\begin{array}{ll}
56 и 38
\end{массив}\right] \nonumber \]

Мы умножили матрицу \(1 \times 3\) на матрицу размера \(3 \times 2\). Таким образом, в отличие от сложения и вычитания, можно умножать две матрицы разной размерности, если количество элементов в строках первой матрицы равно количеству элементов в столбцах второй матрицы.

Пример \(\PageIndex{7}\)

Найти произведение \(AB\), учитывая:

\[A=\left[\begin{array}{lll}
2 & 3 & 4 \\
1 и 2 и 3
\end{array}\right] \nonumber \]

и

\[\mathrm{B}=\left[\begin{array}{ll}
5 & 3 \\
6 & 4 \\
7 & 5
\end{array}\right] \nonumber \]

Решение

На этот раз мы умножаем две строки матрицы \(A\) на два столбца матрицы \(B\). Поскольку количество записей в каждой строке \(A\) равно количеству записей в каждом столбце \(B\), произведение возможно. Делаем точно так же, как и в последнем примере. Единственное отличие состоит в том, что матрица \(A\) имеет на одну строку больше.

Умножаем первую строку матрицы \(A\) на два столбца \(B\), по одному, а затем повторяем процесс со второй строкой A. Получаем

\[\ mathrm{AB}=\left[\begin{array}{lll}
2 & 3 & 4 \\
1 & 2 & 3
\end{array}\right]\left[\begin{array}{ll}
5 и 3 \\
6 и 4 \\
7 и 5
\end{массив}\right]=\left[\begin{массив}{ll}
2 \cdot 5+3 \cdot 6+4 \ cdot 7 и 2 \cdot 3+3 \cdot 4+4 \cdot 5 \\
1 \cdot 5+2 \cdot 6+3 \cdot 7 и 1 \cdot 3+2 \cdot 4+3 \cdot 5
\end{массив}\right] \nonumber \]

\[\mathrm{AB}=\left[\begin{array}{ll}
56 и 38 \\
38 и 26
\end{массив} \right] \nonumber \]

Пример \(\PageIndex{8}\)

Найдите, если возможно:

1. \(EF\)
2. \(ФЭ\)
3. \(ФХ\)
4. \(ГХ\)
5. \(HG\)

\[\mathrm{E}=\left[\begin{array}{ll}
1 & 2 \\
4 & 2 \\
3 & 1
\end{array}\right] \quad \mathrm {F}=\left[\begin{массив}{ll}
2 & -1 \\
3 & 2
\end{array}\right] \quad \mathrm{G}=\left[\begin{array}{lll}
4 & 1
\end{array}\ right] \quad \mathrm{H}=\left[\begin{array}{l}
-3 \\
-1
\end{array}\right] \nonumber \]

Решение

a ) Чтобы найти \(EF\), мы умножаем первую строку \(\left[\begin{array}{ll}
1 & 2
\end{array}\right]\)

E со столбцами \ (\left[\begin{array}{l}
2 \\
3
\end{array}\right] \text { и }\left[\begin{array}{l}
1 \\
-2
\end{array}\right]\) матрицы F, а затем повторите процесс, умножив две другие строки E на эти столбцы F. Результат будет следующим:

\[\mathrm{EF}=\left[\begin{array}{ll}
1 & 2 \\
4 & 2 \\
3 & 1
\end{массив}\right]\left[\begin{ array}{cc}
2 & -1 \\
3 & 2
\end{array}\right]=\left[\begin{array}{cc}
1 \cdot 2+2 \cdot 3 & 1 \ cdot-1+2 \cdot 2 \\
4 \cdot 2+2 \cdot 3 и 4 \cdot-1+2 \cdot 2 \\
3 \cdot 2+1 \cdot 3 и 3 \cdot-1+1 \cdot 2
\end{массив}\right]=\left[\begin{массив}{cc}
8 & 3 \\
14 & 0 \\
9 & -1
\end{array}\right] \nonumber \]

б) Произведение \(FE\) невозможно, так как матрица F имеет два элемента в каждой строке, а матрица E имеет по три записи в каждом столбце. Другими словами, матрица F имеет два столбца, а матрица E — три строки.

c) \[\mathrm{FH}=\left[\begin{array}{cc}
2 & -1 \\
3 & 2
\end{массив}\right]\left[\begin{array}{c}
-3 \\
-1
\end{массив}\right]=\left[\begin{array}{c}
2 \cdot-3+-1 \cdot-1 \\
3 \cdot-3+2 \cdot-1
\end{массив}\right]=\left[\begin{массив}{c}
-5 \\
-11
\end{array}\right] \nonumber \]

d) \[\mathrm{GH}=\left[\begin{array}{ll}
4 & 1
\end{array }\right]\left[\begin{array}{l}
-3 \\
-1
\end{array}\right]=\left[\begin{array}{l}
4 \cdot-3 +1 \cdot-1 \\
-1
\end{array}\right]=[-13] \nonumber \]

e) \[\mathrm{HG}=\left[\begin{array}{l}
-3 \\
-1
\end{array}\right]\left[\begin{array}{ll}
4 & 1
\end{array}\right]=\left[\begin{array}{ll}
-3 \cdot 4 & -3 \cdot 1 \\
-1 \cdot 4 & -1 \cdot 1
\end{массив}\right]=\left[\begin{массив}{cc}
-12 & -3 \\
-4 & -1
\end{array}\right] \nonumber \]

Мы суммируем некоторые важные свойства матричного умножения, которые мы наблюдали в предыдущих примерах.

Чтобы продукт \(\bf{AB}\) существовал:

• количество столбцов \(\bf{A}\) должно равняться количеству строк \(\бф{В}\)
• , если матрица \(\bf{A}\) имеет размерность \(\bf{m \times n}\) и матрица \(\bf{B}\) имеет размерность \(\ bf{n \times p}\) , то произведение \(\bf{AB}\) будет матрицей размерности \(\bf{m \times p}\) .

Умножение матриц не является коммутативным: если оба матричных произведения \(\bf{AB}\) и \(\bf{BA}\) существуют, большую часть времени \(\bf{AB} \) не будет равно \(\bf{BA}\) .

Пример \(\PageIndex{9}\)

По заданным ниже матрицам \(R\), \(S\) и \(T\) найдите \(2RS — 3ST\).

\[R=\left[\begin{array}{lll}
1 & 0 & 2 \\
2 & 1 & 5 \\
2 & 3 & 1
\end{массив}\right] \quad S=\left[\begin{array}{lll}
0 & -1 & 2 \\
3 & 1 & 0 \\
4 & 2 & 1
\end {array}\right] \quad T=\left[\begin{array}{lll}
-2 & 3 & 0 \\
-3 & 2 & 2 \\
-1 & 1 & 0
\end{ array}\right] \nonumber \]

Решение

Перемножаем матрицы R и S.

\begin{aligned}
&\mathrm{RS}=\left[\begin{array}{ccc}
8 & 3 & 4 \
23 & 9 & 9 \\
13 & 3 & 5
\end{массив}\right]\\
&\begin{массив}{l}
2 \mathrm{RS}=2\left[\begin{ array}{ccc}
8 & 3 & 4 \\
23 & 9 & 9 \\
13 & 3 & 5
\end{array}\right]=\left[\begin{array}{ccc}
16 & 6 & 8 \\
46 & 18 & 18 \\
26 & 6 & 10
\end{массив}\right] \\
\mathrm{ST}=\left[\begin{array}{ccc}
1&0&-2\
-9&11&2\
-15&17&4
\end{массив}\right] \\
3 \mathrm{ST}=3\left[\begin{array}{ccc}
1 & 0 & -2 \\
-9 & 11 & 2 \\
-15 & 17 & 4
\end{array}\right]=\left[\begin{array}{ccc}
3 & 0 & -6 \\
-27 & 33 & 6 \\
-45 & 51 & 12
\end{массив}\right]
\end{массив}
\end{выровненный}

Таким образом,

\[2 \mathrm{RS}-3 \mathrm{ST}=\left[\begin{ array}{ccc}
16 & 6 & 8 \
46 & 18 & 18 \ 92\), возможен только в том случае, если матрица является квадратной матрицей.

ИСПОЛЬЗОВАНИЕ МАТРИЦ ДЛЯ ПРЕДСТАВЛЕНИЯ СИСТЕМЫ ЛИНЕЙНЫХ УРАВНЕНИЙ

В этой главе мы будем использовать матрицы для решения линейных систем. В разделе 2.4 нас попросят выразить линейные системы в виде матричного уравнения \(\bf{AX = B}\), где \(A\), \(X\) и \(B\) матрицы.

• Матрица \(A\) называется матрицей коэффициентов .
• Матрица \(X\) — это матрица с 1 столбцом, содержащим переменные.
• Матрица \(B\) — это матрица с 1 столбцом, содержащая константы.

Пример \(\PageIndex{11}\)

Проверить, что система двух линейных уравнений с двумя неизвестными:

\begin{array}{l}
a x+b y=h \\
c x+d y =k
\end{array}

можно записать как \(AX = B\), где

\[A=\left[\begin{array}{ll}
a & b \\
c & d
\end{массив}\right] \quad X=\left[\begin{array}{l}
x \\
y
\end{массив}\right] \text { и } B=\left[\ начало {массив} {l}
h \\
k
\end{array}\right] \nonumber \]

Решение

Если мы перемножим матрицы \(A\) и \(X\), то получим

\[A X =\left[\begin{array}{ll}
a & b \\
c & d
\end{массив}\right]\left[\begin{array}{l}
x \\
y
\ end{массив}\right]=\left[\begin{массив}{c}
a x+b y \\
c x+d y
\end{массив}\right] \nonumber \]

Если \(AX = B\) тогда

\[\left[\begin{array}{l}
a x+b y \\
c x+d y
\end{массив}\right]=\left[\begin{array}{l}
h \\
k
\end{массив}\right] \nonumber \]

Если две матрицы равны, то равны и их соответствующие записи. Отсюда следует, что

\begin{array}{l}
a x+b y=h \\
c x+d y=k
\end{array}

Пример \(\PageIndex{12}\)

Express следующую систему в виде матричного уравнения вида \(AX = B\).

\begin{array}{l}
2 x+3 y-4 z=5 \\
3 x+4 y-5 z=6 \\
5 x \quad-6 z=7
\end{array}

Решение

Эта система уравнений может быть выражена в форме \(AX = B\), как показано ниже.

\[\left[\begin{array}{ccc}
2 & 3 & -4 \\
3 & 4 & -5 \\
5 & 0 & -6
\end{array}\right]\ left[\begin{array}{l}
x \\
y \\
z
\end{array}\right]=\left[\begin{array}{l}
5 \\
6 \\
7
\конец{массив}\право] \номер\]

Эта страница под названием 2.1: Introduction to Matrices распространяется под лицензией CC BY 4.0 и была создана, изменена и/или курирована Рупиндером Секоном и Робертой Блум с использованием исходного контента, который был отредактирован в соответствии со стилем и стандартами платформы LibreTexts; подробная история редактирования доступна по запросу.

1. Наверх

• Была ли эта статья полезной?

1. Тип изделия

   Раздел или страница

   Автор

   Рупиндер Сехон и Роберта Блум

   Лицензия

   СС BY

   Версия лицензии

   4,0

   Показать страницу TOC

   нет

2. Теги

   1. Матрица коэффициентов
   2. вектор-столбец
   3. размер
   4. элементов
   5. записей
   6. тождественная матрица
   7. вектор-строка
   8. источник@https://www. deanza.edu/faculty/bloomroberta/math21/afm3files.html.html
   9. квадратная матрица
   10. нулевая матрица

Матрицы и массивы — MATLAB & Simulink

Основное содержание

Open Live Script

MATLAB — это сокращение от «матричная лаборатория». В то время как другие языки программирования в основном работают с числами по одному, MATLAB® предназначен для работы в основном с целыми матрицами и массивами.

Все переменные MATLAB являются многомерными массивами , независимо от типа данных. А 9Матрица 0451 представляет собой двумерный массив, часто используемый для линейной алгебры.

Создание массива

Чтобы создать массив из четырех элементов в одной строке, разделите элементы запятой ( , ) или пробелом.

 а = [1 2 3 4] 

 а =  1×4 
     1 2 3 4
 

Этот тип массива представляет собой вектор-строку .

Чтобы создать матрицу из нескольких строк, разделите строки точкой с запятой.

 а = [1 3 5; 2 4 6; 7 8 10] 

 а =  3×3 
     1 3 5
     2 4 6
     7 8 10
 

Другой способ создать матрицу — использовать функцию, например единиц , нулей или ранд . Например, создайте вектор-столбец 5 на 1 из нулей.

 z = нули (5,1) 

 z =  5×1 
     0
     0
     0
     0
     0
 

Операции с матрицами и массивами

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

 а + 10 

 анс =  3×3 
    11 13 15
    12 14 16
    17 18 20
 

 sin(a) 

 ans =  3×3 
    0,8415 0,1411 -0,9589
    0,9093 -0,7568 -0,2794
    0,6570 0,9894 -0,5440
 

Чтобы транспонировать матрицу, используйте одинарную кавычку ( ' ):

 ans =  3×3 
     1 2 7
     3 4 8
     5 6 10
 

Вы можете выполнить стандартное умножение матриц, которое вычисляет внутренние произведения между строками и столбцами, используя * оператор. Например, подтвердите, что матрица, умноженная на свою обратную, возвращает единичную матрицу:

 p = a*inv(a) 

 p =  3×3 
    1,0000 0,0000 -0,0000
         0 1,0000 -0,0000
         0 0,0000 1,0000
 

Обратите внимание, что p не является матрицей целочисленных значений. MATLAB хранит числа как значения с плавающей запятой, а арифметические операции чувствительны к небольшим различиям между фактическим значением и его представлением с плавающей запятой. Вы можете отобразить больше десятичных цифр, используя формат команда:

 формат длинный
p = a*inv(a) 

 p =  3×3 
   0,999999999999996 0,000000000000007 -0,000000000000002
                   0 1.000000000000000 -0.000000000000003
                   0 0,000000000000014 0,999999999999995
 

Сбросьте отображение на более короткий формат, используя

 формат short 

формат влияет только на отображение чисел, а не на то, как MATLAB их вычисляет или сохраняет.

Чтобы выполнить поэлементное умножение, а не матричное умножение, используйте .* оператор:

 p = a.*a 

 p =  3×3 
     1 9 25
     4 16 36
    49 64 100
 

Каждому из матричных операторов умножения, деления и возведения в степень соответствует оператор массива, работающий поэлементно. Например, возведите каждый элемент и в третью степень:

 анс =  3×3 
           1 27 125
           8 64 216
         343 512 1000
 

Конкатенация

Конкатенация — это процесс объединения массивов для получения больших массивов. Фактически вы создали свой первый массив, объединив его отдельные элементы. Пара квадратных скобок [] — это оператор конкатенации.

 А = [а, а] 

 А =  3×6 
     1 3 5 1 3 5
     2 4 6 2 4 6
     7 8 10 7 8 10
 

Объединение массивов рядом друг с другом с помощью запятых называется горизонтальная конкатенация. Каждый массив должен иметь одинаковое количество строк. Точно так же, когда массивы имеют одинаковое количество столбцов, вы можете объединить 90 451 по вертикали с 90 452, используя точку с запятой.

 А = [а; а] 

 А =  6×3 
     1 3 5
     2 4 6
     7 8 10
     1 3 5
     2 4 6
     7 8 10
 

Комплексные числа

Комплексные числа имеют как действительную, так и мнимую части, где мнимой единицей является квадратный корень из -1 .

 sqrt(-1) 

 анс = 0,0000 + 1,0000i
 

Для представления мнимой части комплексного числа используйте i или j .

 с = [3+4i, 4+3j; -i, 10j] 

 c =  Комплекс 2×2 
   3.0000 + 4.0000i 4.0000 + 3.0000i
   0,0000 - 1,0000i 0,0000 +10,0000i
 

Начало работы с MATLAB

Следующий

У вас есть модифицированная версия этого примера. Хотите открыть этот пример со своими правками?

Вы щелкнули ссылку, соответствующую этой команде MATLAB:

Запустите команду, введя ее в командном окне MATLAB. Веб-браузеры не поддерживают команды MATLAB.

Выберите веб-сайт, чтобы получить переведенный контент, где он доступен, и ознакомиться с местными событиями и предложениями. В зависимости от вашего местоположения мы рекомендуем вам выбрать: .

Вы также можете выбрать веб-сайт из следующего списка:

Европа

Свяжитесь с местным офисом

• Пробная версия ПО
• Пробная версия программного обеспечения
• Обновления продукта
• Обновления продукта

Определение умножения матриц

Матричная арифметика