Migrating linalg commands to LinearAlgebra and VectorCalculus

はじめる前に
新機能一覧
Maple ワークシートの作成
Mapleワークシートを共有
Maple ウィンドウのカスタマイズ
Maple システムのカスタマイズ
コネクティビティ
Mathematics
数学
- テンソル解析
- パッケージ
- ファンクションアドバイザ
- ベキ級数
- ベクトル解析
- 不活性関数
- 代数
- 因数分解と方程式解法
- 基本数学
- 基本的な注意事項
- 変分法
- 変換
- 幾何
- 微分代数方程式
- 微分幾何学
- 微分方程式
- 微積分
- 数
- 数値計算
- 数学関数
- 数論
- 最適化
- 特殊関数
- 統計
- 線形代数
  - 例
  - LinearAlgebra パッケージ
  - 行列の不活性コマンド
  - 行列多項式代数
  - 配列、行列、ベクトルのインデックス
  - 線形代数パッケージの概要
  - 線形代数パッケージの詳細
  - OrderBasis コマンド
  - ドット積
  - 座標系の変更
  - 線形代数計算
- 群論
- 評価
- 論理
- 過去のパッケージ
- 金融
- 離散数学
- piecewise examples
- グラフ電卓
- 区分関数
物理
プログラミング
グラフィックス
Student パッケージ
Science and Engineering
科学・エンジニアリング
アプリケーションと例題
リファレンス
システム
MapleSim
MapleSim ツールボックス
MapleSim ヘルプ
Tasks
Toolboxes
エラーメッセージガイド
マニュアル
数学アプリ

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, 1) = 1, (1, 2) = 2, (1, 3) = 3, (2, 1) = 3, (2, 2) = 1, (2, 3) = 2, (3, 1) = 2, (3, 2) = 3, (3, 3) = 1})

B := Matrix(3, 3, {(1, 1) = a, (1, 2) = b, (1, 3) = c, (2, 1) = c, (2, 2) = a, (2, 3) = b, (3, 1) = b, (3, 2) = c, (3, 3) = a})

(2.1.1)

LinearAlgebra

P := Matrix(3, 3, {(1, 1) = 1, (1, 2) = 2, (1, 3) = 3, (2, 1) = 3, (2, 2) = 1, (2, 3) = 2, (3, 1) = 2, (3, 2) = 3, (3, 3) = 1})

Q := Matrix(3, 3, {(1, 1) = a, (1, 2) = b, (1, 3) = c, (2, 1) = c, (2, 2) = a, (2, 3) = b, (3, 1) = b, (3, 2) = c, (3, 3) = a})

w := Vector(3, {(1) = 5.05, (2) = 6.125, (3) = 2.980})

w2 := Vector(8, {(1) = Pi+sqrt(2), (2) = Pi+sqrt(2), (3) = Pi+sqrt(2), (4) = Pi+sqrt(2), (5) = Pi+sqrt(2), (6) = Pi+sqrt(2), (7) = Pi+sqrt(2), (8) = Pi+sqrt(2)})

(2.1.2)

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

Matrix(2, 3, {(1, 1) = x, (1, 2) = y, (1, 3) = z, (2, 1) = a, (2, 2) = b, (2, 3) = c})

(2.1.3)

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, {(1, 1) = 2, (1, 2) = 3, (1, 3) = 4, (2, 1) = 3, (2, 2) = 4, (2, 3) = 5})

n := Matrix(2, 2, {(1, 1) = Pi, (1, 2) = Pi, (2, 1) = Pi, (2, 2) = Pi})

array( 1 .. 2, 1 .. 5, [( 2, 3 ) = (5), ( 1, 2 ) = (3), ( 2, 5 ) = (Pi), ( 2, 4 ) = (Pi), ( 1, 3 ) = (4), ( 1, 1 ) = (2), ( 2, 2 ) = (4), ( 1, 5 ) = (Pi), ( 1, 4 ) = (Pi), ( 2, 1 ) = (3) ] )

(2.2.1)

m := Matrix(3, 2, {(1, 1) = 2, (1, 2) = 3, (2, 1) = 3, (2, 2) = 4, (3, 1) = 4, (3, 2) = 5})

n := Matrix(2, 2, {(1, 1) = Pi, (1, 2) = Pi, (2, 1) = Pi, (2, 2) = Pi})

array( 1 .. 5, 1 .. 2, [( 1, 2 ) = (3), ( 4, 1 ) = (Pi), ( 1, 1 ) = (2), ( 2, 2 ) = (4), ( 5, 2 ) = (Pi), ( 5, 1 ) = (Pi), ( 4, 2 ) = (Pi), ( 2, 1 ) = (3), ( 3, 1 ) = (4), ( 3, 2 ) = (5) ] )

(2.2.2)

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

