The array-operations Reference Manual

3.1.1 array-operations/array-operations.asd

Source

array-operations.asd.

Parent Component

array-operations (system).

ASDF Systems

• array-operations.
• array-operations/all.
• array-operations/generic.
• array-operations/reducing.
• array-operations/matrices.
• array-operations/creating.
• array-operations/utilities.
• array-operations/indexing.
• array-operations/displacing.
• array-operations/transforming.
• array-operations/stacking.

---

3.1.2 array-operations/all/file-type.lisp

Source

array-operations.asd.

Parent Component

array-operations/all (system).

Packages

array-operations/all.

---

3.1.3 array-operations/generic/file-type.lisp

Source

array-operations.asd.

Parent Component

array-operations/generic (system).

Packages

array-operations/generic.

Public Interface

• &dims (macro).
• as-array (generic function).
• dim (generic function).
• dims (generic function).
• element-type (generic function).
• ncol (generic function).
• nrow (generic function).
• rank (generic function).
• size (generic function).

---

3.1.4 array-operations/reducing/file-type.lisp

Source

array-operations.asd.

Parent Component

array-operations/reducing (system).

Packages

array-operations/reducing.

Public Interface

• argmax (function).
• argmin (function).
• best (function).
• most (function).
• vectorize-reduce (macro).

---

3.1.5 array-operations/matrices/file-type.lisp

Source

array-operations.asd.

Parent Component

array-operations/matrices (system).

Packages

array-operations/matrices.

Public Interface

• array-matrix (type).
• matrixp (function).
• square-matrix-p (function).

---

3.1.6 array-operations/creating/file-type.lisp

Source

array-operations.asd.

Parent Component

array-operations/creating (system).

Packages

array-operations/creating.

Public Interface

• fill! (function).
• generate (function).
• generate* (function).
• linspace (function).
• linspace! (function).
• linspace* (function).
• ones (function).
• ones! (function).
• ones* (function).
• rand (function).
• rand! (function).
• rand* (function).
• randn (function).
• randn! (function).
• randn* (function).
• similar-array (function).
• zeros (function).
• zeros! (function).
• zeros* (function).

---

3.1.7 array-operations/utilities/file-type.lisp

Source

array-operations.asd.

Parent Component

array-operations/utilities (system).

Packages

array-operations/utilities.

Public Interface

• ensure-dimensions (function).
• multf (macro).
• nested-loop (macro).
• product (function).
• same-dimensions-p (function).
• walk-subscripts (macro).
• walk-subscripts-list (macro).

---

3.1.8 array-operations/indexing/file-type.lisp

Source

array-operations.asd.

Parent Component

array-operations/indexing (system).

Packages

array-operations/indexing.

Public Interface

• each-index (macro).
• each-index! (macro).
• each-index* (macro).
• reduce-index (macro).
• sum-index (macro).

Internals

• find-array-dimensions (function).
• foreach (macro).

---

3.1.9 array-operations/displacing/file-type.lisp

Source

array-operations.asd.

Parent Component

array-operations/displacing (system).

Packages

array-operations/displacing.

Public Interface

• combine (function).
• copy-into (function).
• displace (function).
• fill-in-dimensions (function).
• flatten (function).
• partition (function).
• (setf partition) (function).
• reshape (function).
• reshape-col (function).
• reshape-row (function).
• split (function).
• sub (function).
• (setf sub) (function).
• subvec (function).
• (setf subvec) (function).

Internals

sub-location% (function).

---

3.1.10 array-operations/transforming/file-type.lisp

Source

array-operations.asd.

Parent Component

array-operations/transforming (system).

Packages

array-operations/transforming.

Public Interface

• array-index-row-major (function).
• check-permutation (function).
• coercing (function).
• complement-permutation (function).
• complete-permutation (function).
• each (function).
• each* (function).
• identity-permutation-p (function).
• invert-permutation (function).
• map-array (method).
• margin (function).
• margin* (function).
• outer (function).
• outer* (function).
• permutation-incompatible-rank (condition).
• permutation-invalid-index (condition).
• permutation-repeated-index (condition).
• permute (function).
• recycle (function).
• turn (function).
• vectorize (macro).
• vectorize! (macro).
• vectorize* (macro).

Internals

• array-rank-element (type).
• permutation-flags (function).

---

3.1.11 array-operations/stacking/file-type.lisp

Source

array-operations.asd.

Parent Component

array-operations/stacking (system).

Packages

array-operations/stacking.

Public Interface

• copy-row-major-block (function).
• stack (function).
• stack* (function).
• stack-cols (function).
• stack-cols* (function).
• stack-cols-copy (generic function).
• stack-rows (function).
• stack-rows* (function).
• stack-rows-copy (generic function).

Internals

stack*0 (function).

---

5.1.1 Macros

