Migration into Linear Algebra

All Products Maple MapleSim

Home : Support : Online Help : Mathematics : Linear Algebra : Examples : Migration into Linear Algebra

Migrating linalg commands to LinearAlgebra and VectorCalculus

The LinearAlgebra and VectorCalculus modules together supersede the linalg package. This document shows how to translate common linalg command sequences to LinearAlgebra and VectorCalculus.

Introduction

The LinearAlgebra package (introduced in Maple 6) is a robust and efficient suite of routines for performing computational linear algebra. Together with the VectorCalculus package (introduced in Maple 8), LinearAlgebra provides more complete and efficient functionality than the older linalg package.

It is recommended that you use LinearAlgebra and VectorCalculus instead of linalg.

Advantages of LinearAlgebra and VectorCalculus over linalg include:

•

The numerical routines in LinearAlgebra for floating-point computation are far more efficient. They make calls to compiled C routines from the NAG library, whereas numerical evaluation in linalg relies solely on the built-in Maple numerics. You can therefore work with very large and/or very sparse Matrices efficiently.

•

The new matrix and vector constructors (called Matrix and Vector) are more intuitive and flexible. For example, LinearAlgebra provides built-in commands for constructing identity Matrices, zero Vectors, unit basis Vectors and many other structured Matrices. Furthermore, both constructors have options for output formatting, datatype of the entries, and more.

•

Matrices and Vectors in LinearAlgebra are new data structures, separate from arrays and lists. These data structures were designed explicitly for efficient linear algebra computations, whereas in linalg, matrices and vectors are stored as general arrays or lists. When creating Matrices and Vectors, you can optionally specify the datatype of their entries (for example, floating-point or complex), the shape (for example, triangular or symmetric), the storage method (for example, sparse or rectangular), and more. The LinearAlgebra routines you call on those matrices can then apply algorithms that take advantage of the matrices' structure.

•	The syntax for Matrix arithmetic is simpler. For example, LinearAlgebra avoids both the syntactic and computational overhead of evalm. You can apply the binary operators +, -, . and ^ directly.

•	LinearAlgebra offers two modes of use, one for maximal numeric efficiency, the other for maximal ease-of-use and readability.

•	The set of commands for vector calculus in the VectorCalculus package is more comprehensive than that in linalg. (For example, it includes an augmented int routine that makes multiple integration over complicated geometric regions extremely simple. It also has routines for differential geometry.)

•	VectorCalculus displays vectors as linear combinations of the basis vectors of the coordinate system you specify. This provides more useful information than a simple list of coordinate values, as linalg does.

•	Unlike linalg, VectorCalculus distinguishes constant vectors from vector fields. This reduces the risk of confusion about the types of the mathematical objects you create.

Constructing Matrices and Vectors

Entering matrices by data entry

linalg

>	$A := matrix (3, 3, [1, 2, 3, 3, 1, 2, 2, 3, 1])$

>	$B ≔ matrix (3, 3, [a, b, c, c, a, b, b, c, a])$

>	$v := vector (3, [5.05, 6.125, 2.980])$

$A := [\begin{array}{r} 1 & 2 & 3 \\ 3 & 1 & 2 \\ 2 & 3 & 1 \end{array}]$

$B := [\begin{array}{c} a & b & c \\ c & a & b \\ b & c & a \end{array}]$

$v := [\begin{array}{c} 5.05 & 6.125 & 2.980 \end{array}]$

(2.1.1)

LinearAlgebra

>	$P ≔ Matrix ([[1, 2, 3], [3, 1, 2], [2, 3, 1]])$

>	$Q ≔ Matrix ([[a, b, c], [c, a, b], [b, c, a]])$

>	$w ≔ Vector ([5.05, 6.125, 2.980])$

>	$w2 := Vector (8, fill = π + \sqrt{2})$

$P ≔ [\begin{array}{c} 1 & 2 & 3 \\ 3 & 1 & 2 \\ 2 & 3 & 1 \end{array}]$

$Q ≔ [\begin{array}{c} a & b & c \\ c & a & b \\ b & c & a \end{array}]$

$w ≔ [\begin{array}{c} 5.05 \\ 6.125 \\ 2.980 \end{array}]$

$w2 ≔ [\begin{array}{c} π + \sqrt{2} \\ π + \sqrt{2} \\ π + \sqrt{2} \\ π + \sqrt{2} \\ π + \sqrt{2} \\ π + \sqrt{2} \\ π + \sqrt{2} \\ π + \sqrt{2} \end{array}]$

(2.1.2)

For small Vectors and Matrices, the <..> and <<..>> constructor shortcuts may be more convenient.

>	$⟨⟨x \| y \| z⟩, ⟨a \| b \| c⟩⟩$

>	$⟨x, y, z⟩$

Extending a given Matrix or Vector

The linalg package has routines stackmatrix and augment (or concat) that can extend matrices or conjoin them.

>	$m := matrix (2, 3, (i, j) \to i + j)$

>	$n ≔ matrix (2, 2, (i, j) \to π)$

>	$linalg [augment] (m, n)$

