# Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English verison of the page.

# `Dom`::`SquareMatrix`

Rings of square matrices

MATLAB live scripts support most MuPAD functionality, though there are some differences. For more information, see Convert MuPAD Notebooks to MATLAB Live Scripts.

## Syntax

### Domain Creation

`Dom::SquareMatrix(`n`, <`R`>)`

### Element Creation

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

## Description

### Domain Creation

`Dom::SquareMatrix(n, R)` creates a domain which represents the ring of n×n matrices over a component domain `R`. The domain `R` must be of category `Cat::Rng` (a ring, possibly without unit).

If the optional parameter `R` is not given, the domain `Dom::ExpressionField()` is used as the component ring for the square matrices.

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

`Dom::SquareMatrix(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::SquareMatrix(n, R)`.

Methods described below are re-implemented by `Dom::SquareMatrix`.

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::MatrixGroup(m, n, R)` represents the Abelian group of m×n matrices over R.

### Element Creation

`Dom::SquareMatrix(n, R)(Array)` and ```Dom::SquareMatrix(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::SquareMatrix(n, R)( n , n )` returns the n×n zero matrix. Note that the n×n zero matrix is also defined by the entry `"zero"` (see below).

`Dom::SquareMatrix(n, R)( n , n ListOfRows)` creates an n×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 `n` inner lists, the remaining lower rows of the matrix are filled with zeroes.

The entries of the inner lists are converted 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::SquareMatrix(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::SquareMatrix(n, R)( n , n f)` returns the matrix whose (i, j)th component is the value of the function call `f(i, j)`. The row and column indices i and j range from 1 to `n`.

The function values are converted 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`.

## Categories

`Cat::SquareMatrix``(R)`

## 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::SquareMatrix`.

These examples only concentrate on some differences with respect to working with matrices of the domain `Dom::Matrix(R)`.

The following command defines the ring of two-dimensional matrices over the rationals:

`SqMatQ := Dom::SquareMatrix(2, Dom::Rational)`

`SqMatQ::hasProp(Cat::Ring)`

The unit is defined by the entry `"one"`, which is the 2×2 identity matrix:

`SqMatQ::one`

Note that some operations defined by the domain `SqMatQ` return matrices which are no longer square. They return therefore matrices of the domain `Dom::Matrix(Dom::Rational)`, the super-domain of `SqMatQ`. For example, if we delete the first row of the matrix:

`A := SqMatQ([[1, 2], [-5, 3]])`

we get the matrix:

`SqMatQ::delRow(A, 1)`

which is of the domain type:

`domtype(%)`

### Example 2

We can convert a square matrix into or from another matrix domain, as shown next:

```SqMatR := Dom::SquareMatrix(3, Dom::Real): MatC := Dom::Matrix(Dom::Complex):```
`A := SqMatR((i, j) -> sin(i*j))`

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

`coerce(A, MatC)`

`domtype(%)`

The conversion is done component-wise, as the following examples shows:

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

The matrix B is square but has one complex component and therefore cannot be converted into the domain `SqMatR`:

`coerce(B, SqMatR)`

## Parameters

 `n` A positive integer `R` A ring, i.e., a domain of category `Cat::Rng`; default is `Dom::ExpressionField()` `Array` An n×n array `Matrix` An n×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 `n` 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::SquareMatrix(n, R)( n , n List, Diagonal)` creates the n×n diagonal matrix whose diagonal elements are the entries of `List`. `List` must have at most `n` entries. If it has fewer elements, the remaining diagonal elements 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. `Dom::SquareMatrix(n, R)( n , n g, Diagonal)` returns the matrix whose ith diagonal element is `g(i)`, where the index i runs from 1 to `n`. The function values are converted into elements of the domain `R`. An error message is issued if one of these conversions fails. `Banded` Create a banded Toeplitz matrix `Dom::SquareMatrix(n, R)( n , n List, Banded)` creates an n×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 the n×n identity matrix. This entry exists if the component ring `R` is a domain of category `Cat::Ring`, i.e., a ring with unit. "randomDimen" is set to `[n, n]`. "zero" is the n×n zero matrix.

## Methods

expand all

#### Mathematical Methods

`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(k)`

### Note

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

This method only exists if the component ring `R` is of category `Cat::Ring`, i.e., a ring with unit.

`matdim(A)`

`random()`

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

#### Access Methods

`_concat(A, B, …)`

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

### Note

The matrix returned 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(A, i, j)`

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

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.

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 returned is of the domain `Dom::Matrix(R)`!

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

```concatMatrix(A, B, …)```

`col(A, c)`

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

`delCol(A, c)`

`NIL` is returned if `A` only consists of one column.

### Note

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

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

`delRow(A, r)`

`NIL` is returned if `A` only consists of one row.

### Note

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

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

`row(A, r)`

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

`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

`create(x, …)`

This method should be used if the elements of the parameters `x`, ... are elements of the domain type `R`. This is often the case if a matrix is to be created whose components come from preceding matrix and scalar operations.