`Dom`:: `Matrix`

Матрицы

Блокноты MuPAD® будут демонтированы в будущем релизе. Используйте live скрипты MATLAB® вместо этого.

Live скрипты MATLAB поддерживают большую часть функциональности MuPAD, хотя существуют некоторые различия. Для получения дополнительной информации смотрите, Преобразовывают Notebook MuPAD в Live скрипты MATLAB.

Синтаксис

Доменное создание

Dom::Matrix(<R>)

Создание элемента

Dom::Matrix(R)(Array)

Dom::Matrix(R)(List)

Dom::Matrix(R)(ListOfRows)

Dom::Matrix(R)(Matrix)

Dom::Matrix(R)(m, n)

Dom::Matrix(R)(m, n, Array)

Dom::Matrix(R)(m, n, List)

Dom::Matrix(R)(m, n, ListOfRows)

Dom::Matrix(R)(m, n, Table)

Dom::Matrix(R)(m, n, [(i₁, j₁) = value₁, (i₂, j₂) = value₂, …])

Dom::Matrix(R)(m, n, f)

Dom::Matrix(R)(m, n, List, Diagonal)

Dom::Matrix(R)(m, n, g, Diagonal)

Dom::Matrix(R)(m, n, List, Banded)

Dom::Matrix(R)(1, n, Array)

Dom::Matrix(R)(1, n, List)

Dom::Matrix(R)(1, n, Table)

Dom::Matrix(R)(1, n, [j₁ = value₁, j₂ = value₂, …])

Dom::Matrix(R)(m, 1, Array)

Dom::Matrix(R)(m, 1, List)

Dom::Matrix(R)(m, 1, Table)

Dom::Matrix(R)(m, 1, [i₁ = value₁, i₂ = value₂, …])

Описание

Доменное создание

Dom::Matrix(R) создает области матриц по доменному R компонента категории Cat::Rng (звонок, возможно без модуля).

Если дополнительный параметр, который R не дан, Dom::ExpressionField(), используется в качестве области компонента. Матрицы этого типа принимают произвольные выражения MuPAD^® (числа, символы и т.д.) как записи. Имя matrix является псевдонимом для этого матричного доменного Dom::Matrix() по умолчанию.

Вектором с записями n является любой n ×1 матрица (вектор-столбец), или 1×n матрица (вектор - строка).

Арифметические операции с матрицами могут быть выполнены при помощи стандартных арифметических операторов MuPAD.

Например, если A и B являются двумя матрицами, заданными Dom::Matrix(R), A + B вычисляет сумму, и A * B вычисляет продукт этих двух матриц, при условии, что размерности являются соответствующими.

Точно так же A^(-1) или 1/A вычисляют инверсию квадратной матрицы A, если это существует. В противном случае FAIL возвращен. Смотрите Пример 1.

Много системных функций перегружаются для матриц, таких как map, subs, has, zip, Например, используют conjugate, чтобы вычислить сопряженное комплексное число матрицы, norm, чтобы вычислить матричные нормы или exp, чтобы вычислить экспоненциал матрицы.

Большинство функций в пакете линейной алгебры MuPAD linalg работает с матрицами. Например, команда linalg::gaussJordan(A) выполняет Исключение по Гауссу-Жордану на A, чтобы преобразовать A к его приведенному ступенчатому по строкам виду матрицы.

См. документацию linalg для списка доступных функций этого пакета.

Доменный Dom::Matrix(R) представляет матрицы по R произвольного размера. Поэтому это не имеет никакой алгебраической структуры (кроме того, чтобы быть набором матриц).

В этой странице справки мы используем следующие обозначения для матричного A (элемент Dom::Matrix(R)):

nrows (A) обозначает количество строк A.
ncols (A) обозначает количество столбцов A.
Индекс строки является целым числом в диапазоне от 1 до nrows (A).
Индекс столбца является целым числом в диапазоне от 1 до ncols (A).

Примечание

Количество строк и столбцов, соответственно, матрицы должно быть ^{меньше чем 231}.

Примечание

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

Создание элемента

Dom::Matrix(R)(Array) и Dom::Matrix(R)(Matrix) создают новую матрицу с размерностью и компонентами Array и Matrix, соответственно.

Компоненты Array или Matrix преобразованы в элементы доменного R. Сообщение об ошибке выпущено, если одно из этих преобразований перестало работать.

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

Dom::Matrix(R)(List) создает m ×1 вектор-столбец с компонентами, взятыми из непустого списка, где m является количеством записей List.

Можно также использовать список уравнений, чтобы создать объект Dom::Matrix. В этом случае записи списка должны иметь форму (i, j) = value, где i и j обозначают индекс строки и столбца и value коэффициент матрицы. i и j должны быть положительными целыми числами.

Dom::Matrix(R)(ListOfRows) создает m ×n матрица с компонентами, взятыми из вложенного списка ListOfRows, где m является количеством внутренних списков ListOfRows, и n является максимальным числом элементов внутреннего списка. Каждый внутренний список соответствует строке матрицы. И m и n должны быть ненулевыми.

Если внутренний список имеет меньше, чем записи n, остающиеся компоненты в соответствующей строке матрицы обнуляются.

Записи внутренних списков преобразованы в элементы доменного R. Сообщение об ошибке выпущено, если одно из этих преобразований перестало работать.

Вызов Dom::Matrix(R)(m, n) возвращает m ×n нулевая матрица.

Используйте метод "identity", чтобы создать n ×n единичная матрица.

Dom::Matrix(R)(m, n, Array) вызова создает m ×n матрица с компонентами, взятыми из Array, который должен быть массивом или hfarray. Array должен иметь m n операнды. Первые операнды m задают первую строку, следующие операнды m задают вторую строку и т.д. Форматирование массива не важно. Например, любой массив с 6 элементами может использоваться, чтобы создать матрицу размерности 1 ×6, или 2×3, или 3×2, или 6 ×1.

Dom::Matrix(R)(m, n, List) создает m ×n матрица с компонентами взятая строка после строки из непустого списка. Список должен содержать m n записи.

Dom::Matrix(R)(m, n, ListOfRows) создает m ×n матрица с компонентами, взятыми из списка ListOfRows.

Если m ≥ 2 и n ≥ 2, то ListOfRows должен состоять из в большей части m внутренние списки, каждый имеющий при большинстве записей n. Внутренние списки соответствуют строкам возвращенной матрицы.

Если внутренний список имеет меньше, чем записи n, остающиеся компоненты соответствующей строки матрицы обнуляются. Если существуют меньше, чем m внутренние списки, остающиеся более низкие строки матрицы заполнены, обнуляет.

Dom::Matrix(R)(m, n, Table) создает m ×n матрица с компонентами, взятыми из таблицы Table.

Путем определения записей таблицы сначала, можно легко создать большой и разреженные матрицы. Запись Table[i, j] таблицы будет записью в i-th строка и j-th столбец матрицы. Поэтому таблица должна быть индексирована положительными целыми числами i и j.

Dom::Matrix(R)(m, n, [(i1, j1) = value1, (i2, j2) = value2, ...]) является дальнейшим способом создать матрицу, задающую только ненулевые записи A[i1, j1] = value1, A[i2, j2] = value2 и т.д. Упорядоченное расположение записей в списке входов не важно.