$m := [\begin{array}{r} 2 & 3 & 4 \\ 3 & 4 & 5 \end{array}]$

$n := [\begin{array}{c} π & π \\ π & π \end{array}]$

$[\begin{array}{c} 2 & 3 & 4 & π & π \\ 3 & 4 & 5 & π & π \end{array}]$

(2.2.1)

>	$m := matrix (3, 2, (i, j) \to i + j)$

>	$n := matrix (2, 2, (i, j) \to π)$

>	$linalg [stackmatrix] (m, n)$

$m := [\begin{array}{r} 2 & 3 \\ 3 & 4 \\ 4 & 5 \end{array}]$

$n := [\begin{array}{c} π & π \\ π & π \end{array}]$

$[\begin{array}{c} 2 & 3 \\ 3 & 4 \\ 4 & 5 \\ π & π \\ π & π \end{array}]$

(2.2.2)

These operations can be done directly using either the Matrix and Vector constructors or their shortcuts.

>	$m := Matrix (2, 3, (i, j) \to i + j)$

>	$n := Matrix (2, 2, fill = π)$

>	$Matrix ([m, n])$

>	$⟨⟨m \| n⟩⟩$

>	$m ≔ Matrix (3, 2, (i, j) \to i + j)$

>	$n ≔ Matrix (2, 2, fill = π)$

>	$Matrix ([m], [n])$

>	$⟨⟨m, n⟩⟩$

The linalg routine blockmatrix assembles blocks of matrices together, which can also be accomplished directly using the Matrix constructor without having to specify the number of blocks.

>	$m := matrix (3, 3, (i, j) \to \|i - j\|) &colon; n := matrix (3, 3, (i, j) \to {\|i - j\|}^{2}) &colon; r := matrix (3, 3, 0) &colon; linalg [blockmatrix] (2, 3, [m, n, r, n, r, m])$

$[\begin{array}{r} 0 & 1 & 2 & 0 & 1 & 4 & 0 & 0 & 0 \\ 1 & 0 & 1 & 1 & 0 & 1 & 0 & 0 & 0 \\ 2 & 1 & 0 & 4 & 1 & 0 & 0 & 0 & 0 \\ 0 & 1 & 4 & 0 & 0 & 0 & 0 & 1 & 2 \\ 1 & 0 & 1 & 0 & 0 & 0 & 1 & 0 & 1 \\ 4 & 1 & 0 & 0 & 0 & 0 & 2 & 1 & 0 \end{array}]$

(2.2.3)

>	$interface (rtablesize = 20) &colon;$

>	$M := Matrix (3, 3, (i, j) \to \|i - j\|) &colon; N := Matrix (3, 3, (i, j) \to {\|i - j\|}^{2}) &colon; R := Matrix (3, 3, 0) &colon; Matrix ([[M, N, R], [N, R, M]])$

$[\begin{array}{c} 0 & 1 & 2 & 0 & 1 & 4 & 0 & 0 & 0 \\ 1 & 0 & 1 & 1 & 0 & 1 & 0 & 0 & 0 \\ 2 & 1 & 0 & 4 & 1 & 0 & 0 & 0 & 0 \\ 0 & 1 & 4 & 0 & 0 & 0 & 0 & 1 & 2 \\ 1 & 0 & 1 & 0 & 0 & 0 & 1 & 0 & 1 \\ 4 & 1 & 0 & 0 & 0 & 0 & 2 & 1 & 0 \end{array}]$

(2.2.4)

The Matrix constructor reproduces the functionality of the linalg routine extend.

>	$m := matrix (3, 3, (i, j) \to i - j)$

>	$linalg [extend] (m, 1, 4, π)$

>	$M := Matrix (3, 3, (i, j) \to i - j)$

>	$Matrix (4, 7, [M], fill = π)$

$m := [\begin{array}{r} 0 & - 1 & - 2 \\ 1 & 0 & - 1 \\ 2 & 1 & 0 \end{array}]$

$[\begin{array}{c} 0 & - 1 & - 2 & π & π & π & π \\ 1 & 0 & - 1 & π & π & π & π \\ 2 & 1 & 0 & π & π & π & π \\ π & π & π & π & π & π & π \end{array}]$

The functionality of the linalg routine copyinto can also be accomplished with Matrices.

>	$m := matrix (6, 6, (i, j) \to i - j) &colon;$ $n := matrix (2, 2, (i, j) \to π) &colon;$ $linalg [copyinto] (n, m, 3, 3)$

$[\begin{array}{c} 0 & - 1 & - 2 & - 3 & - 4 & - 5 \\ 1 & 0 & - 1 & - 2 & - 3 & - 4 \\ 2 & 1 & π & π & - 2 & - 3 \\ 3 & 2 & π & π & - 1 & - 2 \\ 4 & 3 & 2 & 1 & 0 & - 1 \\ 5 & 4 & 3 & 2 & 1 & 0 \end{array}]$

(2.2.5)

>	$M := Matrix (6, 6, (i, j) \to i - j) &colon;$ $N := Matrix (2, 2, fill = π) &colon;$ $NewM := copy (M) &colon;$ $NewM [3 .. 5, 3 .. 5] ≔ N &colon;$ $NewM$

