LeviCivita , Permutations , Dot, . , InProduct , CrossProduct , Outer, o , ZeroVector , BaseVector , Identity , ZeroMatrix , Diagonal , DiagonalMatrix , OrthogonalBasis , OrthonormalBasis , IsScalar , IsVector , IsMatrix , IsSquareMatrix , Normalize , Transpose , Determinant , Trace , Inverse , Minor , CoFactor , MatrixPower , SolveMatrix , CharacteristicEquation , EigenValues , EigenVectors , IsHermitian , IsOrthogonal , IsDiagonal , IsLowerTriangular, IsUpperTriangular , IsSymmetric , IsSkewSymmetric , IsUnitary , IsIdempotent , JacobianMatrix , VandermondeMatrix , HessianMatrix , Sparsity , HilbertMatrix , HilbertInverseMatrix , ToeplitzMatrix , WronskianMatrix , SylvesterMatrix , MatrixSolve , Cholesky , RandomIntegerMatrix .

Linear Algebra

This chapter describes the commands for doing linear algebra. They can be used to manipulate vectors, represented as lists, and matrices, represented as lists of lists.

LeviCivita totally anti-symmetric Levi-Civita symbol
Permutations get all permutations of a list
Dot, . get dot product of tensors
InProduct inner product of vectors (deprecated)
CrossProduct outer product of vectors
Outer, o get outer tensor product
ZeroVector create a vector with all zeroes
BaseVector base vector
Identity make identity matrix
ZeroMatrix make a zero matrix
Diagonal extract the diagonal from a matrix
DiagonalMatrix construct a diagonal matrix
OrthogonalBasis create an orthogonal basis
OrthonormalBasis create an orthonormal basis
IsScalar test for a scalar
IsVector test for a vector
IsMatrix test for a matrix
IsSquareMatrix test for a square matrix
Normalize normalize a vector
Transpose get transpose of a matrix
Determinant determinant of a matrix
Trace trace of a matrix
Inverse get inverse of a matrix
Minor get principal minor of a matrix
CoFactor cofactor of a matrix
MatrixPower get nth power of a square matrix
SolveMatrix solve a linear system
CharacteristicEquation get characteristic polynomial of a matrix
EigenValues get eigenvalues of a matrix
EigenVectors get eigenvectors of a matrix
IsHermitian test for a Hermitian matrix
IsOrthogonal test for an orthogonal matrix
IsDiagonal test for a diagonal matrix
IsLowerTriangular, IsUpperTriangular test for a lower or an upper triangular matrix
IsSymmetric test for a symmetric matrix
IsSkewSymmetric test for a skew-symmetric matrix
IsUnitary test for a unitary matrix
IsIdempotent test for an idempotent matrix
JacobianMatrix calculate the Jacobian matrix of n functions in n variables
VandermondeMatrix create the Vandermonde matrix
HessianMatrix create the Hessian matrix
Sparsity get the sparsity of a matrix
HilbertMatrix create a Hilbert matrix
HilbertInverseMatrix create a Hilbert inverse matrix
ToeplitzMatrix create a Toeplitz matrix
WronskianMatrix create the Wronskian matrix
SylvesterMatrix calculate the Sylvester matrix of two polynomials
MatrixSolve solve a system of equations
Cholesky find the Cholesky Decomposition
RandomIntegerMatrix generate a matrix of random integers


LeviCivita -- totally anti-symmetric Levi-Civita symbol

Standard library
Calling format:
LeviCivita(list)

Parameters:
list -- a list of integers 1 .. n in some order

Description:
LeviCivita implements the Levi-Civita symbol. This is generally useful for tensor calculus. list should be a list of integers, and this function returns 1 if the integers are in successive order, eg. LeviCivita( {1,2,3,...} ) would return 1. Swapping two elements of this list would return -1. So, LeviCivita( {2,1,3} ) would evaluate to -1.

Examples:
In> LeviCivita({1,2,3})
Out> 1;
In> LeviCivita({2,1,3})
Out> -1;
In> LeviCivita({2,2,3})
Out> 0;

See also:
Permutations .


Permutations -- get all permutations of a list

Standard library
Calling format:
Permutations(list)

Parameters:
list -- a list of elements

Description:
Permutations returns a list with all the permutations of the original list.

Examples:
In> Permutations({a,b,c})
Out> {{a,b,c},{a,c,b},{c,a,b},{b,a,c},
{b,c,a},{c,b,a}};

See also:
LeviCivita .


Dot, . -- get dot product of tensors

Standard library
Calling format:
Dot(t1,t2)
t1 . t2
Precedence: 30

Parameters:
t1,t2 -- tensor lists (currently only vectors and matrices are supported)

Description:
Dot returns the dot (aka inner) product of two tensors t1 and t2. The last index of t1 and the first index of t2 are contracted. Currently Dot works only for vectors and matrices. Dot-multiplication of two vectors, a matrix with a vector (and vice versa) or two matrices yields either a scalar, a vector or a matrix.

Examples:
In> Dot({1,2},{3,4})
Out> 11;
In> Dot({{1,2},{3,4}},{5,6})
Out> {17,39};
In> Dot({5,6},{{1,2},{3,4}})
Out> {23,34};
In> Dot({{1,2},{3,4}},{{5,6},{7,8}})
Out> {{19,22},{43,50}};