Dom::Matrix(R)(m, n, f) возвращает матрицу, чья (i, j)-th компонент значение вызова функции f(i, j). Индекс строки i колеблется от 1 до m и индекса столбца j от 1 до n.

Значения функции преобразованы в элементы доменного R. Сообщение об ошибке выпущено, если одно из этих преобразований перестало работать.

Dom::Matrix(R)(1, n, Array) возвращает 1 ×n вектор - строку с компонентами, взятыми из Array. array или hfarray Array должны иметь записи n.

Записи массива преобразованы в элементы доменного R. Сообщение об ошибке выпущено, если одно из этих преобразований перестало работать.

Dom::Matrix(R)(1, n, List) возвращает 1 ×n вектор - строку с компонентами, взятыми из List. Список List должен иметь при большинстве записей n. Если существует меньше записей, остающиеся векторные компоненты обнуляются.

Записи списка преобразованы в элементы доменного R. Сообщение об ошибке выпущено, если одно из этих преобразований перестало работать.

Dom::Matrix(R)(1, n, Table) возвращает 1 ×n вектор - строку с компонентами, взятыми из Table. Таблица Table не должна иметь больше, чем записи n. Если существует меньше записей, остающиеся векторные компоненты рассматриваются как нуль.

Dom::Matrix(R)(m, 1, Array) возвращает m ×1 вектор-столбец с компонентами, взятыми из Array. array или hfarray Array должны иметь записи m.

Dom::Matrix(R)(m, 1, List) возвращает m ×1 вектор-столбец с компонентами, взятыми из List. Список List должен иметь при большинстве записей m. Если существует меньше записей, остающиеся векторные компоненты обнуляются.

Dom::Matrix(R)(m, 1, Table) возвращает m ×1 вектор-столбец с компонентами, взятыми из Table. Таблица Table должна иметь не больше, чем записи m. Если существует меньше записей, остающиеся векторные компоненты рассматриваются как нуль.

Суперобласть

Dom::BaseDomain

Аксиомы

Если R имеет Ax::canonicalRep, то Ax::canonicalRep.

Категории

Cat::Matrix (R)

Примеры

Пример 1

Каждый раз, когда возможно, нужно использовать Dom::ExpressionField () в качестве содействующей области матриц – поэтому Dom::ExpressionField, () является содействующей областью по умолчанию матриц.

Компоненты матриц по Dom::ExpressionField () могут быть произвольными арифметическими выражениями. Рассмотреть

Mat := Dom::Matrix()

Мы присвоили область идентификатору Mat, и теперь мы можем задать матричный A двух строк, где каждая строка является списком двух элементов следующей строкой:

A := Mat([[1, 5], [2, 3]])

Таким же образом мы задаем следующие 2 ×3 матрицы:

B := Mat([[-1, 5/2, 3], [1/3, 0, 2/5]])

и выполните матричную арифметику с помощью стандартных арифметических операторов MuPAD, например, матричное произведение A B, четвертая степень A, а также скалярное умножение времен A:

A * B, A ^ 4, 1/3 * A

Матрицы A и B имеют различные размерности, и поэтому сумму A и B, не заданы. MuPAD выдает ошибку сообщение:

A + B

Error: Dimensions do not match. [(Dom::Matrix(Dom::ExpressionField()))::_plus]

Чтобы вычислить инверсию A, только войдите:

1/A

Если матрица не является обратимой, FAIL является результатом этой операции. Например, матрица:

C := Mat(2, 2, [[2]])

не является обратимым, следовательно:

C^(-1)

delete A, B, C:

Пример 2

Мы создаем область матриц по звонку coeffcient Dom::ExpressionField():

Mat := Dom::Matrix()

Около стандартной матричной арифметики библиотека linalg предлагает много функций, имеющих дело с матрицами. Например, если вы хотите вычислить ранг матрицы, используйте linalg::rank:

A := Mat([[1, 2], [2, 4]])

linalg::rank(A)

Используйте linalg::eigenvectors, чтобы вычислить собственные значения и собственные вектора матричного A:

linalg::eigenvectors(A)

Попробуйте info(linalg) за список доступных функций или введите help(linalg) для получения дополнительной информации о библиотеке linalg.

Некоторые функции в пакете linalg просто служат “интерфейсными” функциями для методов матричной области, описанной выше. Например, linalg::transpose использует метод "transpose", чтобы получить транспонированную матрицу. Функциональный linalg::gaussElim применяет Исключение Гаусса к матрице путем вызова метода "gaussElim":

linalg::gaussElim(A) = A::dom::gaussElim(A)[1]

В отличие от методов доменного Dom::Matrix(R), соответствующие функции пакетов linalg делают расширенную проверку своих входных параметров. Обратите внимание на то, что могут быть незначительные различия в функциональности функций linalg и матричных методов. Например, опция ColumnElimination не доступна в linalg::gaussElim, но только в методе "gaussElim" матричной области:

A::dom::gaussElim(A, ColumnElimination)

delete A:

Пример 3

Мы создаем матричный доменный Dom::Matrix() по умолчанию. Как ярлык, эта область может также быть создана через matrix:

A := matrix([[ 1, 2, 3, 4], 
                   [ 2, 0, 4, 1], 
                   [-1, 0, 5, 2]])

domtype(A)

Матричные компоненты могут быть извлечены индексным оператором []:

A[2, 1] * A[1, 2] - A[3, 1] * A[1, 3]

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

delete a:
A[1, 2] := a^2: A

Около обычной индексации матричных компонентов также возможно извлечь подматрицы из данной матрицы. Следующий вызов создает субматрицу A, который состоит из строк 2 - 3 и столбцов 1 - 3 A:

A[2..3, 1..3]

Индексный оператор не позволяет вставлять подматрицы в данную матрицу. Это реализовано функциональным linalg::substitute.

delete A:

Пример 4

В следующих примерах мы демонстрируем различные способы создать матрицы. Мы работаем с матрицами, заданными по полю ℤ₁₉, т.е. полю целых чисел по модулю 19. Этот звонок компонента может быть создан с доменным конструктором Dom::IntegerMod.

Мы запускаем путем предоставления списка строк, где каждая строка является списком записей строки:

MatZ19 := Dom::Matrix(Dom::IntegerMod(19)):
MatZ19([[1, 2], [2]])

Элементы двух внутренних списков, записей строки, были преобразованы в элементы доменного Dom::IntegerMod(19).

Количество строк является количеством подсписков аргумента, т.е. m = 2. Количество столбцов определяется длиной внутреннего списка с большинством записей, который является первым внутренним списком с двумя записями. Недостающие записи в других внутренних списках обработаны как нулевые компоненты. Вызов:

MatZ19(4, 4, [[1, 2], [2]])

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

Сообщение об ошибке выпущено, если одна из данных записей не может быть преобразована в элемент по ℤ ₁₉:

MatZ19([[2, 3], [-1, I]])

Error: Unable to define a matrix over 'Dom::IntegerMod(19)'. [(Dom::Matrix(Dom::IntegerMod(19)))::new]

delete MatZ19:

Пример 5

Этот пример иллюстрирует, как создать матрицу с компонентами, данными как значения индексной функции. Сначала мы создаем 2 ×2 Гильбертовых матрицы (см. также функции linalg::hilbert и linalg::invhilbert):

Dom::Matrix()(2, 2, (i, j) -> 1/(i + j - 1))

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

delete x:
Dom::Matrix()(2, 2, x), Dom::Matrix()(2, 2, (i, j) -> x)