Specially structured matrices and vectors

linalg

>	$array (1 .. 3, 1 .. 3, identity)$

>	$array (1 .. 5, [seq (0, i = 1 .. 5)])$

>	$array (1 .. 3, 1 .. 3, diagonal)$

>	$linalg [band] ([- 1, 2, - 3], 6)$

>	$linalg [hilbert] (3)$

>	$linalg [vandermonde] ([1, 2, 3, 4])$

$[\begin{array}{r} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{array}]$

$[\begin{array}{c} 0 & 0 & 0 & 0 & 0 \end{array}]$

$[\begin{array}{c} {`?`}_{1, 1} & 0 & 0 \\ 0 & {`?`}_{2, 2} & 0 \\ 0 & 0 & {`?`}_{3, 3} \end{array}]$

$[\begin{array}{r} 2 & - 3 & 0 & 0 & 0 & 0 \\ - 1 & 2 & - 3 & 0 & 0 & 0 \\ 0 & - 1 & 2 & - 3 & 0 & 0 \\ 0 & 0 & - 1 & 2 & - 3 & 0 \\ 0 & 0 & 0 & - 1 & 2 & - 3 \\ 0 & 0 & 0 & 0 & - 1 & 2 \end{array}]$

$[\begin{array}{c} 1 & \frac{1}{2} & \frac{1}{3} \\ \frac{1}{2} & \frac{1}{3} & \frac{1}{4} \\ \frac{1}{3} & \frac{1}{4} & \frac{1}{5} \end{array}]$

$[\begin{array}{r} 1 & 1 & 1 & 1 \\ 1 & 2 & 4 & 8 \\ 1 & 3 & 9 & 27 \\ 1 & 4 & 16 & 64 \end{array}]$

(2.3.1)

LinearAlgebra
The naming convention for LinearAlgebra routines is to spell the operation name completely, beginning each word with an uppercase letter.

>	$LinearAlgebra [IdentityMatrix] (3)$

>	$LinearAlgebra [ZeroVector] (5)$

>	$LinearAlgebra [DiagonalMatrix] ([a, b, c]) &semi;$ $LinearAlgebra [BandMatrix] ([- 1, 2, - 3], 1, 6)$

>	$LinearAlgebra [HilbertMatrix] (3) &semi;$ $LinearAlgebra [VandermondeMatrix] ([1, 2, 3, 4])$

A strength of LinearAlgebra is its ability to work with very large Matrices efficiently. Here, we create a 3000-dimensional unit Vector with a 1 in the 17th position.

>	$e2 ≔ LinearAlgebra [UnitVector] (17, 3000)$

$e2 [17]$

>	$e2 [229]$

$1$

$0$

(2.3.2)

Here is a 100x100 band Matrix.

>	$N ≔ LinearAlgebra [BandMatrix] ([- 1, 2, - 3], 1, 100)$

>	$N [47, 47]$

>	$N [47, 48]$

>	$N [47, 49]$

$2$

$- 3$

$0$

(2.3.3)

Maple prints large Vectors and Matrices (one or both dimensions > 10) in the form of a data structure summary. To browse the contents of the vector or matrix , double-click the matrix output. Below is the interface for the 100x100 banded matrix created above.

Matrix Arithmetic

Binary operations

linalg

>	$evalm (A + B)$

>	$evalm (A - B)$

>	$evalm (A &* B)$

>	$evalm (A &* v)$

>	$evalm (A \cdot 2.7)$

$[\begin{array}{c} 1 + a & 2 + b & 3 + c \\ 3 + c & 1 + a & 2 + b \\ 2 + b & 3 + c & 1 + a \end{array}]$

$[\begin{array}{c} 1 - a & 2 - b & 3 - c \\ 3 - c & 1 - a & 2 - b \\ 2 - b & 3 - c & 1 - a \end{array}]$

$[\begin{array}{c} a + 2 c + 3 b & b + 2 a + 3 c & c + 2 b + 3 a \\ c + 2 b + 3 a & a + 2 c + 3 b & b + 2 a + 3 c \\ b + 2 a + 3 c & c + 2 b + 3 a & a + 2 c + 3 b \end{array}]$

$[\begin{array}{c} 26.240 & 27.235 & 31.455 \end{array}]$

$[\begin{array}{c} 2.7 & 5.4 & 8.1 \\ 8.1 & 2.7 & 5.4 \\ 5.4 & 8.1 & 2.7 \end{array}]$

(3.1.1)

LinearAlgebra

For maximal simplicity, you can use +, -, ., and ^ for binary operations.

$P + Q$

>	$P &period; 9 - Q &period; 18$

>	$P &period; Q$

>	$P &period; w$

>	$P &period; 2.7$

$Q^{2}$

For maximal computational efficiency, use the named routines, which demand specific types for the operands (that is, Vector, Matrix, or scalar). These routines save computation time because, unlike the + and . operators, they do not need to determine the operand types.

>	$LinearAlgebra :- MatrixAdd (Q, P)$

>	$LinearAlgebra :- MatrixAdd (Q, P, 9, - 18)$