Or, using the "."-Operator:

In> {1,2} . {3,4}
Out> 11;
In> {{1,2},{3,4}} . {5,6}
Out> {17,39};
In> {5,6} . {{1,2},{3,4}}
Out> {23,34};
In> {{1,2},{3,4}} . {{5,6},{7,8}}
Out> {{19,22},{43,50}};

See also:
Outer , Cross , IsScalar , IsVector , IsMatrix .


InProduct -- inner product of vectors (deprecated)

Standard library
Calling format:
InProduct(a,b)

Parameters:
a, b -- vectors of equal length

Description:
The inner product of the two vectors "a" and "b" is returned. The vectors need to have the same size.

This function is superceded by the . operator.

Examples:
In> {a,b,c} . {d,e,f};
Out> a*d+b*e+c*f;

See also:
Dot , CrossProduct .


CrossProduct -- outer product of vectors

Standard library
Calling format:
CrossProduct(a,b)
a X b
Precedence: 30

Parameters:
a, b -- three-dimensional vectors

Description:
The cross product of the vectors "a" and "b" is returned. The result is perpendicular to both "a" and "b" and its length is the product of the lengths of the vectors. Both "a" and "b" have to be three-dimensional.

Examples:
In> {a,b,c} X {d,e,f};
Out> {b*f-c*e,c*d-a*f,a*e-b*d};

See also:
InProduct .


Outer, o -- get outer tensor product

Standard library
Calling format:
Outer(t1,t2)
t1 o t2
Precedence: 30

Parameters:
t1,t2 -- tensor lists (currently only vectors are supported)

Description:
Outer returns the outer product of two tensors t1 and t2. Currently Outer work works only for vectors, i.e. tensors of rank 1. The outer product of two vectors yields a matrix.

Examples:
In> Outer({1,2},{3,4,5})
Out> {{3,4,5},{6,8,10}};
In> Outer({a,b},{c,d})
Out> {{a*c,a*d},{b*c,b*d}};

Or, using the "o"-Operator:

In> {1,2} o {3,4,5}
Out> {{3,4,5},{6,8,10}};
In> {a,b} o {c,d}
Out> {{a*c,a*d},{b*c,b*d}};

See also:
Dot , Cross .


ZeroVector -- create a vector with all zeroes

Standard library
Calling format:
ZeroVector(n)

Parameters:
n -- length of the vector to return

Description:
This command returns a vector of length "n", filled with zeroes.

Examples:
In> ZeroVector(4)
Out> {0,0,0,0};

See also:
BaseVector , ZeroMatrix , IsZeroVector .


BaseVector -- base vector

Standard library
Calling format:
BaseVector(k, n)

Parameters:
k -- index of the base vector to construct

n -- dimension of the vector

Description:
This command returns the "k"-th base vector of dimension "n". This is a vector of length "n" with all zeroes except for the "k"-th entry, which contains a 1.

Examples:
In> BaseVector(2,4)
Out> {0,1,0,0};

See also:
ZeroVector , Identity .


Identity -- make identity matrix

Standard library
Calling format:
Identity(n)

Parameters:
n -- size of the matrix

Description:
This commands returns the identity matrix of size "n" by "n". This matrix has ones on the diagonal while the other entries are zero.

Examples:
In> Identity(3)
Out> {{1,0,0},{0,1,0},{0,0,1}};

See also:
BaseVector , ZeroMatrix , DiagonalMatrix .


ZeroMatrix -- make a zero matrix

Standard library
Calling format:
ZeroMatrix(n)
ZeroMatrix(n, m)

Parameters:
n -- number of rows

m -- number of columns

Description:
This command returns a matrix with n rows and m columns, completely filled with zeroes. If only given one parameter, it returns the square n by n zero matrix.

Examples:
In> ZeroMatrix(3,4)
Out> {{0,0,0,0},{0,0,0,0},{0,0,0,0}};
In> ZeroMatrix(3)
Out> {{0,0,0},{0,0,0},{0,0,0}};

See also:
ZeroVector , Identity .


Diagonal -- extract the diagonal from a matrix

Standard library
Calling format:
Diagonal(A)

Parameters:
A -- matrix

Description:
This command returns a vector of the diagonal components of the matrix A.

Examples:
In> Diagonal(5*Identity(4))
Out> {5,5,5,5};
In> Diagonal(HilbertMatrix(3))
Out> {1,1/3,1/5};

See also:
DiagonalMatrix , IsDiagonal .


DiagonalMatrix -- construct a diagonal matrix

Standard library
Calling format:
DiagonalMatrix(d)

Parameters:
d -- list of values to put on the diagonal

Description:
This command constructs a diagonal matrix, that is a square matrix whose off-diagonal entries are all zero. The elements of the vector "d" are put on the diagonal.

Examples:
In> DiagonalMatrix(1 .. 4)
Out> {{1,0,0,0},{0,2,0,0},{0,0,3,0},{0,0,0,4}};

See also:
Identity , ZeroMatrix .


OrthogonalBasis -- create an orthogonal basis

Standard library
Calling format:
OrthogonalBasis(W)

