7.3 Construction

► |  | Math Library

1 | Constants and Elementary Functions
2 | Flonums
3 | Special Functions
4 | Number Theory
5 | Arbitrary-Precision Floating-Point Numbers (Bigfloats)
6 | Arrays
7 | Matrices and Linear Algebra
8 | Statistics Functions
9 | Probability Distributions
10 | Stuff That Doesn’t Belong Anywhere Else

▼ | 7 | Matrices and Linear Algebra

7.1 | Introduction
7.2 | Types, Predicates and Accessors
7.3 | Construction
7.4 | Conversion
7.5 | Entrywise Operations and Arithmetic
7.6 | Polymorphic Operations
7.7 | Basic Operations
7.8 | Inner Product Space Operations
7.9 | Solving Systems of Equations
7.10 | Row-Based Algorithms
7.11 | Orthogonal Algorithms
7.12 | Operator Norms and Comparing Matrices

On this page:

matrix
row-matrix
col-matrix
identity-matrix
make-matrix
build-matrix
diagonal-matrix
block-diagonal-matrix
vandermonde-matrix
for/ matrix:
for*/ matrix:
for/ matrix
for*/ matrix

Racket
top contents ← prev up next →

### 7.3 Construction🔗ℹ

> syntax (matrix [[expr ...+] ...+] maybe-type-ann)
> maybe-type-ann |  | = |  |
> |  | | |  | : type

Like the array form for creating arrays, but does not require #[...] to delimit nested rows, and the result is constrained to be a matrix?.

Examples:

> > (matrix [[1 2 3] [4 5 6]])
> - : #(struct:Array
> (Indexes Index (Boxof Boolean) (-> Void) (-> Indexes Positive-Byte))
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:55:13 prop:custom-write>
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:56:13 prop:equal+hash>
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:54:13 prop:custom-print-quotable>)
> (array #[#[1 2 3] #[4 5 6]])
> > (matrix [[1 2 3] [4 5 6]] : Number)
> - : #(struct:Array
> (Indexes Index (Boxof Boolean) (-> Void) (-> Indexes Number))
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:55:13 prop:custom-write>
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:56:13 prop:equal+hash>
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:54:13 prop:custom-print-quotable>)
> (array #[#[1 2 3] #[4 5 6]])
> > (matrix [[]])
> eval:20:0: matrix: given empty row
> at: ()
> in: (matrix (()))

> syntax (row-matrix [expr ...+] maybe-type-ann)
> maybe-type-ann |  | = |  |
> |  | | |  | : type

Like matrix, but returns a row matrix.

Examples:

> > (row-matrix [1 2 3])
> - : #(struct:Array
> (Indexes Index (Boxof Boolean) (-> Void) (-> Indexes Positive-Byte))
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:55:13 prop:custom-write>
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:56:13 prop:equal+hash>
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:54:13 prop:custom-print-quotable>)
> (array #[#[1 2 3]])
> > (row-matrix [1 2 3] : Number)
> - : #(struct:Array
> (Indexes Index (Boxof Boolean) (-> Void) (-> Indexes Number))
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:55:13 prop:custom-write>
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:56:13 prop:equal+hash>
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:54:13 prop:custom-print-quotable>)
> (array #[#[1 2 3]])
> > (row-matrix [])
> eval:23:0: row-matrix: given empty row
> at: ()
> in: (row-matrix ())

> syntax (col-matrix [expr ...+] maybe-type-ann)
> maybe-type-ann |  | = |  |
> |  | | |  | : type

Like matrix, but returns a column matrix.

Examples:

> > (col-matrix [1 2 3])
> - : #(struct:Array
> (Indexes Index (Boxof Boolean) (-> Void) (-> Indexes Positive-Byte))
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:55:13 prop:custom-write>
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:56:13 prop:equal+hash>
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:54:13 prop:custom-print-quotable>)
> (array #[#[1] #[2] #[3]])
> > (col-matrix [1 2 3] : Number)
> - : #(struct:Array
> (Indexes Index (Boxof Boolean) (-> Void) (-> Indexes Number))
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:55:13 prop:custom-write>
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:56:13 prop:equal+hash>
> #<syntax:/build/racket/src/racket-9.1/share/pkgs/math-lib/math/private/array/typed-array-struct.rkt:54:13 prop:custom-print-quotable>)
> (array #[#[1] #[2] #[3]])
> > (col-matrix [])
> eval:26:0: col-matrix: given empty column
> at: ()
> in: (col-matrix ())

> procedure (identity-matrix n [one zero]) → (Matrix A)
> n : Integer
> one : A = 1
> zero : A = 0

Returns an n×n identity matrix, which has the value one on the diagonal and zero everywhere else. The height/width n must be positive.

Examples:

> > (identity-matrix 3)
> - : (Array (U One Zero))
> (array #[#[1 0 0] #[0 1 0] #[0 0 1]])
> > (identity-matrix 4 1.0+0.0i 0.0+0.0i)
> - : (Array Float-Complex)
> (array
> #[#[1.0+0.0i 0.0+0.0i 0.0+0.0i 0.0+0.0i]
> #[0.0+0.0i 1.0+0.0i 0.0+0.0i 0.0+0.0i]
> #[0.0+0.0i 0.0+0.0i 1.0+0.0i 0.0+0.0i]
> #[0.0+0.0i 0.0+0.0i 0.0+0.0i 1.0+0.0i]])

> procedure (make-matrix m n x) → (Matrix A)
> m : Integer
> n : Integer
> x : A

Returns an m×n matrix filled with the value x; both m and n must be positive. Analogous to make-array (and defined in terms of it).

> procedure (build-matrix m n proc) → (Matrix A)
> m : Integer
> n : Integer
> proc : (Index Index -> A)

Returns an m×n matrix with entries returned by proc; both m and n must be positive. Analogous to build-array (and defined in terms of it).

> procedure (diagonal-matrix xs [zero]) → (Matrix A)
> xs : (Listof A)
> zero : A = 0

Returns a matrix with xs along the diagonal and zero everywhere else. The length of xs must be positive.

Examples:

> > (diagonal-matrix '(1 2 3 4 5 6))
> - : (Array Byte)
> (array
> #[#[1 0 0 0 0 0]
> #[0 2 0 0 0 0]
> #[0 0 3 0 0 0]
> #[0 0 0 4 0 0]
> #[0 0 0 0 5 0]
> #[0 0 0 0 0 6]])
> > (diagonal-matrix '(1.0 2.0 3.0 4.0 5.0) 0.0)
> - : (Array (U Flonum-Positive-Zero Positive-Float-No-NaN))
> (array
> #[#[1.0 0.0 0.0 0.0 0.0]
> #[0.0 2.0 0.0 0.0 0.0]
> #[0.0 0.0 3.0 0.0 0.0]
> #[0.0 0.0 0.0 4.0 0.0]
> #[0.0 0.0 0.0 0.0 5.0]])

> procedure (block-diagonal-matrix Xs [zero]) → (Array A)
> Xs : (Listof (Array A))
> zero : A = 0

Wikipedia: Block-diagonal matrices Returns an array with two-dimensional arrays Xs along the diagonal and zero everywhere else.

Examples:

> > (block-diagonal-matrix (list (matrix [[6 7] [8 9]])
> (diagonal-matrix '(7 5 7))
> (col-matrix [1 2 3])
> (row-matrix [4 5 6])))
> - : #(struct:Array
> (Indexes Index (Boxof Boolean) (-> Void) (-> Indexes Byte))
> #<syntax:.../array/typed-array-struct.rkt:55:13 prop:custom-write>
> #<syntax:.../array/typed-array-struct.rkt:56:13 prop:equal+hash>
> #<syntax:.../array/typed-array-struct.rkt:54:13 prop:custom-print-quotable>)
> (array
> #[#[6 7 0 0 0 0 0 0 0]
> #[8 9 0 0 0 0 0 0 0]
> #[0 0 7 0 0 0 0 0 0]
> #[0 0 0 5 0 0 0 0 0]
> #[0 0 0 0 7 0 0 0 0]
> #[0 0 0 0 0 1 0 0 0]
> #[0 0 0 0 0 2 0 0 0]
> #[0 0 0 0 0 3 0 0 0]
> #[0 0 0 0 0 0 4 5 6]])
> > (block-diagonal-matrix (list (make-matrix 2 2 2.0+3.0i)
> (make-matrix 2 2 5.0+7.0i))
> 0.0+0.0i)
> - : #(struct:Array
> (Indexes Index (Boxof Boolean) (-> Void) (-> Indexes Float-Complex))
> #<syntax:.../array/typed-array-struct.rkt:55:13 prop:custom-write>
> #<syntax:.../array/typed-array-struct.rkt:56:13 prop:equal+hash>
> #<syntax:.../array/typed-array-struct.rkt:54:13 prop:custom-print-quotable>)
> (array
> #[#[2.0+3.0i 2.0+3.0i 0.0+0.0i 0.0+0.0i]
> #[2.0+3.0i 2.0+3.0i 0.0+0.0i 0.0+0.0i]
> #[0.0+0.0i 0.0+0.0i 5.0+7.0i 5.0+7.0i]
> #[0.0+0.0i 0.0+0.0i 5.0+7.0i 5.0+7.0i]])

Empty two-dimensional arrays are valid inputs. They contribute to the resulting array’s shape.

Examples:

> > (block-diagonal-matrix (list (make-array #(2 0) 1)
> (matrix [[6 7] [8 9]])))
> - : #(struct:Array
> (Indexes Index (Boxof Boolean) (-> Void) (-> Indexes Byte))
> #<syntax:.../array/typed-array-struct.rkt:55:13 prop:custom-write>
> #<syntax:.../array/typed-array-struct.rkt:56:13 prop:equal+hash>
> #<syntax:.../array/typed-array-struct.rkt:54:13 prop:custom-print-quotable>)
> (array #[#[0 0] #[0 0] #[6 7] #[8 9]])
> > (block-diagonal-matrix (list (matrix [[6 7] [8 9]])
> (make-array #(2 0) 1)))
> - : #(struct:Array
> (Indexes Index (Boxof Boolean) (-> Void) (-> Indexes Byte))
> #<syntax:.../array/typed-array-struct.rkt:55:13 prop:custom-write>
> #<syntax:.../array/typed-array-struct.rkt:56:13 prop:equal+hash>
> #<syntax:.../array/typed-array-struct.rkt:54:13 prop:custom-print-quotable>)
> (array #[#[6 7] #[8 9] #[0 0] #[0 0]])
> > (block-diagonal-matrix (list (make-array #(0 2) 1)
> (matrix [[6 7] [8 9]])))
> - : #(struct:Array
> (Indexes Index (Boxof Boolean) (-> Void) (-> Indexes Byte))
> #<syntax:.../array/typed-array-struct.rkt:55:13 prop:custom-write>
> #<syntax:.../array/typed-array-struct.rkt:56:13 prop:equal+hash>
> #<syntax:.../array/typed-array-struct.rkt:54:13 prop:custom-print-quotable>)
> (array #[#[0 0 6 7] #[0 0 8 9]])
> > (block-diagonal-matrix (list (matrix [[6 7] [8 9]])
> (make-array #(0 2) 1)))
> - : #(struct:Array
> (Indexes Index (Boxof Boolean) (-> Void) (-> Indexes Byte))
> #<syntax:.../array/typed-array-struct.rkt:55:13 prop:custom-write>
> #<syntax:.../array/typed-array-struct.rkt:56:13 prop:equal+hash>
> #<syntax:.../array/typed-array-struct.rkt:54:13 prop:custom-print-quotable>)
> (array #[#[6 7 0 0] #[8 9 0 0]])
> > (block-diagonal-matrix (list (matrix [[6 7] [8 9]])
> (make-array #(2 0) 1)
> (diagonal-matrix '(7 5 7))
> (make-array #(0 2) 1)
> (col-matrix [1 2 3])
> (row-matrix [4 5 6])))
> - : #(struct:Array
> (Indexes Index (Boxof Boolean) (-> Void) (-> Indexes Byte))
> #<syntax:.../array/typed-array-struct.rkt:55:13 prop:custom-write>
> #<syntax:.../array/typed-array-struct.rkt:56:13 prop:equal+hash>
> #<syntax:.../array/typed-array-struct.rkt:54:13 prop:custom-print-quotable>)
> (array
> #[#[6 7 0 0 0 0 0 0 0 0 0]
> #[8 9 0 0 0 0 0 0 0 0 0]
> #[0 0 0 0 0 0 0 0 0 0 0]
> #[0 0 7 0 0 0 0 0 0 0 0]
> #[0 0 0 5 0 0 0 0 0 0 0]
> #[0 0 0 0 7 0 0 0 0 0 0]
> #[0 0 0 0 0 0 0 1 0 0 0]
> #[0 0 0 0 0 0 0 2 0 0 0]
> #[0 0 0 0 0 0 0 3 0 0 0]
> #[0 0 0 0 0 0 0 0 4 5 6]])
> > (block-diagonal-matrix (list (make-array #(2 0) 1)
> (make-array #(0 3) 1)))
> - : #(struct:Array
> (Indexes Index (Boxof Boolean) (-> Void) (-> Indexes (U One Zero)))
> #<syntax:.../array/typed-array-struct.rkt:55:13 prop:custom-write>
> #<syntax:.../array/typed-array-struct.rkt:56:13 prop:equal+hash>
> #<syntax:.../array/typed-array-struct.rkt:54:13 prop:custom-print-quotable>)
> (array #[#[0 0 0] #[0 0 0]])
> > (block-diagonal-matrix (list (make-array #(0 3) 1)
> (make-array #(2 0) 1)))
> - : #(struct:Array
> (Indexes Index (Boxof Boolean) (-> Void) (-> Indexes (U One Zero)))
> #<syntax:.../array/typed-array-struct.rkt:55:13 prop:custom-write>
> #<syntax:.../array/typed-array-struct.rkt:56:13 prop:equal+hash>
> #<syntax:.../array/typed-array-struct.rkt:54:13 prop:custom-print-quotable>)
> (array #[#[0 0 0] #[0 0 0]])

If Xs is null, the result is an empty array with shape #(0 0).

Example:

> > (block-diagonal-matrix '())
> - : #(struct:Array
> (Indexes Index (Boxof Boolean) (-> Void) (-> Indexes Nothing))
> #<syntax:.../array/typed-array-struct.rkt:55:13 prop:custom-write>
> #<syntax:.../array/typed-array-struct.rkt:56:13 prop:equal+hash>
> #<syntax:.../array/typed-array-struct.rkt:54:13 prop:custom-print-quotable>)
> (array #[])

> procedure (vandermonde-matrix xs n) → (Matrix Number)
> xs : (Listof Number)
> n : Integer

Wikipedia: Vandermonde matrix Returns an m×n Vandermonde matrix, where m = (length xs).

Examples:

> > (vandermonde-matrix '(1 2 3 4) 5)
> - : (Array Real)
> (array #[#[1 1 1 1 1] #[1 2 4 8 16] #[1 3 9 27 81] #[1 4 16 64 256]])
> > (vandermonde-matrix '(5.2 3.4 2.0) 3)
> - : (Array Flonum)
> (array
> #[#[1.0 5.2 27.040000000000003]
> #[1.0 3.4 11.559999999999999]
> #[1.0 2.0 4.0]])

Using a Vandermonde matrix to find a Lagrange polynomial (the polynomial of least degree that passes through a given set of points):

> > (define (lagrange-polynomial xs ys)
> (array->list (matrix-solve (vandermonde-matrix xs (length xs))
> (->col-matrix ys))))
> > (define xs '(-3 0 3))
> > (define ys '(13 3 6))
> > (match-define (list c b a) (lagrange-polynomial xs ys))
> > (plot (list (function (λ (x) (+ c (* b x) (* a x x))) -4 4)
> (points (map list xs ys))))

Note that the above example is in untyped Racket.

This function is defined in terms of array-axis-expand.

> > syntax
> > (for/matrix: m n maybe-fill (for:-clause ...) maybe-type-ann
> > body ...+)
> > syntax
> > (for*/matrix: m n maybe-fill (for:-clause ...) maybe-type-ann
> > body ...+)
> maybe-fill |  | = |  |
> |  | | |  | #:fill fill
> maybe-type-ann |  | = |  |
> |  | | |  | : body-type
> > | m |  | : |  | Integer
> > | n |  | : |  | Integer
> > | fill |  | : |  | body-type

Like for/array: and for*/array:, but for matrices. The only material difference is that the shape m n is required and must be positive.

> > syntax
> > (for/matrix m n maybe-fill (for-clause ...)
> > body ...+)
> > syntax
> > (for*/matrix m n maybe-fill (for-clause ...)
> > body ...+)

Untyped versions of the loop macros.
top contents ← prev up next →