>	$LinearAlgebra :- MatrixMatrixMultiply (Q, P)$

>	$LinearAlgebra :- MatrixVectorMultiply (P, w)$

>	$LinearAlgebra :- ScalarMultiply (P, 2.7)$

Unary operations and matrix properties

linalg

>	$linalg [transpose] (A)$

>	$linalg [inverse] (A)$

>	$linalg [charpoly] (A, λ)$

>	$linalg [eigenvalues] (A)$

>	$linalg [eigenvectors] (A)$

>	$linalg [\det] (A)$

>	$linalg [trace] (A)$

>	$linalg [nullspace] (matrix (2, 2, [a, b, a, b]))$

$[\begin{array}{r} 1 & 3 & 2 \\ 2 & 1 & 3 \\ 3 & 2 & 1 \end{array}]$

$[\begin{array}{c} - \frac{5}{18} & \frac{7}{18} & \frac{1}{18} \\ \frac{1}{18} & - \frac{5}{18} & \frac{7}{18} \\ \frac{7}{18} & \frac{1}{18} & - \frac{5}{18} \end{array}]$

$λ^{3} - 3 λ^{2} - 15 λ - 18$

$6, - \frac{3}{2} + \frac{1}{2} I \sqrt{3}, - \frac{3}{2} - \frac{1}{2} I \sqrt{3}$

$[- \frac{3}{2} + \frac{1}{2} I \sqrt{3}, 1, \{[\begin{array}{c} - \frac{1}{2} + \frac{1}{2} I \sqrt{3} & 1 & - \frac{1}{2} - \frac{1}{2} I \sqrt{3} \end{array}]\}], [- \frac{3}{2} - \frac{1}{2} I \sqrt{3}, 1, \{[\begin{array}{c} - \frac{1}{2} - \frac{1}{2} I \sqrt{3} & 1 & - \frac{1}{2} + \frac{1}{2} I \sqrt{3} \end{array}]\}], [6, 1, \{[\begin{array}{c} 1 & 1 & 1 \end{array}]\}]$

$18$

$3$

$\{[\begin{array}{c} - \frac{b}{a} & 1 \end{array}]\}$

(3.2.1)

Note that $linalg [kernel]$ computes the same result as $linalg [nullspace]$ .

>	$linalg [norm] ([x, y, z], 2)$

>	$linalg [norm] ([x, y, z])$

>	$linalg [normalize] ([x, y, z])$

>	$linalg [angle] ([x, y, z], [a, b, c])$

$\sqrt{{|x|}^{2} + {|y|}^{2} + {|z|}^{2}}$

$\max [|x|, |y|, |z|]$

$[\begin{array}{c} \frac{x}{\sqrt{{|x|}^{2} + {|y|}^{2} + {|z|}^{2}}} & \frac{y}{\sqrt{{|x|}^{2} + {|y|}^{2} + {|z|}^{2}}} & \frac{z}{\sqrt{{|x|}^{2} + {|y|}^{2} + {|z|}^{2}}} \end{array}]$

$\arccos (\frac{x a + y b + z c}{\sqrt{x^{2} + y^{2} + z^{2}} \sqrt{a^{2} + b^{2} + c^{2}}})$

(3.2.2)

LinearAlgebra

These operations and others are also available through the context menus. To use them, click a matrix and select the desired operation from the options that appear in the Context Panel.

>	$LinearAlgebra :- Transpose (P)$

>	$LinearAlgebra :- MatrixInverse (P)$

>	$LinearAlgebra :- CharacteristicPolynomial (P, λ)$

>	$LinearAlgebra :- Eigenvalues (P)$

>	$LinearAlgebra :- Eigenvectors (P)$

>	$LinearAlgebra :- Determinant (P)$

>	$LinearAlgebra :- Trace (P)$

>	$LinearAlgebra :- NullSpace (⟨⟨a \| b⟩, ⟨a \| b⟩⟩)$

>	$LinearAlgebra :- Norm (⟨a, b, c⟩, 2)$

>	$LinearAlgebra :- Norm (⟨a, b, c⟩)$

>	$LinearAlgebra :- Normalize (⟨a, b, c⟩, 2)$

>	$LinearAlgebra :- VectorAngle (⟨a, b, c⟩, ⟨d, e, f⟩)$

$- 18 + λ^{3} - 3 λ^{2} - 15 λ$

$18$

$3$

$\sqrt{{|a|}^{2} + {|b|}^{2} + {|c|}^{2}}$

$\max [|a|, |b|, |c|]$

$\arccos (\frac{\overset{&conjugate0;}{a} d + \overset{&conjugate0;}{b} e + \overset{&conjugate0;}{c} f}{\sqrt{{|a|}^{2} + {|b|}^{2} + {|c|}^{2}} \sqrt{{|d|}^{2} + {|e|}^{2} + {|f|}^{2}}})$

(3.2.3)

Row and Column Operations

>	$evalm (B)$

>	$linalg [coldim] (B)$

>	$linalg [rowdim] (B)$

>	$linalg [vectdim] (v)$

>	$linalg [col] (B, 2)$