Пример 6

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

Mat := Dom::Matrix():
Mat(3, 4, [1, 2, 3], Diagonal)

Следовательно, чтобы задать n ×n единичная матрица, можно войти:

Mat(3, 3, [1 $ 3], Diagonal)

или вызов:

Mat(3, 3, x -> 1, Diagonal)

Самый легкий способ создать единичную матрицу, однако, состоит в том, чтобы использовать метод "identity":

Mat::identity(3)

delete Mat:

Пример 7

Матрицы Теплица могут быть заданы с опцией Banded. Следующий вызов задает три ленточных матрицы с 2 компонента на основной диагонали и компоненте - 1 на первой поддиагонали и супердиагонали:

Dom::Matrix()(4, 4, [-1, 2, -1], Banded)

Пример 8

Некоторые системные функции могут быть применены к матрицам, таким как norm, expand, diff, conjugate или exp.

Например, чтобы расширить компоненты матрицы:

delete a, b: 
A := Dom::Matrix()(
  [[(a - b)^2, a^2 + b^2], [a^2 + b^2, (a - b)*(a + b)]]
)

войдите:

expand(A)

Если вы хотите дифференцировать матричные компоненты, то вызовите, например:

diff(A, a)

Заменять матричными компонентами некоторыми значениями, введите:

subs(A, a = 1, b = -1)

Функциональный zip может также быть применен к матрицам. Следующий вызов комбинирует две матрицы A и B путем деления каждого компонента A соответствующим компонентом B:

A := Dom::Matrix()([[4, 2], [9, 3]]): 
B := Dom::Matrix()([[2, 1], [3,-1]]):
zip(A, B, `/`)

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

Если нужно применить функцию к компонентам матрицы, то используйте функциональный map. Например, чтобы упростить компоненты матрицы:

C := Dom::Matrix()(
  [[sin(x)^2 + cos(x)^2, cos(x)*tan(x)], 
  [(a^2 - b^2)/(a + b), 1]]
)

вызов:

map(C, Simplify)

delete A, B, C:

Пример 9

Однако там может появиться некоторые неожиданные результаты с помощью функционального diff в контексте матриц. Производная следующего незаданного функционального f матрицы вычисляется из-за цепочечного правила:

diff(f(matrix([[a*x^2, b], [c, d]])), x)

Обычно, функциональный f был бы неявно принят, чтобы быть скаляром. Следовательно, производная f должна быть скаляром также. В вышеупомянутой ситуации цепочечное правило применяется для дифференцирования: внутренняя функция является матрицей, содержащей символьные компоненты a*x^2, b, c и d. Его производная вычисляется путем простого применения diff к каждому компоненту матрицы:

diff(matrix([[a*x^2, b], [c, d]]), x)

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

Пример 10

Вектор-столбец представлен 2×1 матрица:

Mat := Dom::Matrix():
v := Mat(2, 1, [1, 2])

Размерность этого вектора:

Mat::matdim(v)

Длина вектора может также быть запрошена linalg::vecdim или nops(v):

linalg::vecdim(v)

i th компонент этого вектора может быть извлечен двумя способами: или v[i, 1] или v[i]:

v[1], v[2]

Мы вычисляем 2-норму v следующим вызовом:

norm(v, 2)

delete Mat, v:

Пример 11

Мы создаем случайные матрицы по полю рациональных чисел. Рассмотрите случайный матричный A1 с 3 строками и 3 столбцами:

Mat := Dom::Matrix(Dom::Rational):
A1 := Mat::random(3, 3)

Второй матричный A2 должен содержать самое большее 2 ненулевых записи. Мы можем создать такую матрицу при помощи 2 в качестве третьего аргумента для random:

A2 := Mat::random(3, 3, 2)

Продуктом этих матриц дают

C := A1 * A2

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

C::dom::doprint(C)

С этим методом можно также распечатать большие разреженные матрицы. Мы создаем случайную разреженную матрицу с 100 строками, 200 столбцами и самое большее 6 ненулевыми записями:

X := Mat::random(100, 200, 6):  print(X)

Warning: Matrix too large for display. To see all nonzero entries of a matrix A, use 'A::dom::doprint(A)'. [(Dom::Matrix(Dom::Rational))::print]

Предупреждение выступает за себя. X рассматривается как 'слишком большой для отображения' с тех пор с 'плотным' режимом вывода по умолчанию, разреженная матрица была бы распечатана, когда огромная подобная массиву структура размерности 100×200 с (целым числом) обнуляет в пустых местах. Разреженный режим печати должен использоваться:

X::dom::doprint(X)

Для удобства существует функциональный doprint, который вызывает этот метод, только войдя:

doprint(X)

delete Mat, A1, A2, C, X:

Параметры

`R`	Звонок, т.е. область категории `Cat::Rng`. Звонком по умолчанию является `Dom::ExpressionField()`.
`Array`	Один - или двумерный `array` или `hfarray`
`Matrix`	Матрица, т.е. элемент области категории `Cat::Matrix`
`m, n`	Матричная размерность (положительные целые числа)
`List`	Список матричных компонентов
`ListOfRows`	Список в большинстве строк `m`; каждая строка, данная как список в большинстве матричных компонентов `n`
`Table`	Таблица коэффициентов матрицы для разреженного входа
`f`	Функция или функциональное выражение с двумя параметрами (индекс строки и столбца)
`g`	Функция или функциональное выражение с одним параметром (индекс строки)

Опции

Diagonal

Создайте диагональную матрицу

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

Dom::Matrix(R)(m, n, List, Diagonal) создает m ×n диагональная матрица, диагональные элементы которой являются записями List.

List должен иметь в большей части min (m, n) записи. Если это имеет меньше элементов, остающиеся диагональные элементы обнуляются.

Записи List преобразованы в элементы доменного R. Сообщение об ошибке выпущено, если одно из этих преобразований перестало работать.

Dom::Matrix(R)(m, n, g, Diagonal) возвращает разреженную матрицу, i которой th диагональный элемент является g(i, i), куда индекс i запускается от 1 до min (m, n).

Banded

Создайте матрицу Теплица

Dom::Matrix(R)(m, n, List, Banded) создает m ×n матрица Теплица с элементами List как записи. Количество записей List должно быть нечетным, сказать 2 h + 1 и не должно превышать 2 min (m, n) - 1. Пропускная способность получившейся матрицы самое большее 2 h + 1.

Матрица Теплица является матрицей, где элементы каждой полосы идентичны. См. также Пример 7.

Все элементы основной диагонали созданной матрицы инициализируются со средним элементом List. Все элементы i-th поддиагональ инициализируются с (h + 1 - i)-th элемент List. Все элементы i-th супердиагональ инициализируются с (h + 1 + i)-th элемент List. Все записи на остающемся под - и супердиагонали обнуляются.

Записи

issparse	`всегда TRUE`.
"randomDimen"	установлен в `[10, 10]`. См. метод `"random"` ниже для деталей.

Методы

развернуть все

Математические методы

`_divide` — Разделите матрицы

_divide(A, B)

Сообщение об ошибке выпущено, если размерности A и B не соответствуют.

Этот метод только существует, если R является коммутативным звонком с модулем, т.е. областью категории Cat::Ring.

Этот метод перегружает системную функцию _divide для матриц, т.е. можно использовать его в форме A / B, или в функциональном обозначении: _divide(A, B).