Macro: &dims (&rest dimensions) ¶

Dimensions of array-like object.

Package

array-operations/generic.

Source

file-type.lisp.

Macro: each-index (index &body body) ¶

Given one or more symbols INDEX, walks the BODY expression to determine the index ranges by looking for AREF and ROW-MAJOR-AREF calls.

Transpose of 2D array A

(each-index (i j)
(aref A j i))

Diagonal of a square 2D array

(each-index i (aref A i i))

Turn a 2D array into an array of arrays

(each-index i
(each-index j
(aref A i j)))

Matrix-vector product:

(each-index i
(sum-index j
(* (aref A i j) (aref x j))))

Package

array-operations/indexing.

Source

file-type.lisp.

Macro: each-index! (array index &body body) ¶

Sets elements of the given ARRAY to values of the BODY, evaluated at array indices INDEX

Note: This has the same semantics as each-index and each-index*,
but the INDEX ranges are taken from the ARRAY dimensions, not
a code walker.

Package

array-operations/indexing.

Source

file-type.lisp.

Macro: each-index* (element-type index &body body) ¶

Given one or more symbols INDEX, creates an array with ELEMENT-TYPE, then iterates over the index ranges with the innermost loop using the last index. Each iteration evaluates BODY, and sets the array element.

To find the range of the indices, walks the BODY expression
to determine the index ranges by looking for
AREF and ROW-MAJOR-AREF calls.

Transpose of 2D array A

(each-index* t (i j)
(aref A j i))

Diagonal of a square 2D array

(each-index* t i (aref A i i))

Turn a 2D array into an array of arrays

(each-index* t i
(each-index* t j
(aref A i j)))

Outer product of two 1D arrays to create a 2D array

(each-index* t (i j)
(* (aref x i) (aref y j)))

Matrix-vector product:

(each-index* t i
(sum-index j
(* (aref A i j) (aref x j))))

Package

array-operations/indexing.

Source

file-type.lisp.

Macro: multf (place &rest values) ¶

Multiply by the arguments

Package

array-operations/utilities.

Source

file-type.lisp.

Macro: nested-loop (syms dimensions &body body) ¶

Iterates over a multidimensional range of indices.

SYMS must be a list of symbols, with the first symbol corresponding to the outermost loop.

DIMENSIONS will be evaluated, and must be a list of dimension sizes, of the same length as SYMS.

Example:
(nested-loop (i j) ’(10 20) (format t ’~a ~a~%’ i j))

expands to:

; Check dimensions
(destructuring-bind (g1 g2) ’(10 20)
(loop for i from 0 below g1 do
(loop for j from 0 below g2 do
(format t ’~a ~a~%’ i j))))

with some additional type and dimension checks.

Package

array-operations/utilities.

Source

file-type.lisp.

Macro: reduce-index (function index &body body) ¶

Reduction over one or more INDEX symbols in an array expression.
The range of these symbols is determined by walking the tree
for AREF and ROW-MAJOR-AREF calls.

Example:

(defparameter A #2A((1 2) (3 4)))

(reduce-index #’+ i (row-major-aref A i)) ; Sum all elements (sum-index) => 10

(reduce-index #’* (i j) (aref A i j)) ; Multiply all elements
=> 24

(reduce-index #’max i (row-major-aref A i)) ; Maxmum value
=> 4

Package

array-operations/indexing.

Source

file-type.lisp.

Macro: sum-index (index &body body) ¶

Sums over one or more INDEX symbols in an array expression. The range of these symbols is determined by walking the tree for AREF and ROW-MAJOR-AREF calls.

Example:

(defparameter A #2A((1 2) (3 4)))

(sum-index i (row-major-aref A i)) ; Sum all elements => 10

(sum-index (i j) (aref A i j)) ; Sum all elements
=> 10

(sum-index i (aref A i i)) ; Trace of array
=> 5

Package

array-operations/indexing.

Source

file-type.lisp.

Macro: vectorize (variables &body body) ¶

Makes a new array of type ELEMENT-TYPE, containing the result of an array expression. All input and outputs have the same shape, and BODY is evaluated for each index

VARIABLES must be a list of symbols bound to arrays.
Each array must have the same dimensions. These are
checked at compile and run-time respectively.

(let ((a #2A((1 2) (3 4))))
(vectorize (a) (+ a 1)))
-> #2A((2 3) (4 5))

(let ((a #(1 2 3))
(b #(4 5 6)))
(vectorize (a b) (+ a (* b 2))))
-> #(9 12 15)

Package

array-operations/transforming.

Source

file-type.lisp.

Macro: vectorize! (result variables &body body) ¶

Fills an array RESULT with the result of an array expression. All input and outputs have the same shape, and BODY is evaluated for each index

VARIABLES must be a list of symbols bound to arrays. Each array must have the same dimensions. These are checked at compile and run-time respectively.

(let ((a #2A((1 2) (3 4)))
(b (make-array ’(2 2))))
(vectorize! b (a) (+ a 1)))
-> #2A((2 3) (4 5))

(let ((a #(1 2 3))
(b #(4 5 6)))
(vectorize! b (a b) (+ a (* b 2))))
-> #(9 12 15)

Package

array-operations/transforming.

Source

file-type.lisp.

Macro: vectorize* (element-type variables &body body) ¶

Makes a new array of type ELEMENT-TYPE, containing the result of an array expression. All input and outputs have the same shape, and BODY is evaluated for each index

VARIABLES must be a list of symbols bound to arrays.
Each array must have the same dimensions. These are
checked at compile and run-time respectively.

(let ((a #2A((1 2) (3 4))))
(vectorize* t (a) (+ a 1)))
-> #2A((2 3) (4 5))

(let ((a #(1 2 3))
(b #(4 5 6)))
(vectorize* t (a b) (+ a (* b 2))))
-> #(9 12 15)

Package

array-operations/transforming.

Source

file-type.lisp.

Macro: vectorize-reduce (fn variables &body body) ¶

Performs a reduction using FN over all elements in a vectorized expression on array VARIABLES.

VARIABLES must be a list of symbols bound to arrays.
Each array must have the same dimensions. These are
checked at compile and run-time respectively.

Example: Maximum value in an array A

(vectorize-reduce #’max (a) a)

Example: Maximum absolute difference between two arrays A and B

(vectorize-reduce #’max (a b) (abs (- a b)))

Package

array-operations/reducing.

Source

file-type.lisp.

Macro: walk-subscripts ((dimensions subscripts &optional position) &body body) ¶

Iterate over the subscripts of an array with given DIMENSIONS. SUBSCRIPTS contains the current subscripts as a vector of fixnums, POSITION has the row-major index. Consequences are undefined if either POSITION or SUBSCRIPTS is modified.

Package

array-operations/utilities.

Source

file-type.lisp.

Macro: walk-subscripts-list ((dimensions subscripts &optional position) &body body) ¶

Like WALK-SUBSCRIPTS, but SUBSCRIPTS is a newly created list for each position that does not share structure and can be freely used/modified/kept etc.

Package

array-operations/utilities.

Source

file-type.lisp.

---

5.1.2 Ordinary functions

Function: argmax (array) ¶

Find the row-major-aref in ARRAY with the maximum value Returns both the index and the value of ARRAY at that index

Package

array-operations/reducing.

Source

file-type.lisp.

Function: argmin (array) ¶

Find the row-major-aref in ARRAY with the minimum value Returns both the index and the value of ARRAY at that index

Package

array-operations/reducing.

Source

file-type.lisp.

Function: array-index-row-major (array rmi &optional result) ¶

https://groups.google.com/g/comp.lang.lisp/c/CM3MQkyOTHk/m/Pl4KPUqfobwJ Modified into a destructive, non-consing version. RESULT, if provided, must be a list of length equal to the rank of the array; it is modified to contain the result of the function. This way, the result list can be allocated only once and additionally be DX for zero consing. If RESULT is not provided, then it is consed and then returned.

Package

array-operations/transforming.

Source

file-type.lisp.

Function: best (fn array) ¶

FN must accept two inputs and return true/false. This function is applied
to elements of ARRAY, to find the ’best’. The row-major-aref index is returned.

Example: The index of the maximum is

* (best #’> #(1 2 3 4))
3 ; row-major index
4 ; value

This function was adapted from Paul Graham’s On Lisp

Package

array-operations/reducing.

Source

file-type.lisp.

Function: check-permutation (permutation &optional rank) ¶

Check if PERMUTATION is a valid permutation (of the given RANK), and signal an error if necessary.

Package

array-operations/transforming.

Source

file-type.lisp.

Function: coercing (element-type &optional function) ¶

Return a function composed of a univariate function that coerces to ELEMENT-TYPE and function. When FUNCTION is not given, return a closure that coerces to ELEMENT-TYPE.

Package

array-operations/transforming.

Source

file-type.lisp.

Function: combine (array &optional element-type) ¶

The opposite of SUBARRAYS.
If ELEMENT-TYPE is not given, it is inferred from the first element of array, which also determines the dimensions. If that element is not an array, the original ARRAY is returned as it is.

Package

array-operations/displacing.

Source

file-type.lisp.

Function: complement-permutation (permutation rank) ¶

Return a list of increasing indices that complement PERMUTATION, i.e. form a permutation when appended. Atoms are accepted and treated as lists of a single element.

Package

array-operations/transforming.

Source

file-type.lisp.

Function: complete-permutation (permutation rank) ¶

Return a completed version of permutation, appending it to its complement.

Package

array-operations/transforming.

Source

file-type.lisp.

Function: copy-into (target source) ¶

Copy SOURCE into TARGET, for array arguments of compatible dimensions (checked). Return TARGET, making the implementation of the semantics of SETF easy.

Package

array-operations/displacing.

Source

file-type.lisp.

Function: copy-row-major-block (source-array destination-array element-type &key source-start source-end destination-start) ¶

Copy elements with row major indexes between the given start and end from SOURCE to DESTINATION, respectively. Elements are coerced to ELEMENT-TYPE when necessary. Return no values.

This function should be used to implement copying of contiguous row-major blocks of elements, most optimizations should happen here.

Package

array-operations/stacking.

Source

file-type.lisp.

Function: displace (array dimensions &optional offset) ¶

Shorthand function for displacing an array.

Package

array-operations/displacing.

Source

file-type.lisp.

Function: each (function array &rest other-arrays) ¶

Like EACH*, with ELEMENT-TYPE T.

Package

array-operations/transforming.

Source

file-type.lisp.

Function: each* (element-type function array &rest other-arrays) ¶

Apply function to the array arguments elementwise, and return the result as an array with the given ELEMENT-TYPE. Arguments are checked for dimension compatibility.

Package

array-operations/transforming.

Source

file-type.lisp.

Function: ensure-dimensions (object) ¶

Return a list of dimensions corresponding to OBJECT. Positive integers are treated as dimensions of rank 1, lists are returned as they are, and arrays are queried for their dimensions.

OBJECTS accepted by this function as valid dimensions are called ‘dimension specifications’ in this library.

Package

array-operations/utilities.

Source

file-type.lisp.

Function: fill! (array value) ¶

Fills a given ARRAY with VALUE, coerced to the same element type as ARRAY

Package

array-operations/creating.

Source

file-type.lisp.

Function: fill-in-dimensions (dimensions size) ¶

If one of the dimensions is missing (indicated with T), replace it with a dimension so that the total product equals SIZE. If that’s not possible, signal an error. If there are no missing dimensions, just check that the product equals size. Also accepts other dimension specifications (integer, array).

Package

array-operations/displacing.

Source

file-type.lisp.

Function: flatten (array) ¶

Return ARRAY flattened to a vector. Will share structure.

Package

array-operations/displacing.

Source

file-type.lisp.

Function: generate (function dimensions &optional arguments) ¶

Like GENERATE*, with ELEMENT-TYPE T.

Package

array-operations/creating.

Source

file-type.lisp.

Function: generate* (element-type function dimensions &optional arguments) ¶

Return an array with given DIMENSIONS and ELEMENT-TYPE, with elements generated by calling FUNCTION.

Function is called with:

- no arguments, when ARGUMENTS is nil
- the position (= row major index), when ARGUMENTS is :POSITION
- a list of subscripts, when ARGUMENTS is :SUBSCRIPTS
- both when ARGUMENTS is :POSITION-AND-SUBSCRIPTS

The traversal order is unspecified and may be nonlinear.

Package

array-operations/creating.

Source

file-type.lisp.

Function: identity-permutation-p (permutation &optional rank) ¶

Test if PERMUTATION is the identity permutation, i.e. a sequence of consecutive integers starting at 0. Note that permutation is otherwise not checked, i.e. it may not be a permutation.

Package

array-operations/transforming.

Source

file-type.lisp.

Function: identity-permutation? (permutation &optional rank) ¶

Test if PERMUTATION is the identity permutation, i.e. a sequence of consecutive integers starting at 0. Note that permutation is otherwise not checked, i.e. it may not be a permutation.

Package

array-operations/transforming.

Alias for

identity-permutation-p.

Function: invert-permutation (permutation) ¶

Invert a permutation.

Package

array-operations/transforming.

Source

file-type.lisp.

Function: linspace (start stop n &optional element-type) ¶

Make a vector of N elements containing evenly spaced numbers over an interval. The first element is equal to START and last element STOP, with constant difference between consecutive elements. Elements are of type T, unless ELEMENT-TYPE is given

(linspace 0 4 5) -> #(0 1 2 3 4)
(linspace 1 3 5) -> #(0 1/2 1 3/2 2)
(linspace 0 4d0 3) -> #(0.0d0 2.0d0 4.0d0)

Package

array-operations/creating.

Source

file-type.lisp.

Function: linspace! (array start stop) ¶

Fill an array with evenly spaced numbers over an interval. The first element is equal to START and last element STOP, with constant difference between consecutive elements in ROW-MAJOR-INDEX.

Package

array-operations/creating.

Source

file-type.lisp.

Function: linspace* (element-type start stop n) ¶

Make a vector of N elements and type ELEMENT-TYPE, containing evenly spaced numbers over an interval. The first element is equal to START and last element STOP, with constant difference between consecutive elements.

Package

array-operations/creating.

Source

file-type.lisp.

Function: make-array-like (array &key dimensions adjustable element-type initial-element fill-pointer) ¶

Returns new array with the same properties as ARRAY.
Keyword arguments will override properties of ARRAY.
If INITIAL-ELEMENT is specified, it is coerced to ELEMENT-TYPE.

Package

array-operations/creating.

Alias for

similar-array.

Function: margin (function array inner &optional outer) ¶

Like MARGIN*, with ELEMENT-TYPE T.

Package

array-operations/transforming.

Source

file-type.lisp.

Function: margin* (element-type function array inner &optional outer) ¶

PERMUTE ARRAY with ‘(,@OUTER ,@INNER), split the inner subarrays, apply FUNCTION to each, return the results in an array of dimensions OUTER, with the given ELEMENT-TYPE.

Package

array-operations/transforming.

Source

file-type.lisp.

Function: matrix? (matrix) ¶

Return NIL if MATRIX does not have rank 2.

Package

array-operations/matrices.

Alias for

matrixp.

Function: matrixp (matrix) ¶

Return NIL if MATRIX does not have rank 2.

Package

array-operations/matrices.

Source

file-type.lisp.

Function: most (fn array) ¶

Finds the element of ARRAY that returns the value closest to positive infinity when FN is applied to the array value. Returns the row-major-aref index, and the winning value.

Example: The maximum of an array is
(most #’identity #(1 2 3))
-> 2 (row-major index)
3 (value)

Minimum of an array is
(most #’- #(1 2 3))
0
-1

This function was adapted from Paul Graham’s On Lisp

Package

array-operations/reducing.

Source

file-type.lisp.

Function: ones (dimensions &optional element-type) ¶

Makes an array of shape DIMENSIONS filled with ones. Elements are of type T, unless ELEMENT-TYPE is given.

Package

array-operations/creating.

Source

file-type.lisp.

Function: ones! (array) ¶

Fills the given ARRAY with 1’s, coerced to the element type. Returns ARRAY.

Package

array-operations/creating.

Source

file-type.lisp.

Function: ones* (element-type dimensions) ¶

Makes an array of shape DIMENSIONS and type ELEMENT-TYPE, filled with ones coerced to the specified type ELEMENT-TYPE.

Package

array-operations/creating.

Source

file-type.lisp.

Function: outer (function &rest arrays) ¶

Like OUTER, with ELEMENT-TYPE t.

Package

array-operations/transforming.

Source

file-type.lisp.

Function: outer* (element-type function &rest arrays) ¶

Generalized outer product of ARRAYS with FUNCTION. The resulting array has the concatenated dimensions of ARRAYS, and the given ELEMENT-TYPE.

Package

array-operations/transforming.

Source

file-type.lisp.

Function: partition (array start &optional end) ¶

Return a subset of the array, on the first indexes between START and END.

Package

array-operations/displacing.

Source

file-type.lisp.

Function: (setf partition) (array start &optional end) ¶

Package

array-operations/displacing.

Source

file-type.lisp.

Function: permute (permutation array) ¶

Return ARRAY with the axes permuted by PERMUTATION, which is a sequence of indexes. Specifically, an array A is transformed to B, where

B[b_1,...,b_n] = A[a_1,...,a_n] with b_i=a_{P[i]}

P is the permutation.

Array element type is preserved.

Package

array-operations/transforming.

Source

file-type.lisp.

Function: product (dimensions) ¶

Product of elements in the argument. NOT EXPORTED.

Package

array-operations/utilities.

Source

file-type.lisp.

Function: rand (dimensions &optional element-type) ¶

Makes an array of shape DIMENSIONS filled with random numbers uniformly distributed between 0 and 1. Elements are of type T, unless ELEMENT-TYPE is given.

Uses the built-in RANDOM function.

(rand 3) -> #(0.39319038 0.69693553 0.5021677)
(rand ’(2 2)) -> #2A((0.91003513 0.23208928) (0.5577954 0.94657767))

NOTE: If it’s important that these numbers are really random (e.g. cryptographic applications), then you should probably not use this function.

Package

array-operations/creating.

Source

file-type.lisp.

Function: rand! (array) ¶

Fills a given ARRAY with random numbers, uniformly distributed between 0 and 1. Uses the built-in RANDOM function. Returns ARRAY.

Package

array-operations/creating.

Source

file-type.lisp.

Function: rand* (element-type dimensions) ¶

Makes an array of shape DIMENSIONS and type ELEMENT-TYPE, filled with random numbers uniformly distributed between 0 and 1.

Uses the built-in RANDOM function.

(rand 3) -> #(0.39319038 0.69693553 0.5021677)
(rand ’(2 2)) -> #2A((0.91003513 0.23208928) (0.5577954 0.94657767))

NOTE: If it’s important that these numbers are really random (e.g. cryptographic applications), then you should probably not use this function.

Package

array-operations/creating.

Source

file-type.lisp.

Function: randn (dimensions &optional element-type) ¶

Creates an array of shape DIMENSIONS and type T, and fills with normally distributed numbers with a mean of zero and standard deviation of 1

Uses the Box-Muller algorithm and built-in random number generator.

(rand 3) -> #(-0.82067037 -0.60068226 -0.21494178)
(randn ’(2 2)) -> #2A((1.6905352 -2.5379088) (0.8461403 -1.505984))

NOTE: If it’s important that these numbers are really random (e.g. cryptographic applications), then you should probably not use this function.

Package

array-operations/creating.

Source

file-type.lisp.

Function: randn! (array) ¶

Fills ARRAY with normally distributed numbers with a mean of zero and standard deviation of 1

Uses the Box-Muller algorithm and built-in random number generator.

NOTE: If it’s important that these numbers are really random (e.g. cryptographic applications), then you should probably not use this function.

Package

array-operations/creating.

Source

file-type.lisp.

Function: randn* (element-type dimensions) ¶

Creates an array of shape DIMENSIONS and type ELEMENT-TYPE, and fills with normally distributed numbers with a mean of zero and standard deviation of 1

Uses the Box-Muller algorithm and built-in random number generator.

(rand 3) -> #(-0.82067037 -0.60068226 -0.21494178)
(randn ’(2 2)) -> #2A((1.6905352 -2.5379088) (0.8461403 -1.505984))

NOTE: If it’s important that these numbers are really random
(e.g. cryptographic applications), then you should probably
not use this function.

Package

array-operations/creating.

Source

file-type.lisp.

Function: recycle (object &key inner outer element-type) ¶

Recycle elements of OBJECT, extending the dimensions by outer (repeating OBJECT) and inner (repeating each element of OBJECT). When both INNER and OUTER are nil, the OBJECT is returned as is. Non-array OBJECTs are interpreted as rank 0 arrays, following the usual semantics.

Package

array-operations/transforming.

Source

file-type.lisp.

Function: reshape (array dimensions &optional offset) ¶

Reshape ARRAY using DIMENSIONS (which can also be dimension specifications).
If DIMENSIONS is a list, it may contain a single element T which will be calculated to match the total size of the resulting array.

Package

array-operations/displacing.

Source

file-type.lisp.

Function: reshape-col (array) ¶

Array reshaped as an Nx1 matrix.

Package

array-operations/displacing.

Source

file-type.lisp.

Function: reshape-row (array) ¶

Array reshaped as an 1xN matrix.

Package

array-operations/displacing.

Source

file-type.lisp.

Function: same-dimensions-p (array &rest arrays) ¶

Test if arguments have the same dimensions. NOT EXPORTED.

Package

array-operations/utilities.

Source

file-type.lisp.

Function: similar-array (array &key dimensions adjustable element-type initial-element fill-pointer) ¶

Returns new array with the same properties as ARRAY.
Keyword arguments will override properties of ARRAY.
If INITIAL-ELEMENT is specified, it is coerced to ELEMENT-TYPE.

Package

array-operations/creating.

Source

file-type.lisp.

Function: split (array rank) ¶

Return an array of subarrays, split off at RANK. All subarrays are displaced and share structure.

Package

array-operations/displacing.

Source

file-type.lisp.

Function: square-matrix-p (matrix) ¶

Test if MATRIX has two dimensions and that they are equal.

Package

array-operations/matrices.

Source

file-type.lisp.

Function: square-matrix? (matrix) ¶

Test if MATRIX has two dimensions and that they are equal.

Package

array-operations/matrices.

Alias for

square-matrix-p.

Function: stack (axis array &rest arrays) ¶

Like STACK*, with element-type T.

Package

array-operations/stacking.

Source

file-type.lisp.

Function: stack* (element-type axis array &rest arrays) ¶

Stack array arguments along AXIS. ELEMENT-TYPE determines the element-type of the result.

Package

array-operations/stacking.

Source

file-type.lisp.

Function: stack-cols (&rest objects) ¶

Like STACK-COLS*, with ELEMENT-TYPE T.

Package

array-operations/stacking.

Source

file-type.lisp.

Function: stack-cols* (element-type &rest objects) ¶

Stack OBJECTS column-wise into an array of the given ELEMENT-TYPE, coercing if necessary. Always return a simple array of rank 2.

How objects are used depends on their dimensions, queried by DIMS:

- when the object has 0 dimensions, fill a column with the element.

- when the object has 1 dimension, use it as a column.

- when the object has 2 dimensions, use it as a matrix.

When applicable, compatibility of dimensions is checked, and the result is used to determine the number of rows. When all objects have 0 dimensions, the result has one row.

Package

array-operations/stacking.

Source

file-type.lisp.

Function: stack-rows (&rest objects) ¶

Like STACK-ROWS*, with ELEMENT-TYPE T.

Package

array-operations/stacking.

Source

file-type.lisp.

Function: stack-rows* (element-type &rest objects) ¶

Stack OBJECTS row-wise into an array of the given ELEMENT-TYPE, coercing if necessary. Always return a simple array of rank 2.

How objects are used depends on their dimensions, queried by DIMS:

- when the object has 0 dimensions, fill a row with the element.

- when the object has 1 dimension, use it as a row.

- when the object has 2 dimensions, use it as a matrix.

When applicable, compatibility of dimensions is checked, and the result is used to determine the number of columns. When all objects have 0 dimensions, the result has one column.

Package

array-operations/stacking.

Source

file-type.lisp.

Function: sub (array &rest subscripts) ¶

Given a partial list of subscripts, return the subarray that starts there, with all the other subscripts set to 0, dimensions inferred from the original.

If no subscripts are given, the original array is returned. Implemented by displacing, may share structure.

Package

array-operations/displacing.

Source

file-type.lisp.

Function: (setf sub) (array &rest subscripts) ¶

Package

array-operations/displacing.

Source

file-type.lisp.

Function: subvec (vector start &optional end) ¶

Displaced vector between START and END.

Package

array-operations/displacing.

Source

file-type.lisp.

Function: (setf subvec) (vector start &optional end) ¶

Package

array-operations/displacing.

Source

file-type.lisp.

Function: turn (array nturns &optional rank-1 rank-2) ¶

Turns an array by a specified number of clockwise 90° rotations. The axis of rotation is specified by RANK-1 (defaulting to 0) and RANK-2 (defaulting to 1).

Package

array-operations/transforming.

Source

file-type.lisp.

Function: zeros (dimensions &optional element-type) ¶

Make an array of shape DIMENSIONS filled with zeros. Elements are of type T, unless ELEMENT-TYPE is given.

Package

array-operations/creating.

Source

file-type.lisp.

Function: zeros! (array) ¶

Fills the given ARRAY with zero values, coerced to the element type. Returns ARRAY.

Package

array-operations/creating.

Source

file-type.lisp.

Function: zeros* (element-type dimensions) ¶

Makes an array of shape DIMENSIONS and type ELEMENT-TYPE, filled with zeros coerced to the specified type ELEMENT-TYPE.

Package

array-operations/creating.

Source

file-type.lisp.

---

5.1.3 Generic functions

Generic Function: as-array (object) ¶

Return the contents of OBJECT as an array. Exact semantics depends on OBJECT, but generally objects which contain elements in a rectilinear coordinate system should have a natural mapping to arrays.

When the second value is T, the array itself does not share structure with OBJECT, but its elements may. Otherwise, it is indeterminate whether the two objects share structure, and consequences of modifying the result are not defined. Methods are encouraged but not required to return a second value.

Package

array-operations/generic.

Source

file-type.lisp.

Methods

Method: as-array ((array array)) ¶

Method: as-array (object) ¶

Generic Function: dim (array axis) ¶

Return specificed dimension of ARRAY.

Package

array-operations/generic.

Source

file-type.lisp.

Methods

Method: dim ((array array) axis) ¶

Method: dim (array axis) ¶

Generic Function: dims (array) ¶

Return a list of dimensions.

For non-array objects, SIZE, DIM, NROW and NCOL use this method by default, so it is enough to define it (unless efficiency is a concern).

When DIMS is not defined for an object, it falls back to as-array, which may be very inefficient for objects which need to be consed. It is always advisable to define DIMS.

Package

array-operations/generic.

Source

file-type.lisp.

Methods

Method: dims ((array array)) ¶

Method: dims (array) ¶

Generic Function: element-type (array) ¶

Return TYPE such that

1. all elements of ARRAY are guaranteed to be a subtype of TYPE,

2. if applicable, elements of ARRAY can be set to values which are of a type that is a subtype of TYPE.

Package

array-operations/generic.

Source

file-type.lisp.

Methods

Method: element-type ((array array)) ¶

Method: element-type (array) ¶

Generic Function: map-array (array function &optional retval) ¶

Package

array-operations/transforming.

Methods

Method: map-array (array function &optional retval) ¶

Apply FUNCTION to each element of ARRAY
Return a new array, or write into the optional 3rd argument.

Source

file-type.lisp.

Generic Function: ncol (array) ¶

Number of columns. Will signal an error if ARRAY is not a matrix.

Package

array-operations/generic.

Source

file-type.lisp.

Methods

Method: ncol ((array array)) ¶

Method: ncol (array) ¶

Generic Function: nrow (array) ¶

Number of rows. Will signal an error if ARRAY is not a matrix.

Package

array-operations/generic.

Source

file-type.lisp.

Methods

Method: nrow ((array array)) ¶

Method: nrow (array) ¶

Generic Function: rank (array) ¶

Return the rank of ARRAY.

Package

array-operations/generic.

Source

file-type.lisp.

Methods

Method: rank ((array array)) ¶

Method: rank (array) ¶

Generic Function: size (array) ¶

Return the total number of elements in array.

Package

array-operations/generic.

Source

file-type.lisp.

Methods

Method: size ((array array)) ¶

Method: size (array) ¶

Generic Function: stack-cols-copy (source destination element-type start-col) ¶

Method used to implement the copying of objects in STACK-COL*, by copying the elements of SOURCE to DESTINATION, starting with the column index START-COL in the latter. Elements are coerced to ELEMENT-TYPE.

This method is only called when (DIMS SOURCE) was non-nil. It is assumed that it only changes elements in DESTINATION which are supposed to be copies of SOURCE. DESTINATION is always a matrix with element-type upgraded from ELEMENT-TYPE, and its NROW should match the relevant dimension of SOURCE.

All objects have a fallback method, defined using AS-ARRAY. The only reason for defining a method is efficiency.

Package

array-operations/stacking.

Source

file-type.lisp.

Methods

Method: stack-cols-copy (source destination element-type start-col) ¶

Method: stack-cols-copy ((source array) destination element-type start-col) ¶

Generic Function: stack-rows-copy (source destination element-type start-row) ¶

Method used to implement the copying of objects in STACK-ROW*, by copying the elements of SOURCE to DESTINATION, starting with the row index START-ROW in the latter. Elements are coerced to ELEMENT-TYPE.

This method is only called when (DIMS SOURCE) was non-nil. It is assumed that it only changes elements in DESTINATION which are supposed to be copies of SOURCE. DESTINATION is always a matrix with element-type upgraded from ELEMENT-TYPE, and its NCOL should match the relevant dimension of SOURCE.

All objects have a fallback method, defined using AS-ARRAY. The only reason for defining a method is efficiency.

Package

array-operations/stacking.

Source

file-type.lisp.

Methods

Method: stack-rows-copy (source destination element-type start-row) ¶

Method: stack-rows-copy ((source array) destination element-type start-row) ¶

---

5.1.4 Conditions

Condition: permutation-incompatible-rank ¶

Package

array-operations/transforming.

Source

file-type.lisp.

Direct superclasses

error.

Condition: permutation-invalid-index ¶

Package

array-operations/transforming.

Source

file-type.lisp.

Direct superclasses

error.

Direct slots

Slot: index ¶

Initargs

:index

Condition: permutation-repeated-index ¶

Package

array-operations/transforming.

Source

file-type.lisp.

Direct superclasses

error.

Direct slots

Slot: index ¶

Initargs

:index

---

5.1.5 Types

Type: array-matrix () ¶

A rank-2 array.

Package

array-operations/matrices.

Source

file-type.lisp.

---

5.2.1 Macros

Macro: foreach (&key index sum value) ¶

Examples:

Matrix-matrix multiply

(foreach :index (i j) :sum k
:value (* (aref A i k) (aref B k j)))

Sum over vector

(foreach :sum i :value (aref A i))

Package

array-operations/indexing.

Source

file-type.lisp.

---

5.2.2 Ordinary functions

Function: find-array-dimensions (expr) ¶

Walks an expression tree EXPR, finds AREF and ROW-MAJOR-AREF, SVREF or ELT calls. Returns a list of (symbol, expr) where EXPR is an expression which evaluates to the array dimension size for SYMBOL.

Example:
(find-array-dimensions ’(+ (aref a i) (* 2 (aref b j k))))

-> ((I ARRAY-DIMENSION A 0) (K ARRAY-DIMENSION B 1) (J ARRAY-DIMENSION B 0))

Package

array-operations/indexing.

Source

file-type.lisp.

Function: permutation-flags (permutation &optional rank) ¶

Make a bit vector of flags with indexes from PERMUTATION, signaling errors for invalid and repeated indices. NOT EXPORTED.

Package

array-operations/transforming.

Source

file-type.lisp.

Function: stack*0 (element-type arrays) ¶

Stack arrays along the 0 axis, returning an array with given ELEMENT-TYPE.

Package

array-operations/stacking.

Source

file-type.lisp.

Function: sub-location% (dimensions subscripts) ¶

Return (values OFFSET REMAINING-DIMENSIONS) that can be used to displace a row-major subarray starting at SUBSCRIPTS in an array with the given DIMENSIONS. NOT EXPORTED.

Package

array-operations/displacing.

Source

file-type.lisp.

---

5.2.3 Types

Type: array-rank-element () ¶

Package

array-operations/transforming.

Source

file-type.lisp.

---