>	$linalg [row] (B, 3)$

>	$linalg [delcols] (B, 2 .. 2)$

>	$linalg [swaprow] (B, 1, 3)$

>	$linalg [swapcol] (B, 1, 3)$

>	$linalg [mulrow] (B, 1, s)$

>	$linalg [mulcol] (B, 1, s)$

$[\begin{array}{c} a & b & c \\ c & a & b \\ b & c & a \end{array}]$

$3$

$[\begin{array}{c} b & a & c \end{array}]$

$[\begin{array}{c} b & c & a \end{array}]$

$[\begin{array}{c} a & c \\ c & b \\ b & a \end{array}]$

$[\begin{array}{c} b & c & a \\ c & a & b \\ a & b & c \end{array}]$

$[\begin{array}{c} c & b & a \\ b & a & c \\ a & c & b \end{array}]$

$[\begin{array}{c} s a & s b & s c \\ c & a & b \\ b & c & a \end{array}]$

$[\begin{array}{c} s a & b & c \\ s c & a & b \\ s b & c & a \end{array}]$

(4.1)

LinearAlgebra

Note: Inside a procedure, you can invoke LinearAlgebra commands (or those from any module), with the use <module names> in <module routine calls> end use; construction. This eliminates the need to invoke with(LinearAlgebra) or prepend LinearAlgebra:- to the names of the routines. The use statement is illustrated below.

>	$use LinearAlgebra in ColumnDimension (P) &semi; RowDimension (P) &semi; Dimension (P) &semi; Dimension (w) &semi; Column (P, 2) &semi; Row (P, 2) &semi; DeleteColumn (P, 2 .. 2) end use$

$3$

$3, 3$

$3$

Use the RowOperation and ColumnOperation routines for any general operation of Gaussian elimination (swapping rows/columns, multiplying rows/columns by scalars, or adding multiples of one row to another). You can overwrite the Matrix with the transformed one by including the option inplace=true, or simply inplace, at the end of the command.

>	$use LinearAlgebra in RowOperation (Q, 1, s) &semi; RowOperation (Q, [1, 3]) &semi; RowOperation (Q, [1, 3], - 7, inplace = true) end use$

Another simple syntax is available to manipulate rows, columns, or subblocks of Matrices and Vectors.

>	$M := Matrix (3, 3, [[1, 2, 3], [- 4, - 5, - 6], [7, 8, 9]])$

>	$M [1, 1 .. 3] ≔ M [2, 1 .. 3]$

$M$

>	$M [3, 1 .. - 1] ≔ 2 M [2, 1 .. 3]$

>	$M &semi;$

>	$M [2 .. 3, 2 .. 3] ≔ Matrix (2, 2, [[π, π], [\sin (x), \cos (y)]])$

$M$

Solving Systems of Linear Equations

linalg

>	$eqns ≔ linalg [geneqns] (A, [x, y, z])$

>	$eqns2 ≔ linalg [geneqns] (A, [x, y, z], v)$

$eqns := \{x + 2 y + 3 z = 0, 2 x + 3 y + z = 0, 3 x + y + 2 z = 0\}$

$eqns2 := \{x + 2 y + 3 z = 5.05, 2 x + 3 y + z = 2.980, 3 x + y + 2 z = 6.125\}$

(5.1)

>	$linalg [genmatrix] (eqns2, [x, y, z])$

>	$linalg [genmatrix] (eqns2, [x, y, z], flag)$

$[\begin{array}{r} 1 & 2 & 3 \\ 2 & 3 & 1 \\ 3 & 1 & 2 \end{array}]$

$[\begin{array}{c} 1 & 2 & 3 & 5.05 \\ 2 & 3 & 1 & 2.980 \\ 3 & 1 & 2 & 6.125 \end{array}]$

(5.2)

>	$linalg [linsolve] (A, v)$

>	$linalg [linsolve] (A, B)$

$[\begin{array}{c} 1.144722223 & - 0.2619444451 & 1.476388889 \end{array}]$

$[\begin{array}{c} \frac{1}{18} b + \frac{7}{18} c - \frac{5}{18} a & \frac{7}{18} a - \frac{5}{18} b + \frac{1}{18} c & - \frac{5}{18} c + \frac{7}{18} b + \frac{1}{18} a \\ - \frac{5}{18} c + \frac{7}{18} b + \frac{1}{18} a & \frac{1}{18} b + \frac{7}{18} c - \frac{5}{18} a & \frac{7}{18} a - \frac{5}{18} b + \frac{1}{18} c \\ \frac{7}{18} a - \frac{5}{18} b + \frac{1}{18} c & - \frac{5}{18} c + \frac{7}{18} b + \frac{1}{18} a & \frac{1}{18} b + \frac{7}{18} c - \frac{5}{18} a \end{array}]$

(5.3)

LinearAlgebra

>	$eqns3 := LinearAlgebra :- GenerateEquations (P, [x, y, z])$

>	$eqns4 := LinearAlgebra :- GenerateEquations (P, [x, y, z], w)$

$eqns3 := [x + 2 y + 3 z = 0, 3 x + y + 2 z = 0, 2 x + 3 y + z = 0]$

