Dom::MatrixGroup
-- the
Abelian group of m x n matricesDom::MatrixGroup
(m, n, R)
creates the
Abelian group of m x n matrices over the component ring
R.
Dom::MatrixGroup(m, n <, R>)
m, n |
- | positive integers (matrix dimension) |
R |
- | a commutative ring, i.e., a domain of category
Cat::CommutativeRing ; default
is Dom::ExpressionField() |
Dom::MatrixGroup
(m, n, R)
creates a
domain which represents the Abelian group of m x n matrices
over the component ring R
, i.e., it is a domain of
category Cat::AbelianGroup
.Dom::ExpressionField()
is used
as the component ring for the matrices if the optional parameter
R
is not given.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
.
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 x n matrices over R.
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)
Array |
- | an m xn array |
Matrix |
- | an m xn 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) |
Diagonal |
- | create a diagonal matrix |
Banded |
- | create a banded Toeplitz matrix |
Cat::Matrix(R)
Dom::Matrix
, Dom::SquareMatrix
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.
Dom::MatrixGroup
(m, n, R)( <m,
n>)
returns the m x n zero matrix. Note that the
m x n zero matrix can also be found in the entry
"zero"
(see below).Dom::MatrixGroup
(m, n, R)( <m, n,
>List)
creates an m x n matrix with components
taken from the list List
.
This call is only allowed for m x 1 or 1 x 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 x 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.
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.
Dom::MatrixGroup
(m, n, R)( <m, n, >List,
Diagonal)
creates the m x 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)
, where the index
i runs from 1 to min(n,m).
The function values are coerced into elements of the domain
R
. An error message is issued if one of these conversions
fails.
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 x n banded
Toeplitz matrix with the elements of List
as entries. The
number of entries of List
must be odd, say
2h+1, and must not exceed n
. The resulting
matrix has bandwidth at most 2h+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.
is only defined if m
is equal to n
; in
that case it defines the n x n identity matrix.
is set to [m, n]
.
is the m x n zero matrix.
evalp(dom A, equation
x = a...)
A
at the point x = a
. See the system function evalp
for details.
The matrix returned is of the domain
Dom::MatrixGroup
(m, n, R::coeffRing)
, if the
evaluation of each component leads to an element of the coefficient
ring of the polynomial domain. Otherwise the matrix returned is of the
domain of A
.
R
is a polynomial ring
of category Cat::Polynomial
.evalp
for matrices,
i.e., one may use it in the form evalp(A, x = a)
.identity(positive integer k)
The matrix returned is of the domain Dom::Matrix(R)
, if
m
<>n
or if
k
<>n
.
matdim(dom A)
[m, n]
, i.e., the matrix
dimension of A
.random()
"random"
of the component ring R
._concat(dom A, dom
B...)
B
... to the right
side of the matrix A
.The returned matrix is of the domain Dom::Matrix(R)
.
_concat
for matrices, i.e., one may
use it in the form A . B . ...
, or in functional notation:
_concat(A, B, ...)
._index(dom A, row
index i, column index j)
A
._index
for matrices, i.e., one may
use it in the form A[i, j]
or in functional notation:
_index(A, i, j)
._index(dom A, row-range r1..r2, column-range
c1..c2)
A
, created by the rows of
A
with indices from r1
to r2
and
the columns of A
with indices from c1
to
c2
.The submatrix is of the domain Dom::Matrix(R)
.
_index(dom A, index
i)
A
.m
or n
must be equal
to one. Otherwise an error message is issued._index(dom A, index-range i1..i2)
A
, formed by the
entries with index i1
to i2
(see also the
method "op"
).m
or n
must be equal
to one. Otherwise an error message is issued._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...)
.concatMatrix(dom A, dom B...)
"_concat"
.col(dom A, column
index c)
c
of the
matrix A
and returns it as a column vector, i.e., as an
element of the domain Dom::Matrix(R)
.c
is less than one or
greater than n
.delCol(dom A, column
index c)
c
of the matrix A
.NIL
is returned if A
only consists of one
column.The returned matrix is of the domain Dom::Matrix(R)
.
c
is less than one or
greater than n
.delRow(dom A, row
index r)
r
of the matrix A
.NIL
is returned if A
only consists of one
row.The returned matrix is of the domain Dom::Matrix(R)
.
r
is less than one or
greater than m
.row(dom A, row index
r)
r
of the
matrix A
and returns it as a row vector, i.e., as an
element of domain Dom::Matrix(R)
.r
is less than one or
greater than m
.stackMatrix(dom A, dom B...)
A
on the top of the
matrix B
. If further arguments are given, then the result
is stacked on the top of the third matrix, and so on.The matrix returned is of the domain Dom::Matrix(R)
.
convert(any x)
x
into a matrix of type
Dom::MatrixGroup
(m, n, R)
.FAIL
is returned if the conversion fails.x
may either be an
m
xn
array, or an
m
xn
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.
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 x 4 matrices over the rationals:
>> MatGQ := Dom::MatrixGroup(3, 4, Dom::Rational)
Dom::MatrixGroup(3, 4, Dom::Rational)
>> MatGQ::hasProp(Cat::AbelianGroup), MatGQ::hasProp(Cat::Ring)
TRUE, FALSE
MatGQ
is a commutative group with respect
to the addition of matrices. The unit of this group is the 3 x
4 zero matrix:
>> MatGQ::zero
+- -+ | 0, 0, 0, 0 | | | | 0, 0, 0, 0 | | | | 0, 0, 0, 0 | +- -+
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]])
+- -+ | 1, 2, 1, 2 | | | | -5, 3, 0, 0 | | | | 2, 1/3, 0, 1 | +- -+
and delete its third column, we get the matrix:
>> MatGQ::delCol(A, 3)
+- -+ | 1, 2, 2 | | | | -5, 3, 0 | | | | 2, 1/3, 1 | +- -+
which is of the domain type:
>> domtype(%)
Dom::Matrix(Dom::Rational)
As another example we create the 3 x 3
identity matrix using the method "identity"
of our
domain:
>> E3 := MatGQ::identity(3)
+- -+ | 1, 0, 0 | | | | 0, 1, 0 | | | | 0, 0, 1 | +- -+
This is also a matrix of the domain
Dom::Matrix(Dom::Rational)
:
>> domtype(E3)
Dom::Matrix(Dom::Rational)
If we concatenate E3
to the right of the
matrix A
defined above, we get the 3 x 7
matrix:
>> B := A . E3
+- -+ | 1, 2, 1, 2, 1, 0, 0 | | | | -5, 3, 0, 0, 0, 1, 0 | | | | 2, 1/3, 0, 1, 0, 0, 1 | +- -+
which is of the domain type
Dom::Matrix(Dom::Rational)
:
>> domtype(B)
Dom::Matrix(Dom::Rational)
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)
+- -+ | 1, 2, 3 | | | | 2, 4, 6 | +- -+
To convert A
into a matrix of the domain
MatC
, enter:
>> coerce(A, MatC)
+- -+ | 1, 2, 3 | | | | 2, 4, 6 | +- -+
>> domtype(%)
Dom::Matrix(Dom::Complex)
The conversion is done component-wise. For example, we define the following matrix:
>> B := MatC([[0, 1, 0], [exp(I), 0, 1]])
+- -+ | 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)
FAIL
Note: The system function coerce
uses the methods
"convert"
and "convert_to"
implemented by any
domain created with Dom::MatrixGroup
and
Dom::Matrix
.
"dimen"
was renamed to
"matdim"
."newThis"
was renamed to
"create"
.Dom::Matrix
. See the
corresponding help page for details. Note that
Dom::MatrixGroup
(m, n, R)
inherits every
method which is defined for Dom::Matrix(R)
and not
re-implemented by Dom::MatrixGroup
(m, n,
R)
.