m := Matrix(2, 3, {(1, 1) = 2, (1, 2) = 3, (1, 3) = 4, (2, 1) = 3, (2, 2) = 4, (2, 3) = 5})

n := Matrix(2, 2, {(1, 1) = Pi, (1, 2) = Pi, (2, 1) = Pi, (2, 2) = Pi})

Matrix(2, 5, {(1, 1) = 2, (1, 2) = 3, (1, 3) = 4, (1, 4) = Pi, (1, 5) = Pi, (2, 1) = 3, (2, 2) = 4, (2, 3) = 5, (2, 4) = Pi, (2, 5) = Pi})

(2.2.3)

m := Matrix(3, 2, {(1, 1) = 2, (1, 2) = 3, (2, 1) = 3, (2, 2) = 4, (3, 1) = 4, (3, 2) = 5})

n := Matrix(2, 2, {(1, 1) = Pi, (1, 2) = Pi, (2, 1) = Pi, (2, 2) = Pi})

Matrix(2, 2, {(1, 1) = Pi, (1, 2) = Pi, (2, 1) = Pi, (2, 2) = Pi})

Matrix(5, 2, {(1, 1) = 2, (1, 2) = 3, (2, 1) = 3, (2, 2) = 4, (3, 1) = 4, (3, 2) = 5, (4, 1) = Pi, (4, 2) = Pi, (5, 1) = Pi, (5, 2) = Pi})

(2.2.4)

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, proc (i, j) options operator, arrow; abs(i-j) end proc); n := matrix(3, 3, proc (i, j) options operator, arrow; abs(i-j)^2 end proc); r := matrix(3, 3, 0); linalg[blockmatrix](2, 3, [m, n, r, n, r, m])

(2.2.5)

M := Matrix(3, 3, proc (i, j) options operator, arrow; abs(i-j) end proc); N := Matrix(3, 3, proc (i, j) options operator, arrow; abs(i-j)^2 end proc); R := Matrix(3, 3, 0); Matrix([[M, N, R], [N, R, M]])

(2.2.6)

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

m := Matrix(3, 3, {(1, 1) = 0, (1, 2) = -1, (1, 3) = -2, (2, 1) = 1, (2, 2) = 0, (2, 3) = -1, (3, 1) = 2, (3, 2) = 1, (3, 3) = 0})

Matrix(4, 7, {(1, 1) = 0, (1, 2) = -1, (1, 3) = -2, (1, 4) = Pi, (1, 5) = Pi, (1, 6) = Pi, (1, 7) = Pi, (2, 1) = 1, (2, 2) = 0, (2, 3) = -1, (2, 4) = Pi, (2, 5) = Pi, (2, 6) = Pi, (2, 7) = Pi, (3, 1) = 2, (3, 2) = 1, (3, 3) = 0, (3, 4) = Pi, (3, 5) = Pi, (3, 6) = Pi, (3, 7) = Pi, (4, 1) = Pi, (4, 2) = Pi, (4, 3) = Pi, (4, 4) = Pi, (4, 5) = Pi, (4, 6) = Pi, (4, 7) = Pi})

M := Matrix(3, 3, {(1, 1) = 0, (1, 2) = -1, (1, 3) = -2, (2, 1) = 1, (2, 2) = 0, (2, 3) = -1, (3, 1) = 2, (3, 2) = 1, (3, 3) = 0})

(2.2.7)

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

(2.2.8)

(2.2.9)

Specially structured matrices and vectors

linalg

Matrix(3, 3, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = 1})

Matrix(3, 3, {(1, 1) = `?`[1, 1], (1, 2) = 0, (1, 3) = 0, (2, 1) = 0, (2, 2) = `?`[2, 2], (2, 3) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = `?`[3, 3]})

Matrix(3, 3, {(1, 1) = 1, (1, 2) = 1/2, (1, 3) = 1/3, (2, 1) = 1/2, (2, 2) = 1/3, (2, 3) = 1/4, (3, 1) = 1/3, (3, 2) = 1/4, (3, 3) = 1/5})

array( 1 .. 4, 1 .. 4, [( 4, 1 ) = (1), ( 2, 3 ) = (4), ( 1, 2 ) = (1), ( 1, 3 ) = (1), ( 4, 2 ) = (4), ( 1, 1 ) = (1), ( 2, 2 ) = (2), ( 3, 3 ) = (9), ( 3, 4 ) = (27), ( 2, 4 ) = (8), ( 4, 3 ) = (16), ( 4, 4 ) = (64), ( 1, 4 ) = (1), ( 2, 1 ) = (1), ( 3, 1 ) = (1), ( 3, 2 ) = (3) ] )

(2.3.1)

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

Matrix(3, 3, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = 1})

Matrix(3, 3, {(1, 1) = a, (1, 2) = 0, (1, 3) = 0, (2, 1) = 0, (2, 2) = b, (2, 3) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = c})