$eqns4 := [x + 2 y + 3 z = 5.05, 3 x + y + 2 z = 6.125, 2 x + 3 y + z = 2.980]$

(5.4)

>	$LinearAlgebra :- GenerateMatrix (eqns4, [x, y, z])$

>	$LinearAlgebra :- GenerateMatrix (eqns4, [x, y, z], augmented)$

>	$LinearAlgebra :- LinearSolve (P, w)$

>	$LinearAlgebra :- LinearSolve (P, Q)$

Matrix Reductions and Decompositions

linalg

>	$Av ≔ linalg [augment] (A, linalg [vector] ([1, 2, 1]))$

$Av := [\begin{array}{r} 1 & 2 & 3 & 1 \\ 3 & 1 & 2 & 2 \\ 2 & 3 & 1 & 1 \end{array}]$

(6.1)

>	$linalg [gausselim] (Av)$

>	$linalg [ffgausselim] (Av)$

>	$linalg [gaussjord] (Av)$

>	$linalg [frobenius] (Av)$

>	$linalg [jordan] (A)$

$[\begin{array}{c} 1 & 2 & 3 & 1 \\ 0 & - 5 & - 7 & - 1 \\ 0 & 0 & - \frac{18}{5} & - \frac{4}{5} \end{array}]$

$[\begin{array}{r} 1 & 2 & 3 & 1 \\ 0 & - 5 & - 7 & - 1 \\ 0 & 0 & 18 & 4 \end{array}]$

$[\begin{array}{c} 1 & 0 & 0 & \frac{5}{9} \\ 0 & 1 & 0 & - \frac{1}{9} \\ 0 & 0 & 1 & \frac{2}{9} \end{array}]$

$[\begin{array}{r} 0 & 0 & 18 \\ 1 & 0 & 15 \\ 0 & 1 & 3 \end{array}]$

$[\begin{array}{c} 6 & 0 & 0 \\ 0 & - \frac{3}{2} - \frac{1}{2} I \sqrt{3} & 0 \\ 0 & 0 & - \frac{3}{2} + \frac{1}{2} I \sqrt{3} \end{array}]$

(6.2)

>	$ATA := evalm (linalg [transpose] (A) &* A)$

$ATA := [\begin{array}{r} 14 & 11 & 11 \\ 11 & 14 & 11 \\ 11 & 11 & 14 \end{array}]$

(6.3)

>	$linalg [definite] (ATA, positive_def)$

>	$linalg [cholesky] (ATA)$

$true$

$[\begin{array}{c} \sqrt{14} & 0 & 0 \\ \frac{11}{14} \sqrt{14} & \frac{5}{14} \sqrt{42} & 0 \\ \frac{11}{14} \sqrt{14} & \frac{11}{70} \sqrt{42} & \frac{6}{5} \sqrt{3} \end{array}]$

(6.4)

>	$linalg [LUdecomp] (A)$

>	$linalg [QRdecomp] (A)$

$[\begin{array}{c} 1 & 2 & 3 \\ 0 & - 5 & - 7 \\ 0 & 0 & - \frac{18}{5} \end{array}]$

$[\begin{array}{c} \sqrt{14} & \frac{11}{14} \sqrt{14} & \frac{11}{14} \sqrt{14} \\ 0 & \frac{5}{14} \sqrt{42} & \frac{11}{70} \sqrt{42} \\ 0 & 0 & \frac{6}{5} \sqrt{3} \end{array}]$

(6.5)

LinearAlgebra

>	$use LinearAlgebra in Pv := ⟨P \| ⟨1, 2, 1⟩⟩ &semi; GaussianElimination (Pv) &semi; LUDecomposition (Pv, method = FractionFree) &semi; ReducedRowEchelonForm (Pv) &semi; FrobeniusForm (P) &semi; JordanForm (P) &semi; HessenbergForm (P) end use$

>	$use LinearAlgebra in PTP ≔ Transpose (P) &period; P &semi; IsDefinite (PTP) &semi; LUDecomposition (PTP, method = Cholesky) &semi; P1, P2 ≔ QRDecomposition (P) end use$

$true$

Vector Calculus

$restart$

linalg

>	$v1 := [x, y, z] &colon;$ $v2 ≔ [a, b, c] &colon;$

>	$linalg [dotprod] (v1, v2)$

>	$linalg [innerprod] (v1, v2)$

>	$linalg [crossprod] (v1, v2)$

$x \overset{&conjugate0;}{a} + y \overset{&conjugate0;}{b} + z \overset{&conjugate0;}{c}$

$x a + y b + z c$

$[\begin{array}{c} y c - z b & z a - x c & x b - y a \end{array}]$

(7.1)

>	$f := x^{2} + x z - y^{2} z + \sin (t) &colon;$

>	$linalg [grad] (f, [x, y, z])$

>	$linalg [laplacian] (f, [x, y, z])$

>	$linalg [laplacian] (g (r, θ, φ), [r, θ, φ], coords = cylindrical)$

>	$linalg [hessian] (f, [x, y, z])$