`_invert` — Вычислите инверсию матрицы

_invert(A, Normal = b)

Этот метод только существует, если R является областью категории Cat::Ring.

Этот метод перегружает системную функцию _invert для матриц, т.е. можно использовать его в форме 1/A или A^(-1), или в функциональном обозначении: _invert(A).

Если Normal = TRUE, то матричная инверсия всегда возвращается в нормированной форме. Для получения дополнительной информации о нормализации, смотрите normal. Если Normal = FALSE, то матричная инверсия может появиться в нормированной форме, но нормализация не гарантируется. Normal = TRUE по умолчанию.

Normal влияет на результаты, только если матрица содержит переменные или точные выражения, такие как sqrt(5) или sin(PI/7).

`mod` Сопоставьте оператор по модулю с элементами матрицы

_mod(A, n)

n должен быть ненулевым, и a mod n должен быть задан для каждой записи a A.

Этот метод перегружает функциональный _mod для матриц; можно использовать его в форме A mod n, или в функциональном обозначении: _mod(A, n).

`_mult` — Матрицы мультиплие матрицами, векторами и скалярами

_mult(x, y)

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

В противном случае y преобразован в матрицу доменного типа x. Если это преобразование перестало работать, это вызовы метода метод "_mult" области y, дающего все аргументы в том же порядке.

Если x является матрицей того же доменного типа как y, матричное произведение, x y вычисляется. Сообщение об ошибке выпущено, если размерности матриц не соответствуют.

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

В противном случае x преобразован в матрицу доменного типа y. Если это преобразование перестало работать, FAIL возвращен.

Этот метод обрабатывает больше чем два аргумента путем вызова себя рекурсивно с первой половиной всех аргументов и последней половиной всех аргументов. Затем продукт этих двух результатов вычисляется с системной функцией _mult.

Этот метод перегружает системную функцию _mult для матриц, т.е. можно использовать его в форме x * y, или в функциональном обозначении: _mult(x, y).

`_negate` — Инвертируйте матрицу

_negate(A)

Этот метод перегружает системную функцию _negate для матриц, т.е. можно использовать его в форме -A, или в функциональном обозначении: _negate(A).

`плюс` Добавьте матрицы

_plus(A, B, …)

Аргументы A, B , ... преобразованы в матрицы доменного типа Dom::Matrix(R). FAIL возвращен, если одно из этих преобразований перестало работать.

Этот метод перегружает системную функцию _plus для матриц, т.е. можно использовать его в форме A + B, или в функциональном обозначении: _plus(A, B).

`_power` — Целочисленная степень матрицы

_power(A, n)

Если степень, n является отрицательным целым числом затем A, должна быть несингулярной, и R должен быть областью категории Cat::IntegralDomain. В противном случае FAIL возвращен.

Если n является нулем, и кольцевой R компонента является звонком без модуля (т.е. категории Cat::Rng, но не категории Cat::Ring), FAIL возвращен.

Этот метод перегружает системную функцию _power для матриц, т.е. можно использовать его в форме A^n, или в функциональном обозначении: _power(A, n).

`conjugate` — Сопряженное комплексное число матрицы

conjugate(A)

Этот метод только существует, если R реализует метод "conjugate", который вычисляет сопряженное комплексное число элемента доменного R.

Этот метод перегружает системную функцию conjugate для матриц, т.е. можно использовать его в форме conjugate(A).

`потому что` Косинус матрицы

cos(A)

Если A не является квадратным, сообщение об ошибке выпущено. Если область компонента A не позволяет вычисление cos(elem) для произвольного элемента elem звонка компонента, FAIL возвращен.

Этот метод использует функциональный numeric::expMatrix для приближения с плавающей точкой экспоненциала A, если A задан по доменному Dom::Float.

Если некоторые собственные значения A не существуют в R или не могут быть вычислены, то FAIL возвращен.

В символьном случае функции называются exp и linalg::jordanForm. Последний не может смочь вычислить Жорданову форму A. В этом случае возвращен FAIL.

Этот метод только существует, если R является областью категории Cat::Field.

Этот метод перегружает функциональный cos для матриц, т.е. можно использовать его в форме cos(A).

`diff` Дифференцирование матричных компонентов

diff(A, …)

Этот метод только существует, если R реализует метод "diff".

Этот метод перегружает системную функцию diff для матриц, т.е. можно использовать его в форме diff(A, ...). Смотрите Пример 8 и Пример 9.

`equal` — Тест равенства матриц

equal(A, B)

Обратите внимание на то, что, если R имеет аксиому Ax::systemRep затем, normal используется, чтобы упростить компоненты A и B прежде, чем протестировать их равенство.

`exp` Экспоненциал матрицы

exp(A, <t>)

Если A не является квадратным, сообщение об ошибке выпущено. Если область компонента A не позволяет вычисление exp(elem) для произвольного элемента elem звонка компонента, FAIL возвращен.

Этот метод использует функциональный numeric::expMatrix для приближения с плавающей точкой экспоненциала A, если A*t содержит по крайней мере одно число с плавающей запятой, и все записи могут быть преобразованы в числа с плавающей запятой.

Если некоторые собственные значения A не существуют в R или не могут быть вычислены, то FAIL возвращен.

В символьном случае называется функциональный linalg::jordanForm, который не может смочь вычислить Жорданову форму A. В этом случае возвращен FAIL.

Этот метод только существует, если R является областью категории Cat::Field.

Этот метод перегружает системную функцию exp для матриц, т.е. можно использовать его в форме exp(A, ...).

`расширение` Расширьте матричные компоненты

expand(A)

Этот метод только существует, если R реализует метод "expand", или если R имеет аксиому Ax::systemRep (в этом случае, системная функция, expand используется).

Этот метод перегружает системную функцию expand для матриц, т.е. можно использовать его в форме expand(A).

`фактор` Факторизация диагональной матрицы

factor(A)

Факторный s является GCD всех компонентов матричного A. Следовательно, этот метод только существует, если R имеет категорию Cat::GcdDomain.

Этот метод перегружает системную функцию factor для матриц, т.е. можно использовать его в форме factor(A).

`float` — Приближение с плавающей точкой матричных компонентов

float(A)

Этот метод только существует, если R реализует метод "float".

Примечание

Обычно приближения с плавающей точкой не являются элементами R! Например, Dom::Integer реализует такой метод, но приближение с плавающей точкой целого числа не может быть повторно преобразовано в целое число.

Этот метод проверяет, может ли получившаяся матрица быть преобразована в доменный тип A, только если testargs() возвращает TRUE (например, если вы вызываете этот метод от интерактивного уровня MuPAD).

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

`fourier` — Преобразование Фурье матричных компонентов

fourier(A, t, s)

Этот метод перегружает функциональный fourier для матриц.

`gaussElim` — Исключение Гаусса для матриц

gaussElim(A, <ColumnElimination>)

С опцией ColumnElimination матричный A уменьшается до нижней треугольной формы эшелона через элементарные операции столбца (без ColumnElimination, алгоритм Гаусса использует элементарные операции строки, чтобы получить форму высшего руководства). Следующее отношение содержит: transpose(gaussElim(A, ColumnElimination)[1]) = gaussElim(transpose(A))[1]. С ColumnElimination последняя запись возвращенного списка является набором характеристических индексов столбца A.