Parameters:
W - A linearly independent set of row vectors (aka a matrix)

Description:
Given a linearly independent set W (constructed of rows vectors), this command returns an orthogonal basis V for W, which means that span(V) = span(W) and InProduct(V[i],V[j]) = 0 when i != j. This function uses the Gram-Schmidt orthogonalization process.

Examples:
In> OrthogonalBasis({{1,1,0},{2,0,1},{2,2,1}}) 
Out> {{1,1,0},{1,-1,1},{-1/3,1/3,2/3}};

See also:
OrthonormalBasis , InProduct .


OrthonormalBasis -- create an orthonormal basis

Standard library
Calling format:
OrthonormalBasis(W)

Parameters:
W - A linearly independent set of row vectors (aka a matrix)

Description:
Given a linearly independent set W (constructed of rows vectors), this command returns an orthonormal basis V for W. This is done by first using OrthogonalBasis(W), then dividing each vector by its magnitude, so as the give them unit length.

Examples:
In> OrthonormalBasis({{1,1,0},{2,0,1},{2,2,1}})
Out> {{Sqrt(1/2),Sqrt(1/2),0},{Sqrt(1/3),-Sqrt(1/3),Sqrt(1/3)},
	{-Sqrt(1/6),Sqrt(1/6),Sqrt(2/3)}};

See also:
OrthogonalBasis , InProduct , Normalize .


IsScalar -- test for a scalar

Standard library
Calling format:
IsScalar(expr)

Parameters:
expr -- a mathematical object

Description:
IsScalar returns True if expr is a scalar, False otherwise. Something is considered to be a scalar if it's not a list.

Examples:
In> IsScalar(7)
Out> True;
In> IsScalar(Sin(x)+x)
Out> True;
In> IsScalar({x,y})
Out> False;

See also:
IsList , IsVector , IsMatrix .


IsVector -- test for a vector

Standard library
Calling format:
IsVector(expr)

IsVector(pred,expr)

Parameters:
expr -- expression to test

pred -- predicate test (e.g. IsNumber, IsInteger, ...)

Description:
IsVector(expr) returns True if expr is a vector, False otherwise. Something is considered to be a vector if it's a list of scalars. IsVector(pred,expr) returns True if expr is a vector and if the predicate test pred returns True when applied to every element of the vector expr, False otherwise.

Examples:
In> IsVector({a,b,c})
Out> True;
In> IsVector({a,{b},c})
Out> False;
In> IsVector(IsInteger,{1,2,3})
Out> True;
In> IsVector(IsInteger,{1,2.5,3})
Out> False;

See also:
IsList , IsScalar , IsMatrix .


IsMatrix -- test for a matrix

Standard library
Calling format:
IsMatrix(expr)

IsMatrix(pred,expr)

Parameters:
expr -- expression to test

pred -- predicate test (e.g. IsNumber, IsInteger, ...)

Description:
IsMatrix(expr) returns True if expr is a matrix, False otherwise. Something is considered to be a matrix if it's a list of vectors of equal length. IsMatrix(pred,expr) returns True if expr is a matrix and if the predicate test pred returns True when applied to every element of the matrix expr, False otherwise.

Examples:
In> IsMatrix(1)
Out> False;
In> IsMatrix({1,2})
Out> False;
In> IsMatrix({{1,2},{3,4}})
Out> True;
In> IsMatrix(IsRational,{{1,2},{3,4}})
Out> False;
In> IsMatrix(IsRational,{{1/2,2/3},{3/4,4/5}})
Out> True;

See also:
IsList , IsVector .


IsSquareMatrix -- test for a square matrix

Standard library
Calling format:
IsSquareMatrix(expr)

IsSquareMatrix(pred,expr)

Parameters:
expr -- expression to test

pred -- predicate test (e.g. IsNumber, IsInteger, ...)

Description:
IsSquareMatrix(expr) returns True if expr is a square matrix, False otherwise. Something is considered to be a square matrix if it's a matrix having the same number of rows and columns. IsMatrix(pred,expr) returns True if expr is a square matrix and if the predicate test pred returns True when applied to every element of the matrix expr, False otherwise.

Examples:
In> IsSquareMatrix({{1,2},{3,4}});
Out> True;
In> IsSquareMatrix({{1,2,3},{4,5,6}});
Out> False;
In> IsSquareMatrix(IsBoolean,{{1,2},{3,4}});
Out> False;
In> IsSquareMatrix(IsBoolean,{{True,False},{False,True}});
Out> True;

See also:
IsMatrix .


Normalize -- normalize a vector

Standard library
Calling format:
Normalize(v)

Parameters:
v -- a vector

Description:
Return the normalized (unit) vector parallel to v: a vector having the same direction but with length 1.

Examples:
In> v:=Normalize({3,4})
Out> {3/5,4/5};
In> v . v
Out> 1;

See also:
InProduct , CrossProduct .


Transpose -- get transpose of a matrix

Standard library
Calling format:
Transpose(M)

Parameters:
M -- a matrix

Description:
Transpose returns the transpose of a matrix M. Because matrices are just lists of lists, this is a useful operation too for lists.

Examples:
In> Transpose({{a,b}})
Out> {{a},{b}};


Determinant -- determinant of a matrix