$[\begin{array}{c} 2 x + z & - 2 y z & x - y^{2} \end{array}]$

$2 - 2 z$

$\frac{\frac{\partial}{\partial r} g (r, θ, φ) + r (\frac{\partial^{2}}{\partial r^{2}} g (r, θ, φ)) + \frac{\frac{\partial^{2}}{\partial θ^{2}} g (r, θ, φ)}{r} + r (\frac{\partial^{2}}{\partial φ^{2}} g (r, θ, φ))}{r}$

$[\begin{array}{c} 2 & 0 & 1 \\ 0 & - 2 z & - 2 y \\ 1 & - 2 y & 0 \end{array}]$

(7.2)

>	$F := [x^{2}, x z, y^{2} z] &colon;$

>	$linalg [curl] (F, [x, y, z])$

>	$linalg [diverge] (F, [x, y, z])$

>	$linalg [jacobian] (F, [x, y])$

$[\begin{array}{c} 2 y z - x & 0 & z \end{array}]$

$2 x + y^{2}$

$[\begin{array}{c} 2 x & 0 \\ z & 0 \\ 0 & 2 y z \end{array}]$

(7.3)

VectorCalculus

The VectorCalculus package outputs vectors and vector fields as linear combinations of basis vectors. For example, in Cartesian coordinates, the standard basis vectors are $e_{x} = ⟨1, 0, 0⟩, e_{y} = ⟨0, 1, 0⟩$ , and $e_{z} = ⟨0, 0, 1⟩$ . Set the coordinate system to work in using the SetCoordinates routine.

>	$v1 := ⟨x, y, z⟩ &colon;$ $v2 := ⟨a, b, c⟩ &colon;$

>	$use VectorCalculus, LinearAlgebra in SetCoordinates (cartesian [x, y, z]) &semi; DotProduct (v1, v2) &semi; BilinearForm (v1, v2) &semi; end use$

${cartesian}_{x, y, z}$

$x a + y b + z c$

$\overset{&conjugate0;}{x} a + \overset{&conjugate0;}{y} b + \overset{&conjugate0;}{z} c$

(7.4)

>	$use VectorCalculus in SetCoordinates (' cartesian') &semi; Gradient (f, [x, y, z]) &semi; Laplacian (f, [x, y, z]) &semi; Laplacian (u (r, θ, φ), cylindrical [r, θ, φ]) &semi; Hessian (f, [x, y, z]) end use$

$cartesian$

$0$

$\frac{\frac{\partial}{\partial r} u (r, θ, φ) + r (\frac{\partial^{2}}{\partial r^{2}} u (r, θ, φ)) + \frac{\frac{\partial^{2}}{\partial θ^{2}} u (r, θ, φ)}{r} + r (\frac{\partial^{2}}{\partial φ^{2}} u (r, θ, φ))}{r}$

$[\begin{array}{c} 0 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 0 \end{array}]$

(7.5)

Making a function out of a vector derivative, in this case, the Hessian matrix computed immediately above.

>	$H := unapply (, x, y, z) &colon;$

>	$H (1, 1, s + t)$

$[\begin{array}{c} 0 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 0 \end{array}]$

(7.6)

In VectorCalculus, a vector field is a different data structure from a vector. Vector fields have their own constructor, VectorField. To evaluate the vector field at a particular vector, use the evalVF routine.

>	$use VectorCalculus in F := VectorField (⟨x^{2}, x z, y^{2} z⟩, cartesian [x, y, z]) &colon; evalVF (F, ⟨3, 3, 3⟩) &semi; Divergence (F) &semi; Curl (F) &semi; Jacobian (F, [x, y, z]) end use$

$[\begin{array}{c} 9 \\ 9 \\ 27 \end{array}]$

$y^{2} + 2 x$

$[\begin{array}{c} 2 x & 0 & 0 \\ z & 0 & x \\ 0 & 2 y z & y^{2} \end{array}]$

(7.7)

VectorCalculus provides far more functionality than what is possible using linalg. For a full overview, see the demonstration The Vector Calculus Package on the Maple Application Center.

Programming Hints

Package use

Both LinearAlgebra and linalg are implemented as Maple packages. Using with to load these packages results in their individual component routines' names becoming available for use directly.

>	$m := matrix (2, 2, [1, 2, 3, 5]) &colon;$

>	$with (linalg) &colon;$

>	$adjoint (m)$

>	$inverse (m)$

$[\begin{array}{r} 5 & - 2 \\ - 3 & 1 \end{array}]$

$[\begin{array}{r} - 5 & 2 \\ 3 & - 1 \end{array}]$

(8.1.1)

>	$M := Matrix (2, 2, [[1, 2], [3, 5]]) &colon;$

>	$with (LinearAlgebra) &colon;$

>	$Adjoint (M)$

>	$MatrixInverse (M)$

The LinearAlgebra and linalg packages are implemented as modules. Since both are Maple packages, they share the following long-form calling syntax in the case that neither package has been loaded. The component routines can always be called directly.

>	$m := matrix (2, 2, [1, 2, 3, 5]) &colon;$

>	$linalg [adjoint] (m)$