Для очень большого m ×n матрицы A с m намного больший n, устранение столбца быстрее, чем устранение строки.

Если матрица не является квадратной, т.е. детерминант A не задан, то третья запись возвращенного списка является значением FAIL.

Этот метод только существует, если кольцевой R компонента является интегральной областью, т.е. областью категории Cat::IntegralDomain.

Если R имеет метод "pivotSize", элемент центра самого маленького размера выбран на каждом вертящемся шаге, посредством чего pivotSize должен возвратить положительное целое число, представляющее “размер” элемента.

Если никакой такой метод не задан, Исключение Гаусса без стратегии центра применяется к A.

Если R имеет аксиому Ax::efficientOperation ("_invert") и является категории Cat::Field, обычное Исключение Гаусса используется. В противном случае устранение без частей выполняется на A.

Если R реализует метод "normal", это используется, чтобы упростить последующие вычисления процесса Исключения Гаусса.

Обратите внимание на то, что, если R не реализует метод, "normal", но элементы R представлен областями ядра, т.е. R имеет аксиому Ax::systemRep, системная функция, normal используется вместо этого.

`identity` — Единичная матрица

identity(n)

Этот метод только существует, если кольцевой R компонента имеет категорию Cat::Ring, т.е. звонок с модулем.

`int` — Интегрирование матричных компонентов

int(A, …)

Этот метод только существует, если R реализует метод "int".

Этот метод перегружает системную функцию int для матриц, т.е. можно использовать его в форме int(A, ...).

`ifourier` — Обратное преобразование Фурье матричных компонентов

ifourier(A, s, t)

Этот метод перегружает функциональный ifourier для матриц.

`ilaplace` — Обратное Преобразование Лапласа матричных компонентов

ilaplace(A, s, t)

Этот метод перегружает функциональный ilaplace для матриц.

`iszero` — Протестируйте на нулевые матрицы

iszero(A)

Обратите внимание на то, что там может существовать больше чем одно представление нулевой матрицы данной размерности, если R не имеет Ax::canonicalRep.

Если R реализует метод "normal", это используется, чтобы упростить компоненты A для нулевого теста.

Обратите внимание на то, что, если R не реализует такой метод, но элементы R представлены областями ядра, т.е. R имеет аксиому Ax::systemRep, системная функция, normal используется вместо этого.

Этот метод перегружает системную функцию iszero для матриц, т.е. можно использовать его в форме iszero(A).

`laplace` — Преобразование Лапласа матричных компонентов

laplace(A, t, s)

Этот метод перегружает функциональный laplace для матриц.

`matdim` — Матричная размерность

matdim(A)

`норма` Норма матриц и векторов

norm(A, Infinity)

norm(A, Maximum)

norm(v, Infinity)

norm(v, Maximum)

norm(A, Frobenius)

norm(A, 1)

norm(v, Euclidean)

norm(v, k)

norm(A, Maximum) вычисляет максимальную норму матричного A, который является максимальной суммой строки (сумма строки является суммой норм каждого компонента подряд).

Если доменный R не реализует методы "max" и "norm", FAIL возвращен.

Используя norm(v, Infinity) для векторного v возвращена максимальная норма всех элементов.

Если доменный R не реализует методы "max" и "norm", FAIL возвращен.

Используя norm(v, Maximum) для векторного v возвращена максимальная норма всех элементов.

Если доменный R не реализует методы "max" и "norm", FAIL возвращен.

norm(A, Frobenius) вычисляет норму Фробениуса A, который является квадратным корнем из суммы квадратов норм каждого компонента.

Если результатом больше не является элемент доменного R, или если R не реализует метод "norm", FAIL возвращен.

norm(A, 1) вычисляет 1 норму матричного A, который является максимальной суммой норм элементов каждого столбца. Если R не реализует методы "max" и "norm", FAIL возвращен.

norm(v, Euclidean) вычисляет Евклидову норму (2-норма) векторного v, который задан, чтобы быть квадратным корнем из суммы норм элементов v, повышенного до квадрата.

FAIL возвращен, если результатом больше не является элемент доменного R. Функциональный linalg::scalarProduct используется, чтобы вычислить Евклидову норму векторного v.

Если R не реализует метод "norm", FAIL возвращен.

norm(v, k) вычисляет k - норма векторного v, который задан, чтобы быть k th корень суммы норм элементов v, повышенного до k th степень.

FAIL возвращен, если результатом больше не является элемент доменного R. Для k = 2, функциональный linalg::scalarProduct используется, чтобы вычислить 2-норму v.

Если R не реализует метод "norm", FAIL возвращен.

Метод norm перегружает функциональный norm для матриц, т.е. можно использовать его в форме norm(A k ), где k является или Infinity, Frobenius или положительное целое число. Значением по умолчанию k является Infinity.

`normal` — Упрощение матричных компонентов

normal(A)

Если R не реализует метод, "normal", но элементы R представлен областями ядра, т.е. R имеет аксиому Ax::systemRep, системная функция, normal применяется к компонентам A. В противном случае normal(A) возвращает A без любых изменений.

Этот метод перегружает системную функцию normal для матриц, т.е. можно использовать его в форме normal(A).

`ненули` Количество ненулевых компонентов матрицы

nonZeros(A)

`nonZeroes` — Количество ненулевых компонентов матрицы

nonZeroes(A)

`nonZeroOperands` — Возвратите последовательность всех ненулевых операндов

nonZeroOperands(A)

Этот метод полезен для получения информации о ненулевых записях. Например, чтобы узнать типы записей в матрице, не нужно считать все операнды op(A), потому что это также включило бы нулевые записи. Для больших матриц с немногими записями намного более эффективно использовать этот метод, чтобы извлечь записи.

`random` — Случайная генерация матрицы

random()

random(g)

random(m, n)

random(m, n, g)

random(m, n, p)

random(m, n, p, g)

Размерность матрицы также выбрана случайным образом. Матричный размер ограничивается значениями "randomDimen" (см. “Записи” выше). Чтобы изменить значение записи "randomDimen", нужно сначала оставить без защиты доменный Dom (см. unprotect для деталей).

При вызове метода "random" с одним параметром g этот параметр рассматривается как случайный генератор. Матричные записи создаются вызовами g(), который должен возвратиться, элементы коэффициента звонят R.

Размерность матрицы выбрана случайным образом как выше.

При вызове метода "random" с двумя положительными целыми числами m и n, создается случайная матрица со строками m и столбцами n. Его элементы сгенерированы методом "random" кольцевого R компонента. Если R::random не существует, FAIL возвращен.

random(m,n,g) создает матрицу со строками m и столбцами n. Третий параметр g рассматривается как случайный генератор. Матричные записи создаются вызовами g(), который должен возвратиться, элементы коэффициента звонят R.

При вызове метода "random" с положительными целыми числами m, n и неотрицательный целочисленный p, разреженная матрица со строками m, создаются столбцы n и в большей части p ненулевые записи. Эти записи сгенерированы функциональным "random" кольцевого R компонента. Если R::random не существует, FAIL возвращен.

Целочисленный p должен удовлетворить 0 ≤ p ≤ m n.

При вызове метода "random" с четырьмя параметрами, разреженной матрицы со строками m, создаются столбцы n и в большей части p ненулевые записи. Четвертый параметр g рассматривается как случайный генератор. Матричные записи создаются вызовами g(), который должен возвратиться, элементы коэффициента звонят R.