Matrix(3, 3, {(1, 1) = 1, (1, 2) = 1/2, (1, 3) = 1/3, (2, 1) = 1/2, (2, 2) = 1/3, (2, 3) = 1/4, (3, 1) = 1/3, (3, 2) = 1/4, (3, 3) = 1/5})

Matrix(4, 4, {(1, 1) = 1, (1, 2) = 1, (1, 3) = 1, (1, 4) = 1, (2, 1) = 1, (2, 2) = 2, (2, 3) = 4, (2, 4) = 8, (3, 1) = 1, (3, 2) = 3, (3, 3) = 9, (3, 4) = 27, (4, 1) = 1, (4, 2) = 4, (4, 3) = 16, (4, 4) = 64})

(2.3.2)

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.

(2.3.3)

(2.3.4)

Here is a 100x100 band Matrix.

(2.3.5)

(2.3.6)

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

Matrix(3, 3, {(1, 1) = 1+a, (1, 2) = 2+b, (1, 3) = 3+c, (2, 1) = 3+c, (2, 2) = 1+a, (2, 3) = 2+b, (3, 1) = 2+b, (3, 2) = 3+c, (3, 3) = 1+a})

Matrix(3, 3, {(1, 1) = 1-a, (1, 2) = 2-b, (1, 3) = 3-c, (2, 1) = 3-c, (2, 2) = 1-a, (2, 3) = 2-b, (3, 1) = 2-b, (3, 2) = 3-c, (3, 3) = 1-a})

Matrix(3, 3, {(1, 1) = a+2*c+3*b, (1, 2) = b+2*a+3*c, (1, 3) = c+2*b+3*a, (2, 1) = c+2*b+3*a, (2, 2) = a+2*c+3*b, (2, 3) = b+2*a+3*c, (3, 1) = b+2*a+3*c, (3, 2) = c+2*b+3*a, (3, 3) = a+2*c+3*b})

array( 1 .. 3, 1 .. 3, [( 2, 3 ) = (5.4), ( 1, 2 ) = (5.4), ( 1, 3 ) = (8.1), ( 1, 1 ) = (2.7), ( 2, 2 ) = (2.7), ( 3, 3 ) = (2.7), ( 2, 1 ) = (8.1), ( 3, 1 ) = (5.4), ( 3, 2 ) = (8.1) ] )

(3.1.1)

LinearAlgebra

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

Matrix(3, 3, {(1, 1) = 1+a, (1, 2) = 2+b, (1, 3) = 3+c, (2, 1) = 3+c, (2, 2) = 1+a, (2, 3) = 2+b, (3, 1) = 2+b, (3, 2) = 3+c, (3, 3) = 1+a})

Matrix(3, 3, {(1, 1) = 9-18*a, (1, 2) = 18-18*b, (1, 3) = 27-18*c, (2, 1) = 27-18*c, (2, 2) = 9-18*a, (2, 3) = 18-18*b, (3, 1) = 18-18*b, (3, 2) = 27-18*c, (3, 3) = 9-18*a})

Matrix(3, 3, {(1, 1) = a+2*c+3*b, (1, 2) = b+2*a+3*c, (1, 3) = c+2*b+3*a, (2, 1) = c+2*b+3*a, (2, 2) = a+2*c+3*b, (2, 3) = b+2*a+3*c, (3, 1) = b+2*a+3*c, (3, 2) = c+2*b+3*a, (3, 3) = a+2*c+3*b})

Vector(3, {(1) = 26.2400000000000020, (2) = 27.2349999999999995, (3) = 31.4550000000000020})

Matrix(3, 3, {(1, 1) = 2.70000000000000016, (1, 2) = 5.40000000000000034, (1, 3) = 8.10000000000000142, (2, 1) = 8.10000000000000142, (2, 2) = 2.70000000000000016, (2, 3) = 5.40000000000000034, (3, 1) = 5.40000000000000034, (3, 2) = 8.10000000000000142, (3, 3) = 2.70000000000000016})

$Matrix(3, 3, {(1, 1) = a^2+2*b*c, (1, 2) = 2*a*b+c^2, (1, 3) = 2*a*c+b^2, (2, 1) = 2*a*c+b^2, (2, 2) = a^2+2*b*c, (2, 3) = 2*a*b+c^2, (3, 1) = 2*a*b+c^2, (3, 2) = 2*a*c+b^2, (3, 3) = a^2+2*b*c})$

