Contents

Dom::MatrixGroup

The Abelian group of matrices

Syntax

Domain Creation

Dom::MatrixGroup(m, n, <R>)

Element Creation

Dom::MatrixGroup(m, n, R)(Array)
Dom::MatrixGroup(m, n, R)(Matrix)
Dom::MatrixGroup(m, n, R)(<m, n>)
Dom::MatrixGroup(m, n, R)(<m, n>, List)
Dom::MatrixGroup(m, n, R)(<m, n>, ListOfRows)
Dom::MatrixGroup(m, n, R)(<m, n>, f)
Dom::MatrixGroup(m, n, R)(<m, n>, List, <Diagonal>)
Dom::MatrixGroup(m, n, R)(<m, n>, g, <Diagonal>)
Dom::MatrixGroup(m, n, R)(<m, n>, List, <Banded>)

Description

Domain Creation

Dom::MatrixGroup(m, n, R) creates a domain which represents the Abelian group of m×n matrices over the component ring R, i.e., it is a domain of category Cat::AbelianGroup.

The domain Dom::ExpressionField() is used as the component ring for the matrices if the optional parameter R is not given.

For matrices of a domain created by Dom::MatrixGroup(m, n, R), matrix arithmetic is implemented by overloading the standard arithmetical operators +, -, *, / and ^. All functions of the linalg package dealing with matrices can be applied.

Dom::MatrixGroup(m, n, R) has the domain Dom::Matrix(R) as its super domain, i.e., it inherits each method which is defined by Dom::Matrix(R) and not re-implemented by Dom::MatrixGroup(m, n, R).

Methods described below are implemented by Dom::MatrixGroup.

The domain Dom::Matrix(R) represents matrices over R of arbitrary size, and it therefore does not have any algebraic structure (except of being a set of matrices).

The domain Dom::SquareMatrix(n, R) represents the ring of n×n matrices over R.

Element Creation

Dom::MatrixGroup(m, n, R)(Array) and Dom::MatrixGroup(m, n, R)(Matrix) create a new matrix formed by the entries of Array and Matrix, respectively.

The components of Array and Matrix, respectively, are converted into elements of the domain R. An error message is issued if one of these conversions fails.

The call Dom::MatrixGroup(m, n, R)( m , n ) returns the m×n zero matrix. Note that the m×n zero matrix can also be found in the entry "zero" (see below).

Dom::MatrixGroup(m, n, R)( m , n List) creates an m×n matrix with components taken from the list List.

This call is only allowed for m×1 or 1 ×n matrices, i.e., if either m or n is equal to one.

If the list has too few entries, the remaining components of the matrix are set to zero.

The entries of the list are converted into elements of the domain R. An error message is issued if one of these conversions fails.

Dom::MatrixGroup(m, n, R)( m , n ListOfRows) creates an m×n matrix with components taken from the nested list ListOfRows. Each inner list corresponds to a row of the matrix.

If an inner list has less than n entries, the remaining components in the corresponding row of the matrix are set to zero. If there are less than m inner lists, the remaining lower rows of the matrix are filled with zeroes.

The entries of the inner lists are coerced into elements of the domain R. An error message is issued if one of these conversions fails.

It might be a good idea first to create a two-dimensional array from that list before calling Dom::MatrixGroup(m, n, R). This is due to the fact that creating a matrix from an array is the fastest way one can achieve. However, in this case the sublists must have the same number of elements.

Dom::MatrixGroup(m, n, R)( m , n f) returns the matrix whose (i, j)th component is the value of the function call f(i, j). The row index i ranges from 1 to m and the column index j from 1 to n.

The function values are coerced into elements of the domain R. An error message is issued if one of these conversions fails.

Superdomain

Dom::Matrix(R)

Axioms

If R has Ax::canonicalRep, then Ax::canonicalRep.

Examples

Example 1

A lot of examples can be found on the help page of the domain constructor Dom::Matrix, and most of them are also examples for working with domains created by Dom::MatrixGroup. This example only highlights some differences with respect to working with matrices of the domain Dom::Matrix(R).