Целочисленный p должен удовлетворить 0 ≤ p ≤ m n.

`sin` — Синус матрицы

sin(A)

Если A не является квадратным, сообщение об ошибке выпущено. Если область компонента A не позволяет вычисление sin(elem) для произвольного элемента elem звонка компонента, FAIL возвращен.

Если некоторые собственные значения A не существуют в R или не могут быть вычислены, то FAIL возвращен.

Этот метод только существует, если R является областью категории Cat::Field.

Этот метод перегружает функциональный sin для матриц, т.е. можно использовать его в форме sin(A).

`sqrt` Квадратный корень из матрицы

sqrt(A, <sqrtfunc>)

Возвращенный матричный B с B ² = A, таким образом, что собственные значения B являются квадратными корнями из собственных значений A или FAIL, если квадратный корень из матрицы не существует. Для вычисления квадратных корней из собственных значений функция, удовлетворяющая sqrtfunc (a) ² = a для каждого элемента, a содействующего звонка A может быть дан как дополнительный второй аргумент.

Для получения дополнительной информации мы обращаемся к странице справки функционального linalg::sqrtMatrix.

`testeq` — Тестирование на равенство двух матриц

testeq(A, B)

`tr` — Трассировка квадратной матрицы

tr(A)

Если A не является квадратным, сообщение об ошибке выпущено.

`перемещение` Транспонируйте матрицы

transpose(A)

Методы доступа

`_concat` — Горизонтальная конкатенация матриц

_concat(A, B, …)

Этот метод перегружает системную функцию _concat для матриц, т.е. можно использовать его в форме A . B . ..., или в функциональном обозначении: _concat(A, B, ...).

`_index` — Индексирование матриц

_index(A, i, j)

_index(A, r1 .. r2, c1 .. c2)

_index(v, i)

_index(v, i1 .. i2)

Если i и j не являются целыми числами, вызов этого метода возвращается в его символьной форме (типа "_index") с оцененными аргументами.

В противном случае сообщение об ошибке дано, если i и j не являются допустимыми индексами строки и столбца, соответственно.

Примечание

Обратите внимание на то, что этот метод использует системную функцию context, чтобы оценить запись в контексте среды вызова.

_index(A,r1..r2,c1..c2) возвращает субматрицу A, созданного строками A с индексами от r1 до r2 и столбцов A с индексами от c1 до c2.

Этот метод возвращает i th запись векторного v.

Сообщение об ошибке выпущено, если v не является вектором.

Если i не является целым числом, вызов _index(v,i) возвращается в его символьной форме (типа "_index") с оцененными аргументами.

В противном случае сообщение об ошибке дано, если i - меньше чем один или больше, чем размерность v.

Примечание

_index(v,i1..i2) возвращает подвектор v, сформированного записями с индексом i1 к i2. См. также метод "op".

Сообщение об ошибке выпущено, если v не является вектором.

_index перегружает системную функцию _index для матриц, т.е. можно использовать его в форме A[i, j], A[r1..r2, c1..c2], v[i] и v[i1..i2], соответственно, или в функциональном обозначении: _index(A, ...).

`addCol` — Сложение кратного одному столбцу к кратному другой столбец

addCol(A, i, j, f, <g>)

i и j должны быть положительными целыми числами, меньшими, чем или равный количеству столбцов матричного A.

Если f и g не являются элементами содействующей области R матричного A и не могут быть преобразованы в R, FAIL возвращен.

`addRow` — Сложение кратного одной строке к кратному другая строка

addRow(A, i, j, f, g)

i и j должны быть положительными целыми числами, меньшими, чем или равный количеству строк матричного A.

`concatMatrix` — Горизонтальная конкатенация матриц

concatMatrix(A, B, …)

`col` — Извлечение столбца матрицы

col(A, c)

Сообщение об ошибке выпущено, если c - меньше чем один или больше, чем количество столбцов A.

`delCol` — Удаление столбца матрицы

delCol(A, c)

NIL возвращен, если A состоит только из одного столбца.

Сообщение об ошибке выпущено, если c - меньше чем один или больше, чем количество столбцов A.

`delRow` — Удаление строки матрицы

delRow(A, r)

NIL возвращен, если A состоит только из одной строки.

Сообщение об ошибке выпущено, если r - меньше чем один или больше, чем количество строк A.

`evalp` — Оценка матриц полиномов в определенный момент

evalp(A, x = a, …)

Этот метод только задан, если R является полиномиальным звонком категории Cat::Polynomial.

Этот метод перегружает системную функцию evalp для матриц, т.е. можно использовать его в форме evalp(A, x = a).

`длина` Длина матрицы

length(A)

Этот метод перегружает системную функцию length для матриц, т.е. можно использовать его в форме length(A).

`map` — Примените функцию к матричным компонентам

map(A, f, <p1, p2, …>)

Примечание

Обратите внимание на то, что значения, возвращенные f, преобразованы в элементы доменного R, только если testargs() возвращает TRUE (т.е. если вы вызываете этот метод от интерактивного уровня MuPAD).

Если testargs() возвратит FALSE, нужно гарантировать, что f возвращает элементы доменного типа R. В противном случае получившаяся матрица будет иметь компоненты, которые не являются элементами кольцевого R компонента!

Примечание

Если функциональный f не сопоставит нулевой элемент звонка компонента к нулевому элементу, разреженная матрица изменится в плотную матрицу. Это может привести к проблемам памяти при контакте с очень большими (разреженными) матрицами.

Обратите внимание на то, что существует метод "mapNonZeroes", который сопоставляет функцию с ненулевыми записями матрицы только.

Этот метод перегружает системную функцию map для матриц, т.е. можно использовать его в форме map(A, f p1 , p2 , , …).

`mapNonZeroes` — Примените функцию к ненулевым компонентам (разреженной) матрицы

mapNonZeroes(A, f, <p1, p2, …>)

`multCol` — Умножение одного столбца скалярным фактором

multCol(A, i, f)

i должен быть положительным целым числом, меньшим, чем или равный количеству столбцов матричного A.

Если f не является элементом содействующей области R матричного A и не может быть преобразован в R, FAIL возвращен.

`multRow` — Умножение одной строки скалярным фактором

multRow(A, i, f)

i должен быть положительным целым числом, меньшим, чем или равный количеству строк матричного A.

`nops` — Количество компонентов матрицы

nops(A)

Этот метод перегружает системную функцию nops для матриц, т.е. можно использовать его в форме nops(A).

`op` Компонент матрицы

op(A, i)

op(A)

Этот метод возвращает последовательность выражения всех компонентов A.

См. также метод "_index".

Этот метод перегружает системную функцию op для матриц, т.е. можно использовать его в форме op(A, i) и op(A), соответственно.

`row` — Извлечение строки из матрицы

row(A, r)

Сообщение об ошибке выпущено, если r - меньше чем один или больше, чем количество строк A.

`setCol` — Заменяя столбец матрицы

setCol(A, c, v)

Сообщение об ошибке выпущено, если c - меньше чем один или больше, чем количество строк A.

`setRow` — Заменяя строку матрицы

setRow(A, r, v)

Сообщение об ошибке выпущено, если r - меньше чем один или больше, чем количество строк A.

`stackMatrix` — Вертикальная конкатенация матриц

stackMatrix(A, B, …)

Сообщение об ошибке выпущено, если данные матрицы не имеют одинакового числа столбцов.

