Return to computing page for the first course APMA0330

Return to computing page for the second course APMA0340

Return to Mathematica tutorial for the first course APMA0330

Return to Mathematica tutorial for the second course APMA0340

Return to the main page for the first course APMA0330

Return to the main page for the second course APMA0340

Return to Part I of the course APMA0340

Introduction to Linear Algebra with *Mathematica*

## Glossary

# Preface

Understanding matrices is crucial for almost all applications,
especially for computer modeling. Indeed, a laptop or smartphone
monitor is the most common example of a matrix filled with pixels. A
wide range of applications includes the numerical solution to a set of
linear algebraic equations. All numerical algorithms for solving
differential equations are based on the reduction to algebraic matrix
problems. Every matrix defines a linear operation in a vector space
and vise versa, every linear operator ain a finite dimensional spaces
can be identified with a matrix.
Every matrix can be considered as an array or vectors whose entries are algebraic entries. A matrix is the next generalization of a vector. In this section, you will learn how to define matrices with *Mathematica* as well as some other manipulation tools.

# How to define Matrices

Matrices are simultaneously a very ancient and a highly relevant mathematical concept. The origin of mathematical matrices has a long history. References to matrices and systems of equations can be found in Chinese manuscripts dating back to around 200 B.C. "Matrix" is the Latin word for womb. The term "matrix" in combinatorics was introduced in 1850 by the British mathematician James Joseph Sylvester (1814--1897), who also coined many mathematical terms or used them in "new or unusual ways" mathematically, such as graphs, discriminant, annihilators, canonical forms, minor, nullity, and many others.

A matrix (plural matrices) is a rectangular array of numbers, functions, or any symbols. It can be written as

We denote this array by a single letter **A** (usually a capital boldfaced letter) or by \( \left( a_{i,j} \right) \)
or \( \left[ a_{i,j} \right] , \) depending on what notation (parenthesis or brackets) is in use.
The symbol \( a_{i,j} ,\) or sometimes \( a_{ij} ,\) in the *i*th
row and *j*th column is called the \( \left( i, \, j \right) \) entry. We say that **A** has
*m* rows and *n* columns, and that it is an \( m \times n \) matrix. We also refer to **A** as a matrix of size
\( m \times n . \)

Any \( m \times n \) matrix can be considered as an array of \( n \) columns

*i*th row contains entries of matrix

**A**in

*i*th column. Correspondingly, the row vector \( {\bf r}_j = \langle a_{j,1} , a_{j,2} , \ldots , a_{j,n} \rangle \) in

*j*th column contains entries of matrix

**A**in

*j*th row.

Before we can discuss arithmetic operations for matrices, we have to define equality
for matrices. Two matrices are equal if they have the same size and their corresponding
elements are equal. A matrix with elements that are all 0’s is called a zero or null matrix. A null matrix usually is indicated as **0**.

Another very important type of matrices are square matrices that have the same number of rows as columns. In particular, a square matrix having all elements equal to zero except those on the principal diagonal is called a diagonal matrix.

Constructing Matrices

*Mathematica* offers several ways for constructing matrices:

Table[f,{i,m},{j,n}] | Build an m×n matrix where f is a function of i and j that gives the value of the i,j entry |

Array[f,{m,n}] | Build an m×n matrix whose i,j entry is f[i,j] |

ConstantArray[a,{m,n}] | Build an m×n matrix with all entries equal to a |

DiagonalMatrix[list] | Generate a diagonal matrix with the elements of list on the diagonal |

IdentityMatrix[n] | Generate an n×n identity matrix |

Normal[SparseArray[{{i1,j1}->v1,{i2,j2}->v2,…},{m,n}]] | Make a matrix with nonzero values v_{k}k at positions {i_{k},j_{k}} |

RandomReal[1, {m,n}] | Make a m×n matrix with random coordinates |

In addition, *Mathematica* offers matrices with different
random distributions together with RandomVariate.

Nevertheless, it is most common to define vectors and matrices by typing every row in curly brackets: For example, let's define a 2×3 matrix (with two rows and three columns) as

**TraditionalForm**or

**MatrixForm**.

**MatrixForm**and

**TraditionalForm**are interchangeable as they perform the same operation and are for display only. The output is a single object (image in this case), rather than a matrix with individual components. This means that individual components, such as the second element of the second row, cannot be called upon once either MatrixForm or TraditionalForm is used. As a result, these options are not suitable for matrix operations. For instance, if you want to multiply

**A**with its transpose or extract an element from

**A**,

*Mathematica*will not perform these operations:

**TraditionalForm**or

**MatrixForm**) that are kept by

*Mathematica*in traditional form as a single unit (or image). The motivation for this is so that the matrix operations can be performed on the matrices we define. The first option is to define a matrix on one line of code and then display it in a convenient form on a completely separate line of code.

A // MatrixForm

**MatrixForm**or