The following command defines the abelian group of 3 ×4 matrices over the rationals:

MatGQ := Dom::MatrixGroup(3, 4, Dom::Rational)

MatGQ::hasProp(Cat::AbelianGroup), MatGQ::hasProp(Cat::Ring)

MatGQ is a commutative group with respect to the addition of matrices. The unit of this group is the 3 ×4 zero matrix:

MatGQ::zero

Note that some operations defined by the domain MatGQ return matrices which are no longer elements of the matrix group. They return matrices of the domain Dom::Matrix(Dom::Rational), the super-domain of MatGQ.

For example, if we define the matrix:

A := MatGQ([[1, 2, 1, 2], [-5, 3], [2, 1/3, 0, 1]])

and delete its third column, we get the matrix:

MatGQ::delCol(A, 3)

which is of the domain type:

domtype(%)

As another example we create the 3×3 identity matrix using the method "identity" of our domain:

E3 := MatGQ::identity(3)

This is also a matrix of the domain Dom::Matrix(Dom::Rational):

domtype(E3)

If we concatenate E3 to the right of the matrix A defined above, we get the 3 ×7 matrix:

B := A . E3

which is of the domain type Dom::Matrix(Dom::Rational):

domtype(B)

Example 2

We can convert a matrix from a domain created with Dom::MatrixGroup into or from another matrix domain, as shown next:

MatGR := Dom::MatrixGroup(2, 3, Dom::Real):
MatC := Dom::Matrix(Dom::Complex):
A := MatGR((i, j) -> i*j)

To convert A into a matrix of the domain MatC, enter:

coerce(A, MatC)

domtype(%)

The conversion is done component-wise. For example, we define the following matrix:

B := MatC([[0, 1, 0], [exp(I), 0, 1]])

The matrix B has one complex component and therefore cannot be converted into the domain MatGR:

coerce(B, MatGR)

Note: The system function coerce uses the methods "convert" and "convert_to" implemented by any domain created with Dom::MatrixGroup and Dom::Matrix.

Parameters

m, n

Positive integers (matrix dimension)

R

A commutative ring, i.e., a domain of category Cat::CommutativeRing; the default is Dom::ExpressionField()

Array

An m×n array

Matrix

An m×n matrix, i.e., an element of a domain of category Cat::Matrix

List

A list of matrix components

ListOfRows

A list of at most m rows; each row is a list of at most n matrix components

f

A function or a functional expression with two parameters (the row and column index)

g

A function or a functional expression with one parameter (the row index)

Options

Diagonal

Create a diagonal matrix

With the option Diagonal, diagonal matrices can be created with diagonal elements taken from a list, or computed by a function.

Dom::MatrixGroup(m, n, R)( m , n List, Diagonal) creates the m×n diagonal matrix whose diagonal elements are the entries of List.

List must have at most min(m, n) entries. If it has fewer elements, then the remaining diagonal elements are set to zero.

The entries of List are coerced into elements of the domain R. An error message is issued if one of these conversions fails.

Dom::MatrixGroup(m, n, R)( m , n g, Diagonal) returns the matrix whose ith diagonal element is g(i, i), where the index i runs from 1 to min(m, n).

The function values are coerced into elements of the domain R. An error message is issued if one of these conversions fails.

Banded

Create a banded Toeplitz matrix

With the option Banded, banded matrices can be created.

A banded matrix has all entries zero outside the main diagonal and some of the adjacent sub- and superdiagonals.

Dom::MatrixGroup(m, n, R)( m , n List, Banded) creates an m×n banded Toeplitz matrix with the elements of List as entries. The number of entries of List must be odd, say 2 h + 1, and must not exceed n. The resulting matrix has bandwidth at most 2 h + 1.

All elements of the main diagonal of the created matrix are initialized with the middle element of List. All elements of the ith subdiagonal are initialized with the (h + 1 - i)th element of List. All elements of the ith superdiagonal are initialized with the (h + 1 + i)th element of List. All entries on the remaining sub- and superdiagonals are set to zero.