`subs` — Замена матричных компонентов

subs(A, …)

Примечание

Обратите внимание на то, что значения функции преобразованы в элементы доменного R, только если testargs() возвращает TRUE (например, если вы вызываете этот метод от интерактивного уровня MuPAD).

Если testargs() возвратит FALSE, нужно гарантировать, что f возвращает элементы доменного типа R. В противном случае получившаяся матрица, которая имеет доменный тип Dom::Matrix(R), имела бы компоненты, которые не являются элементами доменного R!

Этот метод перегружает системную функцию subs для матриц, т.е. можно использовать его в форме subs(A, ...).

`subsex` — Расширенная замена матричных компонентов

subsex(A, …)

Примечание

Обратите внимание на то, что результаты замен преобразованы в элементы доменного R, только если testargs() возвращает TRUE (например, если вы вызываете этот метод от интерактивного уровня MuPAD).

Если testargs() возвратит FALSE, нужно гарантировать, что результаты замен имеют доменный тип R, в противном случае получившаяся матрица, которая имеет доменный тип Dom::Matrix(R), имела бы компоненты, которые не являются элементами доменного R!

Этот метод перегружает системную функцию subsex для матриц, т.е. можно использовать его в форме subsex(A, ...).

`subsop` — Замена операнда матричных компонентов

subsop(A, i = x, …)

Примечание

Обратите внимание на то, что x преобразован в доменный R, только если testargs() возвращает TRUE (например, если вы вызываете этот метод от интерактивного уровня MuPAD).

Если testargs() возвращает FALSE, x должен быть элементом R, в противном случае получившаяся матрица, которая имеет доменный тип Dom::Matrix(R), имела бы компоненты, которые не являются элементами доменного R!

См. также метод "set_index".

Этот метод перегружает системную функцию subsop для матриц, т.е. можно использовать его в форме subsop(A, ...).

`swapCol` — Свопинг столбцов матрицы

swapCol(A, c1, c2)

swapCol(A, c1, c2, r1 .. r2)

Сообщение об ошибке выпущено, если один из индексов столбца - меньше чем один или больше, чем количество столбцов A.

swapCol(A,c1,c2,r1..r2) подкачивает столбец с индексом c1 и столбец с индексом c2 A, но путем взятия только тех компонентов столбца, которые лежат в строках с индексами r1 к r2.

Сообщение об ошибке выпущено, если один из индексов столбца - меньше чем один или больше, чем количество столбцов A, или если один из индексов строки - меньше чем один или больше, чем количество строк A.

`swapRow` — Свопинг строк матрицы

swapRow(A, r1, r2)

swapRow(A, r1, r2, c1 .. c2)

Сообщение об ошибке выпущено, если один из индексов строки - меньше чем один или больше, чем количество строк A.

swapCol(A,r1,r2,c1..c2) подкачивает строку с индексом r1 и строка с индексом r2 A, но путем взятия только тех компонентов строки, которые лежат в столбцах с индексами c1 к c2.

Сообщение об ошибке выпущено, если один из индексов строки - меньше чем один или больше, чем количество строк A, или если один из индексов столбца - меньше чем один или больше, чем количество столбцов A.

`set_index` — Установка матричных компонентов

set_index(A, i, j, x)

set_index(v, i, x)

Примечание

Обратите внимание на то, что x преобразован в элемент доменного R, только если testargs возвращает TRUE, и i и j являются целыми числами (например, если вы вызываете этот метод от интерактивного уровня MuPAD). Если x является матрицей того же типа как A или может быть преобразован в матрицу того же типа как A и индексы, i или j являются областями значений, соответствующими субматрице A, то x заменяет соответствующую субматрицу в A.

В противном случае нужно заботиться, что x имеет доменный тип R.

См. также метод "subsop".

set_index(v,i,x) заменяет i th запись векторного v x.

set_index на векторах перегружает функциональный set_index для матриц, т.е. можно использовать его в форме A[i, j] := x и v[i] := x, соответственно, или в функциональном обозначении: A := set_index(A, i, j, x) или v := set_index(v, i, x).

`zip` Объедините матрицы покомпонентно

zip(A, B, f, <p1, p2, …>)

Номер строки возвращенной матрицы является минимумом номеров строк A и B. Его номер столбца является минимумом номеров столбцов A и B.

Примечание

Этот метод перегружает системную функцию zip для матриц, т.е. можно использовать его в форме zip(A, B, f p1 , p2 , , …).

Методы преобразования

`\convert` Преобразование в матрицу

convert(x)

FAIL возвращен, если преобразование перестало работать.

x может или быть массивом, матрицей или списком (подсписков, смотрите параметр ListOfRows в “Создании Элементов” выше). Их записи должны затем быть конвертируемы в элементы доменного R.

`convert_to` — Матричное преобразование

convert_to(A, T)

T может или быть DOM_ARRAY, DOM_LIST или область, созданная Dom::Matrix или Dom::SquareMatrix. Элементы A должны быть конвертируемы в элементы доменного R.

Используйте функциональный expr, чтобы преобразовать A в объект области ядра (см. ниже).

`create` — Определение матриц без преобразований компонента

create(x, …)

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

`expr)` Преобразование матрицы к объекту области ядра

expr(A)

Результатом является массив, представляющий матричный A, где каждая запись является объектом области ядра.

Этот метод перегружает системную функцию expr для матриц, т.е. можно использовать его в форме expr(A).

`expr2text` — Преобразование mtrix к строке

expr2text(A)

Этот метод перегружает системную функцию expr2text для матриц, т.е. можно использовать его в форме expr2text(A).

Технические методы

`assignElements` — Несколько присвоение на матрицы

assignElements(A, …)

Присвоенные компоненты должны иметь доменный тип R, неявное преобразование компонентов в элементы доменного типа, R не выполняется.

Этот метод перегружает системную функцию assignElements для матриц, т.е. можно использовать его в форме assignElements(A, ...).

`mkSparse` — Преобразование массива или список списков к разреженной структуре

mkSparse(Array)

mkSparse(List)

mkSparse(r, c, List)

'Разреженная структура' s является списком c одномерные полиномы, который используется, чтобы сохранить нетривиальные элементы столбцов матриц.

mkSparse(List) пытается преобразовать список List в разреженная структура. Результатом является или FAIL, если это не возможно, или список [s, [r, c]], где положительные целые числа r и c являются размерностью соответствующей матрицы. 'Разреженная структура' s является списком одномерных полиномов, который используется, чтобы сохранить нетривиальные элементы столбцов матриц.

Смотрите параметры List и ListOfRows в “Создании Элементов” выше для допустимых форматов List.

Матрица рассматривается как столбец или вектор - строка, если r или c равны одному. T

mkSparse(r,c,List) пытается преобразовать список List в разреженную структуру, представляющую матрицу размерности времена r c.

Результатом является или FAIL, если это не возможно, или список [s, [r, c]]. 'Разреженная структура' s является списком одномерных полиномов, который используется, чтобы сохранить нетривиальные элементы столбцов матриц.

Матрица рассматривается как столбец или вектор - строка, если r или c равны одному. T

`печать` Печать матриц

print(A)

Примечание

Обратите внимание на то, что не будет полезно распечатать очень большие разреженные матрицы с большим количеством нулевых коэффициентов таким образом – печать таких матриц может быть сделана при помощи функционального "doprint".