**TraditionalForm**) but define the entire matrix within parentheses.

**ReplacePart[expr,i->new]**
yields an expression in which the i-th part of **expr** is
replaced by new.

Diagonal Matrices

**DiagonalMatrix[L]**. When you have a list of values,

**L**, you can build a square diagonal matrix with entries from

**L**along its diagonal. All entries outside the main diagonal are zeroes. Other "diagonals" of a rectangular or square matrix extend from upper left to lower right; the main diagonal starts in the upper left-hand corner.

The command **Diagonal[M] ** gives the list of elements on the leading diagonal of matrix **M**.

The command **Diagonal[M,k]** gives the elements on the k-th
diagonal of matrix **M**.

**Example 1: **
Consider the 4×5 matrix

%// MatrixForm

**MatrixForm**for the direct definition of matrix

**A**will prohibit any operations with elements of the matrix. Therefore, we first define matrix

**A**and only after that we visualize it with

**MatrixForm**or

**TraditionalForm**. For instance, you can determine a particular element of the matrix

**B**as

*Mathematica*will not be able to provide you the answer:

To see diagonal elements, we type:

Diagonal[A]

*Mathematica*provides the main diagonal, starting at the upper left corner. Other diagonal elements are obtained by including a particular shift from the main diagonal:

*Mathematica*allows us not only to check diagonal elements but also to construct the diagonal matrix. The following two examples are self-explanatory.

Basic Commands

These introductory commands are very easy to use. The first two
command lines define the matrices, **A**
and **M** that we will be analyzing. The most important thing to understand is that to create a matrix with multiple rows,
you need to separate each row and surround it
with {}, as shown in the example above.

The **Dimensions** command tells you the dimensions for each matrix.

The commands

**A[[2,1]]**and

**A[[1]]**are used to have

*Mathematica*output certain matrix elements.

The second to last command just asks

*Mathematica*if the two matrices that we generated are the same, which, of course, they are not.

The command
** MatrixQ[matrix] **
gives True if it is a matrix, otherwise -- False

*m*×

*n*matrices \( {\bf A} = \left[ a_{i,j} \right] \) and \( {\bf B} = \left[ b_{i,j} \right] \) having the same dimensions can be added or subtracted

*Mathematica*uses the standard commands "+" and "-" to add or subtract two matrices of the same dimensions. Remember that you cannot add or subtract matrices of distinct dimensions, and

*Mathematica*will not allow you to perform such operations. However, it is possible to enlarge the lowest size by appending zeroes and then add/subtract the matrices.

Transposition of Matrices

