Matrices are represented in

*Mathematica* with lists. They can be entered directly with the { } notation, constructed from a formula, or imported from a data file.

*Mathematica* also has commands for creating diagonal matrices, constant matrices, and other special matrix types.

A matrix can be entered directly with

notation:

Out[125]= | |

You can show the result in matrix notation with

MatrixForm:

Out[126]//MatrixForm= |

| |

is another way of entering

. It can be convenient to use it when

is a formatting function.

This uses

Table to create a grid of values in

and

:

Out[129]//MatrixForm= |

| |

Note that matrices in

*Mathematica* are not restricted to contain numbers; they can contain symbolic entries such as formulas:

Out[131]//MatrixForm= |

| |

When you create a matrix and save it with an assignment, take care not to combine this with formatting using

MatrixForm. Use parentheses:

Out[132]//MatrixForm= |

| |

You can use

in further calculations:

Out[133]//MatrixForm= |

| |

Suppose you do not use parentheses:

Out[134]//MatrixForm= |

| |

Then

will print like a matrix but will not work in calculations like a matrix. For example, the following does not carry out matrix multiplication:

Out[135]= | |

You can check the value of

by using

FullForm:

Out[11]//FullForm= |

| |

This shows that

also includes the formatting wrapper

MatrixForm, which stops it from working as a matrix.

There are functions to create a variety of special types of matrices.

This creates a 4×5 matrix of real values that fall between -10 and 10:

Out[136]//MatrixForm= |

| |

This creates a matrix that only has nonzero entries on the diagonal:

Out[137]//MatrixForm= |

| |

This creates a matrix whose entries are all the same:

Out[138]//MatrixForm= |

| |

This creates a 4×4 Hilbert matrix; each entry is of the form

:

Out[139]//MatrixForm= |

| |

Many linear algebra and other functions return matrices.

Here, the QR decomposition of a random 3×3 matrix is calculated:

This prints the Q matrix:

Out[142]//MatrixForm= |

| |

When

*Mathematica* functions return matrices they often use an optimized storage format called packed arrays.

You can apply many common operations in

*Mathematica* to a list, and get back another list with the function mapped onto each element. This also works for matrices, which are lists of lists.

Here is a 2×2 matrix of squares:

Out[144]//MatrixForm= |

| |

This applies

Sqrt to each element of the matrix:

Out[145]//MatrixForm= |

| |

This behavior of

Sqrt is called listability, and it makes very readable and efficient code.

If a function that is not listable is used, it does not map onto each element:

Out[146]= | |

You can make the function listable; now it will map onto each element:

Out[148]//MatrixForm= |

| |

Another important way to create a matrix is to import a data file. This can be done with tabular formats such as

Table (.dat),

CSV (.csv), and

TSV (.tsv). A matrix can also be read from an

Excel spreadsheet (.xls).

Here,

ImportString is used to import a CSV formatted string into a matrix. Importing from a file is done with

Import:

Out[149]= | |

*Mathematica* also supports a number of other formats including scientific and medical data formats such as

HarwellBoeing,

MAT,

HDF,

NASACDF, and

FITS.

The way that you create a matrix can have an important impact on the efficiency of your programs. For the best efficiency, avoid appending to a matrix, avoid unnecessary creation operations, and use listable operations when you can.

This example repeatedly adds a new row to a matrix:

Out[151]= | |

It is much faster to create the matrix in one computation. Whenever you see a

For loop, try to replace it with some other construct, like

Table:

Out[152]= | |

The following example creates a

matrix of zeros and then fills it in with a loop. The creation of a zero matrix here is completely unnecessary:

Out[153]= | |

It is much faster to create data for each row of the matrix once, and then use a listable operation:

Out[154]= | |

If your matrices are large and have many elements that are the same (for example, zero), then you should consider working with sparse matrices formed with

SparseArray.