Standard library
Calling format:
Determinant(M)

Parameters:
M -- a matrix

Description:
Returns the determinant of a matrix M.

Examples:
In> A:=DiagonalMatrix(1 .. 4)
Out> {{1,0,0,0},{0,2,0,0},{0,0,3,0},{0,0,0,4}};
In> Determinant(A)
Out> 24;


Trace -- trace of a matrix

Standard library
Calling format:
Trace(M)

Parameters:
M -- a matrix

Description:
Trace returns the trace of a matrix M (defined as the sum of the elements on the diagonal of the matrix).

Examples:
In> A:=DiagonalMatrix(1 .. 4)
Out> {{1,0,0,0},{0,2,0,0},{0,0,3,0},{0,0,0,4}};
In> Trace(A)
Out> 10;


Inverse -- get inverse of a matrix

Standard library
Calling format:
Inverse(M)

Parameters:
M -- a matrix

Description:
Inverse returns the inverse of matrix M. The determinant of M should be non-zero. Because this function uses Determinant for calculating the inverse of a matrix, you can supply matrices with non-numeric (symbolic) matrix elements.

Examples:
In> A:=DiagonalMatrix({a,b,c})
Out> {{a,0,0},{0,b,0},{0,0,c}};
In> B:=Inverse(A)
Out> {{(b*c)/(a*b*c),0,0},{0,(a*c)/(a*b*c),0},
{0,0,(a*b)/(a*b*c)}};
In> Simplify(B)
Out> {{1/a,0,0},{0,1/b,0},{0,0,1/c}};

See also:
Determinant .


Minor -- get principal minor of a matrix

Standard library
Calling format:
Minor(M,i,j)

Parameters:
M -- a matrix

i, j - positive integers

Description:
Minor returns the minor of a matrix around the element ( i, j). The minor is the determinant of the matrix obtained from M by deleting the i-th row and the j-th column.

Examples:
In> A := {{1,2,3}, {4,5,6}, {7,8,9}};
Out> {{1,2,3},{4,5,6},{7,8,9}};
In> PrettyForm(A);

/                    \
| ( 1 ) ( 2 ) ( 3 )  |
|                    |
| ( 4 ) ( 5 ) ( 6 )  |
|                    |
| ( 7 ) ( 8 ) ( 9 )  |
\                    /
Out> True;
In> Minor(A,1,2);
Out> -6;
In> Determinant({{2,3}, {8,9}});
Out> -6;

See also:
CoFactor , Determinant , Inverse .


CoFactor -- cofactor of a matrix

Standard library
Calling format:
CoFactor(M,i,j)

Parameters:
M -- a matrix

i, j - positive integers

Description:
CoFactor returns the cofactor of a matrix around the element ( i, j). The cofactor is the minor times (-1)^(i+j).

Examples:
In> A := {{1,2,3}, {4,5,6}, {7,8,9}};
Out> {{1,2,3},{4,5,6},{7,8,9}};
In> PrettyForm(A);

/                    \
| ( 1 ) ( 2 ) ( 3 )  |
|                    |
| ( 4 ) ( 5 ) ( 6 )  |
|                    |
| ( 7 ) ( 8 ) ( 9 )  |
\                    /
Out> True;
In> CoFactor(A,1,2);
Out> 6;
In> Minor(A,1,2);
Out> -6;
In> Minor(A,1,2) * (-1)^(1+2);
Out> 6;

See also:
Minor , Determinant , Inverse .


MatrixPower -- get nth power of a square matrix

Standard library
Calling format:
MatrixPower(mat,n)

Parameters:
mat -- a square matrix

n -- an integer

Description:
MatrixPower(mat,n) returns the nth power of a square matrix mat. For positive n it evaluates dot products of mat with itself. For negative n the nth power of the inverse of mat is returned. For n=0 the identity matrix is returned.

Example:
In> A:={{1,2},{3,4}}
Out> {{1,2},{3,4}};
In> MatrixPower(A,0)
Out> {{1,0},{0,1}};
In> MatrixPower(A,1)
Out> {{1,2},{3,4}};
In> MatrixPower(A,3)
Out> {{37,54},{81,118}};
In> MatrixPower(A,-3)
Out> {{-59/4,27/4},{81/8,-37/8}};

See also:
IsSquareMatrix , Inverse , Dot .


SolveMatrix -- solve a linear system

Standard library
Calling format:
SolveMatrix(M,v)

Parameters:
M -- a matrix

v -- a vector

Description:
SolveMatrix returns the vector x that satisfies the equation M*x=v. The determinant of M should be non-zero.

Examples:
In> A := {{1,2}, {3,4}};
Out> {{1,2},{3,4}};
In> v := {5,6};
Out> {5,6};
In> x := SolveMatrix(A, v);
Out> {-4,9/2};
In> A * x;
Out> {5,6};

See also:
Inverse , Solve , PSolve , Determinant .


CharacteristicEquation -- get characteristic polynomial of a matrix

Standard library
Calling format:
CharacteristicEquation(matrix,var)

Parameters:
matrix -- a matrix

var -- a free variable

Description:
CharacteristicEquation returns the characteristic equation of "matrix", using "var". The zeros of this equation are the eigenvalues of the matrix, Det(matrix-I*var);