(3.1.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.

Matrix(3, 3, {(1, 1) = 1+a, (1, 2) = 2+b, (1, 3) = 3+c, (2, 1) = 3+c, (2, 2) = 1+a, (2, 3) = 2+b, (3, 1) = 2+b, (3, 2) = 3+c, (3, 3) = 1+a})

Matrix(3, 3, {(1, 1) = 9*a-18, (1, 2) = 9*b-36, (1, 3) = 9*c-54, (2, 1) = 9*c-54, (2, 2) = 9*a-18, (2, 3) = 9*b-36, (3, 1) = 9*b-36, (3, 2) = 9*c-54, (3, 3) = 9*a-18})

Matrix(3, 3, {(1, 1) = a+2*c+3*b, (1, 2) = b+2*a+3*c, (1, 3) = c+2*b+3*a, (2, 1) = c+2*b+3*a, (2, 2) = a+2*c+3*b, (2, 3) = b+2*a+3*c, (3, 1) = b+2*a+3*c, (3, 2) = c+2*b+3*a, (3, 3) = a+2*c+3*b})

Vector(3, {(1) = 26.2400000000000020, (2) = 27.2349999999999995, (3) = 31.4550000000000020})

(3.1.3)

Unary operations and matrix properties

linalg

Matrix(3, 3, {(1, 1) = 1, (1, 2) = 3, (1, 3) = 2, (2, 1) = 2, (2, 2) = 1, (2, 3) = 3, (3, 1) = 3, (3, 2) = 2, (3, 3) = 1})

Matrix(3, 3, {(1, 1) = -5/18, (1, 2) = 7/18, (1, 3) = 1/18, (2, 1) = 1/18, (2, 2) = -5/18, (2, 3) = 7/18, (3, 1) = 7/18, (3, 2) = 1/18, (3, 3) = -5/18})

[-3/2+(1/2*I)*sqrt(3), 1, {Vector[row](3, {(1) = -1/2+((1/2)*I)*sqrt(3), (2) = 1, (3) = -1/2-((1/2)*I)*sqrt(3)})}], [-3/2-(1/2*I)*sqrt(3), 1, {Vector[row](3, {(1) = -1/2-((1/2)*I)*sqrt(3), (2) = 1, (3) = -1/2+((1/2)*I)*sqrt(3)})}], [6, 1, {Vector[row](3, {(1) = 1, (2) = 1, (3) = 1})}]

{array( 1 .. 2, [( 1 ) = (-b/a), ( 2 ) = (1) ] )}

(3.2.1)

Note that computes the same result as .

array( 1 .. 3, [( 1 ) = (x/(abs(x)^2+abs(y)^2+abs(z)^2)^(1/2)), ( 2 ) = (y/(abs(x)^2+abs(y)^2+abs(z)^2)^(1/2)), ( 3 ) = (z/(abs(x)^2+abs(y)^2+abs(z)^2)^(1/2)) ] )

arccos((x*a+y*b+z*c)/((x^2+y^2+z^2)^(1/2)*(a^2+b^2+c^2)^(1/2)))

(3.2.2)

LinearAlgebra

These operations and others are also available through the context menus. To use them, right-click (COMMAND-click on Macintosh) a matrix and select the desired operation from the menu that appears.

Matrix(3, 3, {(1, 1) = 1, (1, 2) = 3, (1, 3) = 2, (2, 1) = 2, (2, 2) = 1, (2, 3) = 3, (3, 1) = 3, (3, 2) = 2, (3, 3) = 1})

Matrix(3, 3, {(1, 1) = -5/18, (1, 2) = 7/18, (1, 3) = 1/18, (2, 1) = 1/18, (2, 2) = -5/18, (2, 3) = 7/18, (3, 1) = 7/18, (3, 2) = 1/18, (3, 3) = -5/18})

Vector(3, {(1) = 6, (2) = -3/2+((1/2)*I)*sqrt(3), (3) = -3/2-((1/2)*I)*sqrt(3)})

{Vector(2, {(1) = -b/a, (2) = 1})}

$Vector(3, {(1) = a/sqrt(abs(a)^2+abs(b)^2+abs(c)^2), (2) = b/sqrt(abs(a)^2+abs(b)^2+abs(c)^2), (3) = c/sqrt(abs(a)^2+abs(b)^2+abs(c)^2)})$

arccos((conjugate(a)*d+conjugate(b)*e+conjugate(c)*f)/((abs(a)^2+abs(b)^2+abs(c)^2)^(1/2)*(abs(d)^2+abs(e)^2+abs(f)^2)^(1/2)))

(3.2.3)

Row and Column Operations

Matrix(3, 3, {(1, 1) = a, (1, 2) = b, (1, 3) = c, (2, 1) = c, (2, 2) = a, (2, 3) = b, (3, 1) = b, (3, 2) = c, (3, 3) = a})

Matrix(3, 2, {(1, 1) = a, (1, 2) = c, (2, 1) = c, (2, 2) = b, (3, 1) = b, (3, 2) = a})

Matrix(3, 3, {(1, 1) = b, (1, 2) = c, (1, 3) = a, (2, 1) = c, (2, 2) = a, (2, 3) = b, (3, 1) = a, (3, 2) = b, (3, 3) = c})

Matrix(3, 3, {(1, 1) = c, (1, 2) = b, (1, 3) = a, (2, 1) = b, (2, 2) = a, (2, 3) = c, (3, 1) = a, (3, 2) = c, (3, 3) = b})

Matrix(3, 3, {(1, 1) = s*a, (1, 2) = s*b, (1, 3) = s*c, (2, 1) = c, (2, 2) = a, (2, 3) = b, (3, 1) = b, (3, 2) = c, (3, 3) = a})

array( 1 .. 3, 1 .. 3, [( 2, 3 ) = (b), ( 1, 2 ) = (b), ( 1, 3 ) = (c), ( 1, 1 ) = (s*a), ( 2, 2 ) = (a), ( 3, 3 ) = (a), ( 2, 1 ) = (s*c), ( 3, 1 ) = (s*b), ( 3, 2 ) = (c) ] )

(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.

LinearAlgebra:-ColumnDimension(P); 1; LinearAlgebra:-RowDimension(P); 1; LinearAlgebra:-Dimension(P); 1; LinearAlgebra:-Dimension(w); 1; LinearAlgebra:-Column(P, 2); 1; LinearAlgebra:-Row(P, 2); 1; LinearAlgebra:-DeleteColumn(P, 2 .. 2)

Matrix(3, 2, {(1, 1) = 1, (1, 2) = 3, (2, 1) = 3, (2, 2) = 2, (3, 1) = 2, (3, 2) = 1})

(4.2)

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.

LinearAlgebra:-RowOperation(Q, 1, s); 1; LinearAlgebra:-RowOperation(Q, [1, 3]); 1; LinearAlgebra:-RowOperation(Q, [1, 3], -7, inplace = true)

Matrix(3, 3, {(1, 1) = s*a, (1, 2) = s*b, (1, 3) = s*c, (2, 1) = c, (2, 2) = a, (2, 3) = b, (3, 1) = b, (3, 2) = c, (3, 3) = a})

Matrix(3, 3, {(1, 1) = b, (1, 2) = c, (1, 3) = a, (2, 1) = c, (2, 2) = a, (2, 3) = b, (3, 1) = a, (3, 2) = b, (3, 3) = c})

Matrix(3, 3, {(1, 1) = a-7*b, (1, 2) = b-7*c, (1, 3) = c-7*a, (2, 1) = c, (2, 2) = a, (2, 3) = b, (3, 1) = b, (3, 2) = c, (3, 3) = a})

(4.3)

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

M := Matrix(3, 3, {(1, 1) = 1, (1, 2) = 2, (1, 3) = 3, (2, 1) = -4, (2, 2) = -5, (2, 3) = -6, (3, 1) = 7, (3, 2) = 8, (3, 3) = 9})

(4.4)

Matrix(3, 3, {(1, 1) = -4, (1, 2) = -5, (1, 3) = -6, (2, 1) = -4, (2, 2) = -5, (2, 3) = -6, (3, 1) = 7, (3, 2) = 8, (3, 3) = 9})

(4.5)

Matrix(3, 3, {(1, 1) = -4, (1, 2) = -5, (1, 3) = -6, (2, 1) = -4, (2, 2) = -5, (2, 3) = -6, (3, 1) = -8, (3, 2) = -10, (3, 3) = -12})

(4.6)

M[2 .. 3, 2 .. 3] := Matrix(2, 2, {(1, 1) = Pi, (1, 2) = Pi, (2, 1) = sin(x), (2, 2) = cos(y)})

Matrix(3, 3, {(1, 1) = -4, (1, 2) = -5, (1, 3) = -6, (2, 1) = -4, (2, 2) = Pi, (2, 3) = Pi, (3, 1) = -8, (3, 2) = sin(x), (3, 3) = cos(y)})

(4.7)

Solving Systems of Linear Equations

linalg

(5.1)

Matrix(3, 3, {(1, 1) = 1, (1, 2) = 2, (1, 3) = 3, (2, 1) = 2, (2, 2) = 3, (2, 3) = 1, (3, 1) = 3, (3, 2) = 1, (3, 3) = 2})

array( 1 .. 3, 1 .. 4, [( 2, 3 ) = (1), ( 1, 2 ) = (2), ( 1, 3 ) = (3), ( 1, 1 ) = (1), ( 2, 2 ) = (3), ( 3, 3 ) = (2), ( 3, 4 ) = (6.125), ( 2, 4 ) = (2.980), ( 1, 4 ) = (5.05), ( 2, 1 ) = (2), ( 3, 1 ) = (3), ( 3, 2 ) = (1) ] )

(5.2)

array( 1 .. 3, 1 .. 3, [( 2, 3 ) = ((7/18)*a-(5/18)*b+(1/18)*c), ( 1, 2 ) = ((7/18)*a-(5/18)*b+(1/18)*c), ( 1, 3 ) = (-(5/18)*c+(7/18)*b+(1/18)*a), ( 1, 1 ) = ((1/18)*b+(7/18)*c-(5/18)*a), ( 2, 2 ) = ((1/18)*b+(7/18)*c-(5/18)*a), ( 3, 3 ) = ((1/18)*b+(7/18)*c-(5/18)*a), ( 2, 1 ) = (-(5/18)*c+(7/18)*b+(1/18)*a), ( 3, 1 ) = ((7/18)*a-(5/18)*b+(1/18)*c), ( 3, 2 ) = (-(5/18)*c+(7/18)*b+(1/18)*a) ] )

(5.3)

LinearAlgebra

(5.4)

Matrix(3, 3, {(1, 1) = 1, (1, 2) = 2, (1, 3) = 3, (2, 1) = 3, (2, 2) = 1, (2, 3) = 2, (3, 1) = 2, (3, 2) = 3, (3, 3) = 1}), Vector(3, {(1) = 5.05, (2) = 6.125, (3) = 2.980})

Matrix(3, 4, {(1, 1) = 1, (1, 2) = 2, (1, 3) = 3, (1, 4) = 5.05, (2, 1) = 3, (2, 2) = 1, (2, 3) = 2, (2, 4) = 6.125, (3, 1) = 2, (3, 2) = 3, (3, 3) = 1, (3, 4) = 2.980})

(5.5)

Vector(3, {(1) = 1.14472222222222242, (2) = -.261944444444444369, (3) = 1.47638888888888876})

Matrix(3, 3, {(1, 1) = -(5/18)*a+2*b+(7/18)*c, (1, 2) = -(5/18)*b+2*c+(7/18)*a, (1, 3) = -(5/18)*c+2*a+(7/18)*b, (2, 1) = -(5/18)*c+(1/18)*a, (2, 2) = -(5/18)*a+(1/18)*b, (2, 3) = -(5/18)*b+(1/18)*c, (3, 1) = -3*b+(7/18)*a+(1/18)*c, (3, 2) = -3*c+(7/18)*b+(1/18)*a, (3, 3) = -3*a+(7/18)*c+(1/18)*b})

(5.6)

Matrix Reductions and Decompositions

linalg

array( 1 .. 3, 1 .. 4, [( 2, 3 ) = (2), ( 1, 2 ) = (2), ( 1, 3 ) = (3), ( 1, 1 ) = (1), ( 2, 2 ) = (1), ( 3, 3 ) = (1), ( 3, 4 ) = (1), ( 2, 4 ) = (2), ( 1, 4 ) = (1), ( 2, 1 ) = (3), ( 3, 1 ) = (2), ( 3, 2 ) = (3) ] )

(6.1)

Matrix(3, 4, {(1, 1) = 1, (1, 2) = 2, (1, 3) = 3, (1, 4) = 1, (2, 1) = 0, (2, 2) = -5, (2, 3) = -7, (2, 4) = -1, (3, 1) = 0, (3, 2) = 0, (3, 3) = -18/5, (3, 4) = -4/5})

Matrix(3, 4, {(1, 1) = 1, (1, 2) = 2, (1, 3) = 3, (1, 4) = 1, (2, 1) = 0, (2, 2) = -5, (2, 3) = -7, (2, 4) = -1, (3, 1) = 0, (3, 2) = 0, (3, 3) = 18, (3, 4) = 4})

Matrix(3, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) = 5/9, (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (2, 4) = -1/9, (3, 1) = 0, (3, 2) = 0, (3, 3) = 1, (3, 4) = 2/9})

Matrix(3, 3, {(1, 1) = 0, (1, 2) = 0, (1, 3) = 18, (2, 1) = 1, (2, 2) = 0, (2, 3) = 15, (3, 1) = 0, (3, 2) = 1, (3, 3) = 3})

array( 1 .. 3, 1 .. 3, [( 2, 3 ) = (0), ( 1, 2 ) = (0), ( 1, 3 ) = (0), ( 1, 1 ) = (6), ( 2, 2 ) = (-3/2-((1/2)*I)*3^(1/2)), ( 3, 3 ) = (-3/2+((1/2)*I)*3^(1/2)), ( 2, 1 ) = (0), ( 3, 1 ) = (0), ( 3, 2 ) = (0) ] )

(6.2)

array( 1 .. 3, 1 .. 3, [( 2, 3 ) = (11), ( 1, 2 ) = (11), ( 1, 3 ) = (11), ( 1, 1 ) = (14), ( 2, 2 ) = (14), ( 3, 3 ) = (14), ( 2, 1 ) = (11), ( 3, 1 ) = (11), ( 3, 2 ) = (11) ] )

(6.3)

array( 1 .. 3, 1 .. 3, [( 2, 3 ) = (0), ( 1, 2 ) = (0), ( 1, 3 ) = (0), ( 1, 1 ) = (14^(1/2)), ( 2, 2 ) = ((5/14)*42^(1/2)), ( 3, 3 ) = ((6/5)*3^(1/2)), ( 2, 1 ) = ((11/14)*14^(1/2)), ( 3, 1 ) = ((11/14)*14^(1/2)), ( 3, 2 ) = ((11/70)*42^(1/2)) ] )

(6.4)

Matrix(3, 3, {(1, 1) = 1, (1, 2) = 2, (1, 3) = 3, (2, 1) = 0, (2, 2) = -5, (2, 3) = -7, (3, 1) = 0, (3, 2) = 0, (3, 3) = -18/5})

array( 1 .. 3, 1 .. 3, [( 2, 3 ) = ((11/70)*42^(1/2)), ( 1, 2 ) = ((11/14)*14^(1/2)), ( 1, 3 ) = ((11/14)*14^(1/2)), ( 1, 1 ) = (14^(1/2)), ( 2, 2 ) = ((5/14)*42^(1/2)), ( 3, 3 ) = ((6/5)*3^(1/2)), ( 2, 1 ) = (0), ( 3, 1 ) = (0), ( 3, 2 ) = (0) ] )

(6.5)

LinearAlgebra

Pv := `<|>`(P, `<,>`(1, 2, 1)); 1; LinearAlgebra:-GaussianElimination(Pv); 1; LinearAlgebra:-LUDecomposition(Pv, method = FractionFree); 1; LinearAlgebra:-ReducedRowEchelonForm(Pv); 1; LinearAlgebra:-FrobeniusForm(P); 1; LinearAlgebra:-JordanForm(P); 1; LinearAlgebra:-HessenbergForm(P)

Pv := Matrix(3, 4, {(1, 1) = 1, (1, 2) = 2, (1, 3) = 3, (1, 4) = 1, (2, 1) = 3, (2, 2) = 1, (2, 3) = 2, (2, 4) = 2, (3, 1) = 2, (3, 2) = 3, (3, 3) = 1, (3, 4) = 1})

Matrix(3, 4, {(1, 1) = 1, (1, 2) = 2, (1, 3) = 3, (1, 4) = 1, (2, 1) = 0, (2, 2) = -5, (2, 3) = -7, (2, 4) = -1, (3, 1) = 0, (3, 2) = 0, (3, 3) = -18/5, (3, 4) = -4/5})

Matrix(3, 4, {(1, 1) = 1, (1, 2) = 0, (1, 3) = 0, (1, 4) = 5/9, (2, 1) = 0, (2, 2) = 1, (2, 3) = 0, (2, 4) = -1/9, (3, 1) = 0, (3, 2) = 0, (3, 3) = 1, (3, 4) = 2/9})

Matrix(3, 3, {(1, 1) = 0, (1, 2) = 0, (1, 3) = 18, (2, 1) = 1, (2, 2) = 0, (2, 3) = 15, (3, 1) = 0, (3, 2) = 1, (3, 3) = 3})

Matrix(3, 3, {(1, 1) = 6, (1, 2) = 0, (1, 3) = 0, (2, 1) = 0, (2, 2) = -3/2-((1/2)*I)*sqrt(3), (2, 3) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = -3/2+((1/2)*I)*sqrt(3)})

Matrix(3, 3, {(1, 1) = 1., (1, 2) = -3.32820117735137444, (1, 3) = 1.38675049056307298, (2, 1) = -3.60555127546398957, (2, 2) = 3.30769230769230660, (2, 3) = -.461538461538461897, (3, 1) = 0., (3, 2) = -1.46153846153846212, (3, 3) = -1.30769230769230771})

(6.6)

PTP := LinearAlgebra:-Transpose(P).P; 1; LinearAlgebra:-IsDefinite(PTP); 1; LinearAlgebra:-LUDecomposition(PTP, method = Cholesky); 1; P1, P2 := LinearAlgebra:-QRDecomposition(P)

PTP := Matrix(3, 3, {(1, 1) = 14, (1, 2) = 11, (1, 3) = 11, (2, 1) = 11, (2, 2) = 14, (2, 3) = 11, (3, 1) = 11, (3, 2) = 11, (3, 3) = 14})

Matrix(3, 3, {(1, 1) = sqrt(14), (1, 2) = 0, (1, 3) = 0, (2, 1) = (11/14)*sqrt(14), (2, 2) = (5/14)*sqrt(42), (2, 3) = 0, (3, 1) = (11/14)*sqrt(14), (3, 2) = (11/70)*sqrt(42), (3, 3) = (6/5)*sqrt(3)})

(6.7)

Vector Calculus

linalg

(7.1)

$Vector[row](3, {(1) = 2*x+z, (2) = -2*y*z, (3) = x-y^2})$

(diff(g(r, theta, phi), r)+r*(diff(g(r, theta, phi), r, r))+(diff(g(r, theta, phi), theta, theta))/r+r*(diff(g(r, theta, phi), phi, phi)))/r

array( 1 .. 3, 1 .. 3, [( 3, 3 ) = (0), ( 3, 1 ) = (1), ( 1, 3 ) = (1), ( 1, 1 ) = (2), ( 2, 2 ) = (-2*z), ( 2, 3 ) = (-2*y), ( 2, 1 ) = (0), ( 1, 2 ) = (0), ( 3, 2 ) = (-2*y) ] )

(7.2)

array( 1 .. 3, 1 .. 2, [( 3, 1 ) = (0), ( 1, 1 ) = (2*x), ( 2, 2 ) = (0), ( 2, 1 ) = (z), ( 1, 2 ) = (0), ( 3, 2 ) = (2*y*z) ] )

(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 , and . Set the coordinate system to work in using the SetCoordinates routine.

VectorCalculus:-SetCoordinates(cartesian[x, y, z]); 1; VectorCalculus:-DotProduct(v1, v2); 1; LinearAlgebra:-BilinearForm(v1, v2)

(7.4)

VectorCalculus:-SetCoordinates('cartesian'); 1; VectorCalculus:-Gradient(f, [x, y, z]); 1; VectorCalculus:-Laplacian(f, [x, y, z]); 1; VectorCalculus:-Laplacian(u(r, theta, phi), cylindrical[r, theta, phi]); 1; VectorCalculus:-Hessian(f, [x, y, z])

(diff(u(r, theta, phi), r)+r*(diff(u(r, theta, phi), r, r))+(diff(u(r, theta, phi), theta, theta))/r+r*(diff(u(r, theta, phi), phi, phi)))/r

Matrix(%id = 136546900)

(7.5)

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

Matrix(%id = 136566404)

(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.

F := VectorCalculus:-VectorField(VectorCalculus:-`<,>`(x^2, VectorCalculus:-`*`(x, z), VectorCalculus:-`*`(y^2, z)), cartesian[x, y, z]); 1; VectorCalculus:-evalVF(F, VectorCalculus:-`<,>`(3, 3, 3)); 1; VectorCalculus:-Divergence(F); 1; VectorCalculus:-Curl(F); 1; VectorCalculus:-Jacobian(F, [x, y, z])

Matrix(%id = 136615048)

(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.

Matrix(2, 2, {(1, 1) = 5, (1, 2) = -2, (2, 1) = -3, (2, 2) = 1})

array( 1 .. 2, 1 .. 2, [( 1, 1 ) = (-5), ( 2, 2 ) = (-1), ( 2, 1 ) = (3), ( 1, 2 ) = (2) ] )

(8.1.1)

Matrix(2, 2, {(1, 1) = 5, (1, 2) = -2, (2, 1) = -3, (2, 2) = 1})

Matrix(%id = 136620512)

(8.1.2)

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.

array( 1 .. 2, 1 .. 2, [( 1, 1 ) = (5), ( 2, 2 ) = (1), ( 2, 1 ) = (-3), ( 1, 2 ) = (-2) ] )

(8.1.3)

Matrix(%id = 136624552)

(8.1.4)

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

Matrix(%id = 136628172)

(8.1.5)

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

array( 1 .. 2, 1 .. 2, [( 1, 1 ) = (8), ( 2, 2 ) = (36), ( 2, 1 ) = (21), ( 1, 2 ) = (14) ] )

(8.1.6)

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

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

Matrix(%id = 136631104)

(8.1.7)

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.

(8.2.1)

(8.2.2)

(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.

(8.2.4)

U := Vector(2, {(1) = 1, (2) = 2})

(8.2.5)

(8.2.6)

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.

m := Matrix(2, 2, {(1, 1) = 1, (1, 2) = 2, (2, 1) = 3, (2, 2) = 5})

r := Matrix(2, 2, {(1, 1) = sqrt(10), (1, 2) = (17/10)*sqrt(10), (2, 1) = 0, (2, 2) = (1/10)*sqrt(10)})

array( 1 .. 2, 1 .. 2, [( 1, 1 ) = ((1/10)*10^(1/2)), ( 2, 2 ) = (-(1/10)*10^(1/2)), ( 2, 1 ) = ((3/10)*10^(1/2)), ( 1, 2 ) = ((3/10)*10^(1/2)) ] )

(8.3.1)

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

M := Matrix(2, 2, {(1, 1) = 1, (1, 2) = 2, (2, 1) = 3, (2, 2) = 5})

R, Q := Matrix(2, 2, {(1, 1) = sqrt(10), (1, 2) = (17/10)*sqrt(10), (2, 1) = 0, (2, 2) = (1/10)*sqrt(10)}), Matrix(2, 2, {(1, 1) = (1/10)*sqrt(10), (1, 2) = (3/10)*sqrt(10), (2, 1) = (3/10)*sqrt(10), (2, 2) = -(1/10)*sqrt(10)})