The entries of List are converted into elements of the domain R. An error message is issued if one of these conversions fails.

Entries

"one"

is only defined if m is equal to n; in that case it defines the n×n identity matrix.

"randomDimen"

is set to [m, n].

"zero"

is the m×n zero matrix.

Methods

expand all

Mathematical Methods

evalp — Evaluating matrices of polynomials at a certain point

evalp(A, x = a, …)

This method is only defined if R is a polynomial ring of category Cat::Polynomial.

This method overloads the function evalp for matrices, i.e., one may use it in the form evalp(A, x = a).

identity — Identity matrix

identity(k)

    Note:   The matrix returned is of the domain Dom::Matrix(R), if or if .

random — Random matrix generation

random()

The components of the random matrix are randomly generated with the method "random" of the component ring R.

Access Methods

_concat — Horizontally concatenation of matrices

_concat(A, B, …)

An error message is issued if the given matrices do not have the same number of rows.

    Note:   The returned matrix is of the domain Dom::Matrix(R).

This method overloads the function _concat for matrices, i.e., one may use it in the form A . B . ..., or in functional notation: _concat(A, B, ...).

_index — Matrix indexing

_index(A, i, j)

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

_index(A, i)

_index(A, i1 .. i2)

If i and j are not integers, then the call of this method returns in its symbolic form (of type "_index") with evaluated arguments.

Otherwise an error message is given, if i and j are not valid row and column indices, respectively.

    Note:   Note that the system function context is used to evaluate the entry in the context of the calling environment.

This method overloads the function _index for matrices, i.e., one may use it in the form A[i, j] or in functional notation: _index(A, i, j).

Returns the submatrix of A, created by the rows of A with indices from r1 to r2 and the columns of A with indices from c1 to c2.

    Note:   The submatrix is of the domain Dom::Matrix(R).

This method returns the ith entry of A.

If i is not an integer, then the call of this method returns in its symbolic form (of type "_index") with evaluated arguments.

Otherwise an error message is given, if i is less than one or greater than the dimension of v.

This call is only allowed for 1×n or m×1 matrices, i.e., either m or n must be equal to one. Otherwise an error message is issued.

    Note:   Note that the system function context is used to evaluate the entry in the context of the calling environment.

This method returns the subvector of A, formed by the entries with index i1 to i2 (see also the method "op").

This call is only allowed for 1×n or m×1 matrices, i.e., either m or n must be equal to one. Otherwise an error message is issued.

This method overloads the function _index for matrices, i.e., one may use it in the form A[i,j], A[r1..r2,c1..c2], A[i] or A[i1..i2], respectively, or in functional notation: _index(A, ...).

col — Extracting a column

col(A, c)

An error message is issued if c is less than one or greater than n.

delCol — Deleting a column

delCol(A, c)

NIL is returned if A only consists of one column.

    Note:   The returned matrix is of the domain Dom::Matrix(R).

An error message is issued if c is less than one or greater than n.

delRow — Deleting a row

delRow(A, r)

NIL is returned if A only consists of one row.

    Note:   The returned matrix is of the domain Dom::Matrix(R).

An error message is issued if r is less than one or greater than m.

row — Extracting a row

row(A, r)

An error message is issued if r is less than one or greater than m.

stackMatrix — Concatenating of matrices vertically

stackMatrix(A, B, …)

An error message is issued if the given matrices do not have the same number of columns.

    Note:   The matrix returned is of the domain Dom::Matrix(R).

Conversion Methods

convert — Conversion into a matrix

convert(x)

FAIL is returned if the conversion fails.

x may either be an m×n array, or an m×n matrix of category Cat::Matrix.

x can also be a list. See the parameter List and ListOfRows in "Creating Elements" above for admissible values of x.

The entries of x must be convertable into elements of the domain R, otherwise FAIL is returned.

See Also

MuPAD Domains

Was this topic helpful?