There is a special operation that transfers columns into rows and vice versa: it is called **transposition**. The transpose of a matrix was introduced in 1858
by the British mathematician Arthur Cayley (1821--1895). The transpose of a *m* × *n* matrix **A** is an *n* × *m* matrix
**A**^{T} (also denoted as \( {\bf A}' \) or
\( {\bf A}^t \) ) created by any one of the following equivalent actions:

reflects **A** over its main diagonal (which runs from top-left to bottom-right);

writes the rows of **A** as the columns of \( {\bf A}^{\mathrm T} \)

Formally, the *i*-th row, *j*-th column element of **A**^{T} is the *j*-th row, *i*-th column element of **A**:

Let **A** and **B** be \( m \times n \) matrices
and c be a scalar. Then we have the following properties for transpose matrices:

1. \( \left( {\bf A}^{\mathrm T} \right)^{\mathrm T} = {\bf A} \)

2. \( \left( {\bf A} + {\bf B} \right)^{\mathrm T} = {\bf A}^{\mathrm T} + {\bf B}^{\mathrm T} \)

3. \( \left( {\bf A} \, {\bf B} \right)^{\mathrm T} = {\bf B}^{\mathrm T} \, {\bf A}^{\mathrm T} \)

4. \( \left( c \, {\bf B} \right)^{\mathrm T} = c\,{\bf B}^{\mathrm T} \)

5. \( {\bf A}\, {\bf A}^{\mathrm T} \) is a symmetric matrix.

A square matrix whose transpose is equal to its negative is called a skew-symmetric matrix; that is, **A** is skew-symmetric if

Complex entries

Let **A** be a *m* × *n* matrix with real or complex entries (they could be numbers or functions or other
entities). Its complex conjugate, denoted by \( \overline{\bf A} , \) is again a *m* × *n* matrix,
which is formed by taking the complex conjugate of each entry. *Mathematica* has a specific command to calculate the complex conjugate:

Adjoint Matrices

If we take a transpose of the complex conjugate of *m*
× *n* matrix **A**, we get the *n*
× *m* matrix,
called the **adjoint** matrix of **A**,
which is denoted by
\( {\bf A}^{\ast} = \overline{{\bf A}^{\mathrm T}} = \left( \overline{\bf A} \right)^{\mathrm T} . \)

**A**is called symmetric if \( {\bf A} = {\bf A}^{\mathrm T} . \) A square matrix

**A**is called

**self-adjoint**(or Hermitian) if it coincides with its transposed and complex conjugate:

**A**

^{*}or

**A**

^{H},

**A**

^{T}is the transpose matrix, and \( \overline{z} = a - {\bf j}b \) is complex conjugate of

*z*= 𝑎 +

**j**

*b*.

**Pauli matrix**, named after the Austrian (and later American / Swiss) physicist Wolfgang Ernst Pauli (1900-1958):

% //TraditionalForm

A square complex matrix whose transpose is equal to the matrix with every entry replaced by its
complex conjugate (denoted here with an overline) is called a **self-adjoint matrix** or a
Hermitian matrix (equivalent to the matrix being equal to its
conjugate transpose); that is, **A** is self-adjoint or Hermitian if \( {\bf A} = {\bf A}^{\ast} . \)

**A**is not self-adjoint.

Building zero or diagonal matrices

*Mathematica* makes no distinction between vectors
and matrices. For example, all *n* element column vectors are treated as
*n*×1 matrices. This means that we can create a composition of row vectors in a column vector or vice versa.

If you wish to avoid building your matrix from curly brackets, *Mathematica* allows you to specify the size of a matrix through its toolbar. Navigate to *Insert* on the toolbar. Then click *Table/Matrix* -> *New*. A window will now appear allowing you to specify the size of your matrix. Under *Make* select *Matrix(List of lists)*. Then specify the number of rows and columns you wish to input and click *ok*. Your specified matrix will now appear on your notebook for you to input information.

Suppose we need to build a zero matrix or the identity matrix:

\( \begin{pmatrix} 1&0&0 \\ 0&1&0 \\ 0&0&1 \end{pmatrix} \)

\( \begin{pmatrix} 1&0&0 \\ 0&1&0 \\ 0&0&1 \end{pmatrix} \)

**DiagonalMatrix[list]**gives a matrix with the elements of the list on the leading diagonal, and 0 elsewhere. Therefore, the identity matrix of dimensions \( 3 \times 3 \) can be defined also as

To construct an \( n \times n \) zero square matrix, use the command **Table[Table[0,{n}],{n}]**, where **n** specifies the dimension of the matrix.

Adding distinct size matrices

According to definition, we can add (or subtract) two matrices only when they are of the same size by adding (or subtracting) corresponding entries. However, sometimes we need to add two matrices of distinct sizes. It is natural to extend matrices to the largest of dimensions and fill extra entries by zeroes. It turns out that *Mathematica* accommodates such an operation, but you need to write a special subroutine in Wolfram language.
To add two matrices (or sets of vectors) of different size by appending additional zeros to smallest vectors, we use the following script:

n = Length[A[[1]]]; m = Length[B[[1]]];

Which[n > m, B1 = Map[PadRight[#, n] &, B, 1], n < m,

A1 = Map[PadRight[#, m] &, A, 1], True,(*do nothing*)];

sum1 = Map[PadRight[#, Max[n, m] + 1] &,

Flatten[Table[A1[[i]] + B1[[j]], {i, 1, Length[A1]}, {j, 1, Length[B1]}],

1], 1]; Return[sum1[[All, 1 ;; Length[Part[sum1, 1]] - 1]]];]

Note: The inputs **A_** and **B_** represent the input
variables. However, we use **A_?MatrixQ** and **B_?MatrixQ** to
tell *Mathematica* to verify that these input variables are
matrices, not arbitrary inputs.

The same code but appending zero to the right of every vector:

Module[{A1, B1, n, m },

A1 = A; B1 = B;

n = Length[A[[1]]];

m = Length[B[[1]]];

Which[n > m, B1 = Map[PadRight[#, n] &, B, 1],

n < m, A1 = Map[PadRight[#, m] &, A, 1],

True, (* do nothing *)];

sum1 = Map[PadRight[#, Max[n, m] + 1] &,

Flatten[Table[

A1[[i]] + B1[[j]], {i, 1, Length[A1]}, {j, 1, Length[B1]}], 1],

1];

Return[sum1];

]

For instance, to add two sets of vectors, we apply:

B = {{a, b}, {c, d}, {e, f}};

AddSets[A, B]

Example

B = {{a, b}, {c, d}, {e, f}};

AddSets0[A, B]

0}, {4 + a, 5 + b, 6, 0}, {4 + c, 5 + d, 6, 0}, {4 + e, 5 + f, 6, 0}}

Return to Mathematica page

Return to the main page (APMA0340)

Return to the Part 1 Matrix Algebra

Return to the Part 2 Linear Systems of Ordinary Differential Equations

Return to the Part 3 Non-linear Systems of Ordinary Differential Equations

Return to the Part 4 Numerical Methods

Return to the Part 5 Fourier Series

Return to the Part 6 Partial Differential Equations

Return to the Part 7 Special Functions