Examples:
In> A:=DiagonalMatrix({a,b,c})
Out> {{a,0,0},{0,b,0},{0,0,c}};
In> B:=CharacteristicEquation(A,x)
Out> (a-x)*(b-x)*(c-x);
In> Expand(B,x)
Out> (b+a+c)*x^2-x^3-((b+a)*c+a*b)*x+a*b*c;

See also:
EigenValues , EigenVectors .


EigenValues -- get eigenvalues of a matrix

Standard library
Calling format:
EigenValues(matrix)

Parameters:
matrix -- a square matrix

Description:
EigenValues returns the eigenvalues of a matrix. The eigenvalues x of a matrix M are the numbers such that M*v=x*v for some vector.

It first determines the characteristic equation, and then factorizes this equation, returning the roots of the characteristic equation Det(matrix-x*identity).

Examples:
In> M:={{1,2},{2,1}}
Out> {{1,2},{2,1}};
In> EigenValues(M)
Out> {3,-1};

See also:
EigenVectors , CharacteristicEquation .


EigenVectors -- get eigenvectors of a matrix

Standard library
Calling format:
EigenVectors(A,eigenvalues)

Parameters:
matrix -- a square matrix

eigenvalues -- list of eigenvalues as returned by EigenValues

Description:
EigenVectors returns a list of the eigenvectors of a matrix. It uses the eigenvalues and the matrix to set up n equations with n unknowns for each eigenvalue, and then calls Solve to determine the values of each vector.

Examples:
In> M:={{1,2},{2,1}}
Out> {{1,2},{2,1}};
In> e:=EigenValues(M)
Out> {3,-1};
In> EigenVectors(M,e)
Out> {{-ki2/ -1,ki2},{-ki2,ki2}};

See also:
EigenValues , CharacteristicEquation .


IsHermitian -- test for a Hermitian matrix

Standard library
Calling format:
IsHermitian(A)

Parameters:
A -- a square matrix

Description:
IsHermitian(A) returns True if A is Hermitian and False otherwise. A is a Hermitian matrix iff Conjugate( Transpose A )= A. If A is a real matrix, it must be symmetric to be Hermitian.

Examples:
In> IsHermitian({{0,I},{-I,0}})
Out> True;
In> IsHermitian({{0,I},{2,0}})
Out> False;

See also:
IsUnitary .


IsOrthogonal -- test for an orthogonal matrix

Standard library
Calling format:
IsOrthogonal(A)

Parameters:
A -- square matrix

Description:
IsOrthogonal(A) returns True if A is orthogonal and False otherwise. A is orthogonal iff A*Transpose( A) = Identity, or equivalently Inverse( A) = Transpose( A).

Examples:
In> A := {{1,2,2},{2,1,-2},{-2,2,-1}};
Out> {{1,2,2},{2,1,-2},{-2,2,-1}};
In> PrettyForm(A/3)

/                      \
| / 1 \  / 2 \ / 2 \   |
| | - |  | - | | - |   |
| \ 3 /  \ 3 / \ 3 /   |
|                      |
| / 2 \  / 1 \ / -2 \  |
| | - |  | - | | -- |  |
| \ 3 /  \ 3 / \ 3  /  |
|                      |
| / -2 \ / 2 \ / -1 \  |
| | -- | | - | | -- |  |
| \ 3  / \ 3 / \ 3  /  |
\                      /
Out> True;
In> IsOrthogonal(A/3)
Out> True;


IsDiagonal -- test for a diagonal matrix

Standard library
Calling format:
IsDiagonal(A)

Parameters:
A -- a matrix

Description:
IsDiagonal(A) returns True if A is a diagonal square matrix and False otherwise.

Examples:
In> IsDiagonal(Identity(5))
Out> True;
In> IsDiagonal(HilbertMatrix(5))
Out> False;


IsLowerTriangular, IsUpperTriangular -- test for a lower or an upper triangular matrix

Standard library
Calling format:
IsLowerTriangular(A)
IsUpperTriangular(A)

Parameters:
A -- a matrix

Description:
A lower/upper triangular matrix is a square matrix which has all zero entries above/below the diagonal.

IsLowerTriangular(A) returns True if A is a lower triangular matrix and False otherwise. IsUpperTriangular(A) returns True if A is an upper triangular matrix and False otherwise.

Examples:
In> IsUpperTriangular(Identity(5))
Out> True;
In> IsLowerTriangular(Identity(5))
Out> True;
In> IsLowerTriangular({{1,2},{0,1}})
Out> False;
In> IsUpperTriangular({{1,2},{0,1}})
Out> True;
A non-square matrix cannot be triangular:
In> IsUpperTriangular({{1,2,3},{0,1,2}})
Out> False;

See also:
IsDiagonal .


IsSymmetric -- test for a symmetric matrix

Standard library
Calling format:
IsSymmetric(A)

Parameters:
A -- a matrix

Description:
IsSymmetric(A) returns True if A is symmetric and False otherwise. A is symmetric iff Transpose ( A) = A.

Examples:
In> A := {{1,0,0,0,1},{0,2,0,0,0},{0,0,3,0,0},
  {0,0,0,4,0},{1,0,0,0,5}};
In> PrettyForm(A)