$[\begin{array}{r} 5 & - 2 \\ - 3 & 1 \end{array}]$

(8.1.2)

>	$M := Matrix (2, 2, [[1, 2], [3, 5]]) &colon;$

>	$LinearAlgebra [Adjoint] (M)$

Since the LinearAlgebra package is a module, it also offers another long-form syntax for calling a routine directly.

>	$LinearAlgebra :- Adjoint (M)$

Basic arithmetic involving matrix and vector objects, as used by linalg, can be accomplished through use of evalm.

>	$evalm (m + m &* m)$

$[\begin{array}{r} 8 & 14 \\ 21 & 36 \end{array}]$

(8.1.3)

Such arithmetic is available for Matrix and Vector objects, as used by LinearAlgebra, directly.

>	$M + M &period; M$

Use of evalm when performing operations with Matrix and Vector objects is not advised; it introduces unnecessary inefficiency to the operations.

Evaluation

The matrix and vector objects used in the linalg package have last name evaluation. Assignment chains involving these objects are only normally evaluated to the last name in the chain. Here are some examples.

>	$v ≔' v' &colon;$ $u ≔' u' &colon;$

$v ≔ u$

>	$u := vector (2, [1, 2])$

$v := u$

$u := [\begin{array}{c} 1 & 2 \end{array}]$

(8.2.1)

$v$

$u$

>	$eval (u)$

>	$eval (v)$

$u$

$[\begin{array}{c} 1 & 2 \end{array}]$

(8.2.2)

>	$v [1] ≔ 7$

>	$u [2] ≔ 13$

>	$eval (u)$

>	$eval (v)$

$v_{1} := 7$

$u_{2} := 13$

$[\begin{array}{c} 7 & 13 \end{array}]$

(8.2.3)

The Matrix and Vector objects in the LinearAlgebra package do not follow last name evaluation. As a result, you do not need to specify a full evaluation, at the Maple top-level, to display the entries.

>	$V :=' V' &colon;$ $U ≔' U' &colon;$

$V ≔ U$

$V := U$

(8.2.4)

>	$U ≔ Vector (2, [1, 2])$

$V$

$U$

>	$V [1] ≔ 7$

>	$U [2] ≔ 13$

$U$

$V$

$V_{1} := 7$

$U_{2} := 13$

Output objects versus side-effects

Several linalg routines make use of side-effects on names to assign auxiliary results.

Here, QRdecomp has made an assignment to q as a side-effect of the operation that computed r.

>	$r ≔' r' &colon; q ≔' q' &colon;$

>	$m ≔ matrix (2, 2, [1, 2, 3, 5]) &semi;$

>	$r ≔ linalg [QRdecomp] (m,' Q' =' q') &semi;$

>	$eval (q)$

$m := [\begin{array}{r} 1 & 2 \\ 3 & 5 \end{array}]$

$r := [\begin{array}{c} \sqrt{10} & \frac{17}{10} \sqrt{10} \\ 0 & \frac{1}{10} \sqrt{10} \end{array}]$

$[\begin{array}{c} \frac{1}{10} \sqrt{10} & \frac{3}{10} \sqrt{10} \\ \frac{3}{10} \sqrt{10} & - \frac{1}{10} \sqrt{10} \end{array}]$

(8.3.1)

The routines in the LinearAlgebra package use multiple-assignment instead of side-effects in order to assign auxiliary results.

>	$R :=' R' &colon;$ $Q ≔' Q' &colon;$

>	$M ≔ Matrix (2, 2, [[1, 2], [3, 5]]) &semi;$

>	$R, Q ≔ LinearAlgebra [QRDecomposition] (M,' output' = [' R',' Q'])$

	See Also
	Last Name Evaluation, linalg, LinearAlgebra, Matrix, module, multiple assignment, rtable, rtable_eval, Vector, VectorCalculus

Return to Index for Example Worksheets

Download Help Document

Maple

Maple Add-Ons

MapleSim

MapleSim Add-Ons

Systems Engineering

Consulting Services

Maple T.A. and Möbius

Education

Industries

Automotive and Aerospace

Robotics

Machine Design & Industrial Automation

Other

Application Areas

Product Pricing

Purchasing

Institutional Student Licensing

Maplesoft Elite Maintenance (EMP)

Support

Product Training

Online Product Help

Webinars & Events

Publications

Content Hubs

Examples & Applications

Community

About Maplesoft

Media Center

User Community

Contact

Online Help

All Products Maple MapleSim

Maple

Powerful math software that is easy to use

Maple Add-Ons

MapleSim

Advanced System Level Modeling

MapleSim Add-Ons

Systems Engineering

Consulting Services

Maple T.A. and Möbius

Education

Industries

Automotive and Aerospace

Robotics

Machine Design & Industrial Automation

Other

Application Areas

Product Pricing

Purchasing

Institutional Student Licensing

Maplesoft Elite Maintenance (EMP)

Support

Product Training

Online Product Help

Webinars & Events

Publications

Content Hubs

Examples & Applications

Community

About Maplesoft

Media Center

User Community

Contact

Online Help

All Products Maple MapleSim