Используйте матричный слот "setPrintMaxSize", чтобы установить максимальный размер матриц, которые будут распечатаны как “плотные” массивы с нулевыми записями, отображенными как целое число 0.

`doprint` — Печать больших разреженных матриц

doprint(A)

`setPrintMaxSize` — Установите максимальный размер матриц, которые будут распечатаны как “плотные” массивы

setPrintMaxSize(printMaxSize)

Значением параметра printMaxSize может также быть infinity. В этом случае матрицы произвольного размера распечатаны как “плотные” массивы.

Этот метод возвращает предыдущее значение printMaxSize.

Значением по умолчанию является printMaxSize = 500.

`unapply` — Создайте процедуру из матрицы

unapply(A, <x, …>)

Этот метод перегружает системную функцию fp::unapply для матриц, т.е. можно использовать его в форме fp::unapply(A).

Смотрите также

Области MuPAD

Dom::DenseMatrix | Dom::DenseMatrix | Dom::MatrixGroup | Dom::SquareMatrix

Функции MuPAD

densematrix | matrix

Документация

Dom:: Matrix

Синтаксис

Доменное создание

Создание элемента

Описание

Доменное создание

Примечание

Примечание

Создание элемента

Суперобласть

Аксиомы

Категории

Примеры

Пример 1

Пример 2

Пример 3

Пример 4

Пример 5

Пример 6

Пример 7

Пример 8

Пример 9

Пример 10

Пример 11

Параметры

Опции

Записи

Методы

Математические методы

_divide — Разделите матрицы

_invert — Вычислите инверсию матрицы

mod Сопоставьте оператор по модулю с элементами матрицы

_mult — Матрицы мультиплие матрицами, векторами и скалярами

_negate — Инвертируйте матрицу

плюс Добавьте матрицы

_power — Целочисленная степень матрицы

conjugate — Сопряженное комплексное число матрицы

потому что Косинус матрицы

diff Дифференцирование матричных компонентов

equal — Тест равенства матриц

exp Экспоненциал матрицы

расширение Расширьте матричные компоненты

фактор Факторизация диагональной матрицы

float — Приближение с плавающей точкой матричных компонентов

Примечание

fourier — Преобразование Фурье матричных компонентов

gaussElim — Исключение Гаусса для матриц

identity — Единичная матрица

int — Интегрирование матричных компонентов

ifourier — Обратное преобразование Фурье матричных компонентов

ilaplace — Обратное Преобразование Лапласа матричных компонентов

iszero — Протестируйте на нулевые матрицы

laplace — Преобразование Лапласа матричных компонентов

matdim — Матричная размерность

норма Норма матриц и векторов

normal — Упрощение матричных компонентов

ненули Количество ненулевых компонентов матрицы

nonZeroes — Количество ненулевых компонентов матрицы

nonZeroOperands — Возвратите последовательность всех ненулевых операндов

random — Случайная генерация матрицы

sin — Синус матрицы

sqrt Квадратный корень из матрицы

testeq — Тестирование на равенство двух матриц

tr — Трассировка квадратной матрицы

перемещение Транспонируйте матрицы

Методы доступа

_concat — Горизонтальная конкатенация матриц

_index — Индексирование матриц

Примечание

Примечание

addCol — Сложение кратного одному столбцу к кратному другой столбец

addRow — Сложение кратного одной строке к кратному другая строка

concatMatrix — Горизонтальная конкатенация матриц

col — Извлечение столбца матрицы

delCol — Удаление столбца матрицы

delRow — Удаление строки матрицы

evalp — Оценка матриц полиномов в определенный момент

длина Длина матрицы

map — Примените функцию к матричным компонентам

`Dom`:: `Matrix`

`_divide` — Разделите матрицы

`_invert` — Вычислите инверсию матрицы

`mod` Сопоставьте оператор по модулю с элементами матрицы

`_mult` — Матрицы мультиплие матрицами, векторами и скалярами

`_negate` — Инвертируйте матрицу

`плюс` Добавьте матрицы

`_power` — Целочисленная степень матрицы

`conjugate` — Сопряженное комплексное число матрицы

`потому что` Косинус матрицы

`diff` Дифференцирование матричных компонентов

`equal` — Тест равенства матриц

`exp` Экспоненциал матрицы

`расширение` Расширьте матричные компоненты

`фактор` Факторизация диагональной матрицы

`float` — Приближение с плавающей точкой матричных компонентов

`fourier` — Преобразование Фурье матричных компонентов

`gaussElim` — Исключение Гаусса для матриц

`identity` — Единичная матрица

`int` — Интегрирование матричных компонентов

`ifourier` — Обратное преобразование Фурье матричных компонентов

`ilaplace` — Обратное Преобразование Лапласа матричных компонентов

`iszero` — Протестируйте на нулевые матрицы

`laplace` — Преобразование Лапласа матричных компонентов

`matdim` — Матричная размерность

`норма` Норма матриц и векторов

`normal` — Упрощение матричных компонентов

`ненули` Количество ненулевых компонентов матрицы

`nonZeroes` — Количество ненулевых компонентов матрицы

`nonZeroOperands` — Возвратите последовательность всех ненулевых операндов

`random` — Случайная генерация матрицы

`sin` — Синус матрицы

`sqrt` Квадратный корень из матрицы

`testeq` — Тестирование на равенство двух матриц

`tr` — Трассировка квадратной матрицы

`перемещение` Транспонируйте матрицы

`_concat` — Горизонтальная конкатенация матриц

`_index` — Индексирование матриц

`addCol` — Сложение кратного одному столбцу к кратному другой столбец

`addRow` — Сложение кратного одной строке к кратному другая строка

`concatMatrix` — Горизонтальная конкатенация матриц

`col` — Извлечение столбца матрицы

`delCol` — Удаление столбца матрицы

`delRow` — Удаление строки матрицы

`evalp` — Оценка матриц полиномов в определенный момент

`длина` Длина матрицы

`map` — Примените функцию к матричным компонентам

`mapNonZeroes` — Примените функцию к ненулевым компонентам (разреженной) матрицы

`multCol` — Умножение одного столбца скалярным фактором

`multRow` — Умножение одной строки скалярным фактором

`nops` — Количество компонентов матрицы

`op` Компонент матрицы

`row` — Извлечение строки из матрицы

`setCol` — Заменяя столбец матрицы

`setRow` — Заменяя строку матрицы

`stackMatrix` — Вертикальная конкатенация матриц

`subs` — Замена матричных компонентов

`subsex` — Расширенная замена матричных компонентов

`subsop` — Замена операнда матричных компонентов

`swapCol` — Свопинг столбцов матрицы

`swapRow` — Свопинг строк матрицы

`set_index` — Установка матричных компонентов

`zip` Объедините матрицы покомпонентно

`\convert` Преобразование в матрицу

`convert_to` — Матричное преобразование

`create` — Определение матриц без преобразований компонента

`expr)` Преобразование матрицы к объекту области ядра

`expr2text` — Преобразование mtrix к строке

`assignElements` — Несколько присвоение на матрицы

`mkSparse` — Преобразование массива или список списков к разреженной структуре

`печать` Печать матриц

`doprint` — Печать больших разреженных матриц

`setPrintMaxSize` — Установите максимальный размер матриц, которые будут распечатаны как “плотные” массивы

`unapply` — Создайте процедуру из матрицы