/                                \
| ( 1 ) ( 0 ) ( 0 ) ( 0 ) ( 1 )  |
|                                |
| ( 0 ) ( 2 ) ( 0 ) ( 0 ) ( 0 )  |
|                                |
| ( 0 ) ( 0 ) ( 3 ) ( 0 ) ( 0 )  |
|                                |
| ( 0 ) ( 0 ) ( 0 ) ( 4 ) ( 0 )  |
|                                |
| ( 1 ) ( 0 ) ( 0 ) ( 0 ) ( 5 )  |
\                                /
Out> True;
In> IsSymmetric(A)
Out> True;
	

See also:
IsHermitian , IsSkewSymmetric .


IsSkewSymmetric -- test for a skew-symmetric matrix

Standard library
Calling format:
IsSkewSymmetric(A)

Parameters:
A -- a square matrix

Description:
IsSkewSymmetric(A) returns True if A is skew symmetric and False otherwise. A is skew symmetric iff Transpose(A) =-A.

Examples:
In> A := {{0,-1},{1,0}}
Out> {{0,-1},{1,0}};
In> PrettyForm(%)

/               \
| ( 0 ) ( -1 )  |
|               |
| ( 1 ) ( 0 )   |
\               /
Out> True;
In> IsSkewSymmetric(A);
Out> True;

See also:
IsSymmetric , IsHermitian .


IsUnitary -- test for a unitary matrix

Standard library
Calling format:
IsUnitary(A)

Parameters:
A -- a square matrix

Description:
This function tries to find out if A is unitary.

A matrix A is orthogonal iff A^(-1) = Transpose( Conjugate(A) ). This is equivalent to the fact that the columns of A build an orthonormal system (with respect to the scalar product defined by InProduct).

Examples:
In> IsUnitary({{0,I},{-I,0}})
Out> True;
In> IsUnitary({{0,I},{2,0}})
Out> False;

See also:
IsHermitian , IsSymmetric .


IsIdempotent -- test for an idempotent matrix

Standard library
Calling format:
IsIdempotent(A)

Parameters:
A -- a square matrix

Description:
IsIdempotent(A) returns True if A is idempotent and False otherwise. A is idempotent iff A^2=A. Note that this also implies that A raised to any power is also equal to A.

Examples:
In> IsIdempotent(ZeroMatrix(10,10));
Out> True;
In> IsIdempotent(Identity(20))
Out> True;


JacobianMatrix -- calculate the Jacobian matrix of n functions in n variables

Standard library
Calling format:
JacobianMatrix(functions,variables)

Parameters:
functions -- an n-dimensional vector of functions

variables -- an n-dimensional vector of variables

Description:
The function JacobianMatrix calculates the Jacobian matrix of n functions in n variables.

The ( i, j)-th element of the Jacobian matrix is defined as the derivative of i-th function with respect to the j-th variable.

Examples:
In> JacobianMatrix( {Sin(x),Cos(y)}, {x,y} ); 
Out> {{Cos(x),0},{0,-Sin(y)}};
In> PrettyForm(%)

/                                 \
| ( Cos( x ) ) ( 0 )              |
|                                 |
| ( 0 )        ( -( Sin( y ) ) )  |
\                                 /


VandermondeMatrix -- create the Vandermonde matrix

Standard library
Calling format:
VandermondeMatrix(vector)
Parameters:
vector -- an n-dimensional vector

Description:
The function VandermondeMatrix calculates the Vandermonde matrix of a vector.

The ( i, j)-th element of the Vandermonde matrix is defined as i^(j-1).

Examples:
In> VandermondeMatrix({1,2,3,4})
Out> {{1,1,1,1},{1,2,3,4},{1,4,9,16},{1,8,27,64}};
In>PrettyForm(%)

/                            \
| ( 1 ) ( 1 ) ( 1 )  ( 1 )   |
|                            |
| ( 1 ) ( 2 ) ( 3 )  ( 4 )   |
|                            |
| ( 1 ) ( 4 ) ( 9 )  ( 16 )  |
|                            |
| ( 1 ) ( 8 ) ( 27 ) ( 64 )  |
\                            /


HessianMatrix -- create the Hessian matrix

Standard library
Calling format:
HessianMatrix(function,var)
Parameters:
function -- a function in n variables

var -- an n-dimensional vector of variables

Description:
The function HessianMatrix calculates the Hessian matrix of a vector.

If f(x) is a function of an n-dimensional vector x, then the ( i, j)-th element of the Hessian matrix of the function f(x) is defined as Deriv(x[i])Deriv(x[j])f(x). If the third order mixed partials are continuous, then the Hessian matrix is symmetric (a standard theorem of calculus).

The Hessian matrix is used in the second derivative test to discern if a critical point is a local maximum, a local minimum or a saddle point.

Examples:
In> HessianMatrix(3*x^2-2*x*y+y^2-8*y, {x,y} )
Out> {{6,-2},{-2,2}};
In> PrettyForm(%)

/                \
| ( 6 )  ( -2 )  |
|                |
| ( -2 ) ( 2 )   |
\                /


Sparsity -- get the sparsity of a matrix

Standard library
Calling format:
Sparsity(matrix)
Parameters:
matrix -- a matrix

