When you try to add a scalar to a Vector, you get an error because there is no mathematical meaning for this operation.

When you add a scalar to a Matrix, the scalar is interpreted as the scalar multiplied by an appropriately sized Identity Matrix.  Another way to think of this is that the scalar is added to the entries on the main diagonal.

When you add a scalar to an Array, the scalar is added to every entry in the Array.

The MatrixAdd and VectorAdd functions let you add a multiple of one Matrix (or Vector) to another.  This functionality can also be obtained by using the + and * operators:

Adding (multiples of) Vectors:

Adding two 2x3 Matrices (one is constructed in row-major order and the other in column-major order, but the addition still works since the resulting Matrices are the same size):

You can also add Arrays:

The '*' operator is used to perform commutative multiplication.  When you use the '*' operator, Maple assumes it can safely reorder the operands.

Since multiplying a Vector, Matrix, or Array by a scalar is commutative, you can use the * operator to perform that operation:

Matrix and Vector multiplication is not commutative, so attempting to use the '*' operator when both operands are Matrices or Vectors results in an error.

There is a form of commutative multiplication for Arrays.  The '*' operator carries out pointwise multiplication (each entry in the first Array is multiplied by the corresponding entry in the second Array):

The '.' operator is used to perform noncommutative multiplication.  When you use the '.' operator, Maple knows it must not reorder the operands.

You can also use the '.' operator to perform scalar multiplication.  In 2-D math, you must put the scalar in parentheses so that Maple knows you intend to use the . as an operator, not a decimal point.  Scalar multiplication is the one situation in which '*' and '.' can be used interchangeably.  You may find it easier to use '*' or implicit multiplication, since it does not require parentheses.

(Note: in 1-D math, there is no need to use parentheses, but you must put spaces on either side of the dot so that Maple knows you intend to use the . as an operator.)

If one of the operands is an unassigned variable, Maple does not know whether it represents a scalar, and so does not automatically carry out the multiplication.

To tell Maple to treat the variable as a scalar, use the simplify command with option symbolic or assume=scalar:

You can carry out Matrix and Vector multiplication by using the '.' operator.

On Arrays, the '.' operator performs component-wise multiplication.

To carry out Matrix multiplication repeatedly (that is, to get a power of a Matrix), use the '^' operator:

The examples in this section use the following Matrix.  Note that (with one exception, indicated below) the same techniques can be used on Vectors and Arrays.

To extract a single entry, type its row and column coordinates in square brackets after the name of the Matrix:

The simplest way to extract a row is by using a single index.

To extract part of a row (or column) as a row Vector (or column Vector), use a range instead of a single index for the row (or column) coordinate:

To extract a sub-Matrix, replace both coordinates with ranges:

Notice that you can control whether the result is the entry, a 1-element row Vector, a 1-element column Vector, or a 1x1 Matrix based on whether you use single indices or ranges:

If you do not want a contiguous set of entries, or if you wish to reorder rows or columns, use a list (which can also include ranges):

Note that an index list containing a single item (for example, [3]) yields the same results as a range with the same beginning and end points.  

You can use negative indices to count backwards from the end of a Vector or Matrix.  Use -1 to indicate the last row (or column), -2 to indicate the second last row (or column), and so on.  (This technique does not apply to Arrays since they can have negative indices.)

You can also use implicit range endpoints.  For example,  means from the third row (or column) to the last row (or column), and  means from the first row (or column) to the third row (or column).  Thus, the following syntax is equivalent to  for the 5x5 Matrix .

You can overwrite data using the same notation as in the previous section.  This works as long as the right-hand side of your expression matches the size and shape of the left-hand side (it can be smaller than the left-hand side, but not larger).

So far, we have seen how to index entries in a Matrix or Vector using square brackets, [].  There is a second way to index entries using round brackets, ().  This is called programmer indexing.  One use of programmer indexing is to grow a Matrix or Vector past its initially declared bounds.

The following attempts to assign to column 6 of the 5x5 Matrix . Maple returns an error.

Using round brackets, however, the Matrix is enlarged to include a sixth column.

For more information on programmer indexing, see rtable_indexing.

You can use the techniques from the previous two sections to carry out elementary row operations in place.  Note that these techniques are intended for convenient interactive Maple use.  For programs carrying out extensive operations it will be more efficient to call the appropriate LinearAlgebra routine directly.

Swap two rows:

Multiply a row by a scalar:

Add a multiple of one row to another: