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[1]= |  |
You can show the result in matrix notation with
MatrixForm:
Out[2]//MatrixForm= |
| |  |
expr//fun is another way of entering
fun[expr]. It can be convenient to use it when
fun is a formatting function.
This uses
Table to create a grid of values in
and
:
Out[4]//MatrixForm= |
| |  |
Note that matrices in
Mathematica are not restricted to contain numbers; they can contain symbolic entries such as formulas:
Out[5]//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[6]//MatrixForm= |
| |  |
You can use
mat in further calculations:
Out[7]//MatrixForm= |
| |  |
Suppose you do not use parentheses:
Out[8]//MatrixForm= |
| |  |
Then
mat 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[9]= |  |
You can check the value of
mat by using
FullForm:
Out[10]//FullForm= |
| |  |
This shows that
mat 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[11]//MatrixForm= |
| |  |
This creates a matrix that only has nonzero entries on the diagonal:
Out[12]//MatrixForm= |
| |  |
This creates a matrix whose entries are all the same:
Out[13]//MatrixForm= |
| |  |
This creates a 4×4 Hilbert matrix; each entry is of the form 1/(
i +
j - 1):
Out[14]//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[16]//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[17]//MatrixForm= |
| |  |
This applies
Sqrt to each element of the matrix:
Out[18]//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[19]= |  |
You can make the function listable; now it will map onto each element:
Out[20]//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[21]= |  |
Mathematica also supports a number of other formats including scientific and medical data formats such as
HarwellBoeing,
MAT,
HDF,
CDF, 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[22]= |  |
It is much faster to create the matrix in one computation. Whenever you see a
For loop you want to see how to replace it with some other construct like
Table:
| Out[23]= |  |
The following example creates a
2×n matrix of zeros and then fills it in with a loop. The creation of a zero matrix here is completely unnecessary:
| Out[24]= |  |
It is much faster to create data for each row of the matrix once, and then use a listable operation:
| Out[25]= |  |
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.