Description:
The function Sparsity returns a number between 0 and 1 which represents the percentage of zero entries in the matrix. Although there is no definite critical value, a sparsity of 0.75 or more is almost universally considered a "sparse" matrix. These type of matrices can be handled in a different manner than "full" matrices which speedup many calculations by orders of magnitude.

Examples:
In> Sparsity(Identity(2))
Out> 0.5;
In> Sparsity(Identity(10))
Out> 0.9;
In> Sparsity(HankelMatrix(10))
Out> 0.45;
In> Sparsity(HankelMatrix(100))
Out> 0.495;
In> Sparsity(HilbertMatrix(10))
Out> 0;
In> Sparsity(ZeroMatrix(10,10))
Out> 1;


HilbertMatrix -- create a Hilbert matrix

Standard library
Calling format:
HilbertMatrix(n)
HilbertMatrix(n,m)
Parameters:
n,m -- positive integers

Description:
The function HilbertMatrix returns the n by m Hilbert matrix if given two arguments, and the square n by n Hilbert matrix if given only one. The Hilbert matrix is defined as A(i,j) = 1/(i+j-1). The Hilbert matrix is extremely sensitive to manipulate and invert numerically.

Examples:
In> PrettyForm(HilbertMatrix(4))

/                          \
| ( 1 ) / 1 \ / 1 \ / 1 \  |
|       | - | | - | | - |  |
|       \ 2 / \ 3 / \ 4 /  |
|                          |
| / 1 \ / 1 \ / 1 \ / 1 \  |
| | - | | - | | - | | - |  |
| \ 2 / \ 3 / \ 4 / \ 5 /  |
|                          |
| / 1 \ / 1 \ / 1 \ / 1 \  |
| | - | | - | | - | | - |  |
| \ 3 / \ 4 / \ 5 / \ 6 /  |
|                          |
| / 1 \ / 1 \ / 1 \ / 1 \  |
| | - | | - | | - | | - |  |
| \ 4 / \ 5 / \ 6 / \ 7 /  |
\                          /

See also:
HilbertInverseMatrix .


HilbertInverseMatrix -- create a Hilbert inverse matrix

Standard library
Calling format:
HilbertInverseMatrix(n)
Parameters:
n -- positive integer

Description:
The function HilbertInverseMatrix returns the n by n inverse of the corresponding Hilbert matrix. All Hilbert inverse matrices have integer entries that grow in magnitude rapidly.

Examples:
In> PrettyForm(HilbertInverseMatrix(4))

/                                         \
| ( 16 )   ( -120 )  ( 240 )   ( -140 )   |
|                                         |
| ( -120 ) ( 1200 )  ( -2700 ) ( 1680 )   |
|                                         |
| ( 240 )  ( -2700 ) ( 6480 )  ( -4200 )  |
|                                         |
| ( -140 ) ( 1680 )  ( -4200 ) ( 2800 )   |
\                                         /

See also:
HilbertMatrix .


ToeplitzMatrix -- create a Toeplitz matrix

Standard library
Calling format:
ToeplitzMatrix(N)
Parameters:
N -- an n-dimensional row vector

Description:
The function ToeplitzMatrix calculates the Toeplitz matrix given an n-dimensional row vector. This matrix has the same entries in all diagonal columns, from upper left to lower right.

Examples:
In> PrettyForm(ToeplitzMatrix({1,2,3,4,5}))

/                                \
| ( 1 ) ( 2 ) ( 3 ) ( 4 ) ( 5 )  |
|                                |
| ( 2 ) ( 1 ) ( 2 ) ( 3 ) ( 4 )  |
|                                |
| ( 3 ) ( 2 ) ( 1 ) ( 2 ) ( 3 )  |
|                                |
| ( 4 ) ( 3 ) ( 2 ) ( 1 ) ( 2 )  |
|                                |
| ( 5 ) ( 4 ) ( 3 ) ( 2 ) ( 1 )  |
\                                /


WronskianMatrix -- create the Wronskian matrix

Standard library
Calling format:
WronskianMatrix(func,var)
Parameters:
func -- an n-dimensional vector of functions

var -- a variable to differentiate with respect to

Description:
The function WronskianMatrix calculates the Wronskian matrix of n functions.

The Wronskian matrix is created by putting each function as the first element of each column, and filling in the rest of each column by the ( i-1)-th derivative, where i is the current row.

The Wronskian matrix is used to verify that the n functions are linearly independent, usually solutions to a differential equation. If the determinant of the Wronskian matrix is zero, then the functions are dependent, otherwise they are independent.

Examples:
In> WronskianMatrix({Sin(x),Cos(x),x^4},x);
Out> {{Sin(x),Cos(x),x^4},{Cos(x),-Sin(x),4*x^3},
  {-Sin(x),-Cos(x),12*x^2}};
In> PrettyForm(%)

/                                                 \
| ( Sin( x ) )      ( Cos( x ) )      /  4 \      |
|                                     \ x  /      |
|                                                 |
| ( Cos( x ) )      ( -( Sin( x ) ) ) /      3 \  |
|                                     \ 4 * x  /  |
|                                                 |
| ( -( Sin( x ) ) ) ( -( Cos( x ) ) ) /       2 \ |
|                                     \ 12 * x  / |
\                                                 /
The last element is a linear combination of the first two, so the determinant is zero:
In> A:=Determinant( WronskianMatrix( {x^4,x^3,2*x^4 
  + 3*x^3},x ) )
Out> x^4*3*x^2*(24*x^2+18*x)-x^4*(8*x^3+9*x^2)*6*x
  +(2*x^4+3*x^3)*4*x^3*6*x-4*x^6*(24*x^2+18*x)+x^3
  *(8*x^3+9*x^2)*12*x^2-(2*x^4+3*x^3)*3*x^2*12*x^2;
In> Simplify(A)
Out> 0;


SylvesterMatrix -- calculate the Sylvester matrix of two polynomials

Standard library
Calling format:
SylvesterMatrix(poly1,poly2,variable)

Parameters:
poly1 -- polynomial

poly2 -- polynomial

variable -- variable to express the matrix for

Description:
The function SylvesterMatrix calculates the Sylvester matrix for a pair of polynomials.

The Sylvester matrix is closely related to the resultant, which is defined as the determinant of the Sylvester matrix. Two polynomials share common roots only if the resultant is zero.

Examples:
In> ex1:= x^2+2*x-a
Out> x^2+2*x-a;
In> ex2:= x^2+a*x-4
Out> x^2+a*x-4;
In> A:=SylvesterMatrix(ex1,ex2,x)
Out> {{1,2,-a,0},{0,1,2,-a},
  {1,a,-4,0},{0,1,a,-4}};
In> B:=Determinant(A)
Out> 16-a^2*a- -8*a-4*a+a^2- -2*a^2-16-4*a;
In> Simplify(B)
Out> 3*a^2-a^3;

The above example shows that the two polynomials have common zeros if a=3.

See also:
Determinant , Simplify , Solve , PSolve .


MatrixSolve -- solve a system of equations

Standard library
Calling format:
MatrixSolve(A,b)

Parameters:
A -- coefficient matrix

b -- row vector

Description:
MatrixSolve solves the matrix equations A*x = b using Gaussian Elimination with Backward substitution. If your matrix is triangular or diagonal, it will be recognized as such and a faster algorithm will be used.

Examples:
In> A:={{2,4,-2,-2},{1,2,4,-3},{-3,-3,8,-2},{-1,1,6,-3}};
Out> {{2,4,-2,-2},{1,2,4,-3},{-3,-3,8,-2},{-1,1,6,-3}};
In> b:={-4,5,7,7};
Out> {-4,5,7,7};
In> MatrixSolve(A,b);
Out> {1,2,3,4};


Cholesky -- find the Cholesky Decomposition

Standard library
Calling format:
Cholesky(A)

Parameters:
A -- a square positive definite matrix

Description:
Cholesky returns a upper triangular matrix R such that Transpose(R)*R = A. The matrix A must be positive definite, Cholesky will notify the user if the matrix is not. Some families of positive definite matrices are all symmetric matrices, diagonal matrices with positive elements and Hilbert matrices.

Examples:
In> A:={{4,-2,4,2},{-2,10,-2,-7},{4,-2,8,4},{2,-7,4,7}}
Out> {{4,-2,4,2},{-2,10,-2,-7},{4,-2,8,4},{2,-7,4,7}};
In> R:=Cholesky(A);
Out> {{2,-1,2,1},{0,3,0,-2},{0,0,2,1},{0,0,0,1}};
In> Transpose(R)*R = A
Out> True;
In> Cholesky(4*Identity(5))
Out> {{2,0,0,0,0},{0,2,0,0,0},{0,0,2,0,0},{0,0,0,2,0},{0,0,0,0,2}};
In> Cholesky(HilbertMatrix(3))
Out> {{1,1/2,1/3},{0,Sqrt(1/12),Sqrt(1/12)},{0,0,Sqrt(1/180)}};
In> Cholesky(ToeplitzMatrix({1,2,3}))
In function "Check" :
CommandLine(1) : "Cholesky: Matrix is not positive definite"

See also:
IsSymmetric , IsDiagonal , Diagonal .


RandomIntegerMatrix -- generate a matrix of random integers

Standard library
Calling format:
RandomIntegerMatrix(rows,cols,from,to)

Parameters:
rows -- number of rows in matrix

cols -- number of cols in matrix

from -- lower bound

to -- upper bound

Description:
This function generates a rows x cols matrix of random integers. All entries lie between "from" and "to", including the boundaries, and are uniformly distributed in this interval.

Examples:
In> PrettyForm( RandomIntegerMatrix(5,5,-2^10,2^10) )

/                                               \
| ( -506 ) ( 749 )  ( -574 ) ( -674 ) ( -106 )  |
|                                               |
| ( 301 )  ( 151 )  ( -326 ) ( -56 )  ( -277 )  |
|                                               |
| ( 777 )  ( -761 ) ( -161 ) ( -918 ) ( -417 )  |
|                                               |
| ( -518 ) ( 127 )  ( 136 )  ( 797 )  ( -406 )  |
|                                               |
| ( 679 )  ( 854 )  ( -78 )  ( 503 )  ( 772 )   |
\                                               /

See also:
RandomIntegerVector , RandomPoly .