The array-operations Reference Manual

This is the array-operations Reference Manual, version 1.2.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed May 15 03:19:31 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

The main system appears first, followed by any subsystem dependency.


2.1 array-operations

Array operations library for Common Lisp

Long Name

Array operations for array-like data structures

Maintainer

Steve Nunez <>

Author

Tamas K. Papp <>

Home Page

https://lisp-stat.dev/docs/manuals/array-operations

Bug Tracker

https://github.com/Lisp-Stat/array-operations/issues

License

MS-PL

Long Description

The array-operations system is a collection of functions and macros for manipulating Common Lisp arrays and performing numerical calculations with them. It is extendible to array-like data structures, such as data frames. It is a core system for solving linear systems of equations in common lisp.

Array-operations is a ’generic’ way of operating on array like data structures using a syntax that is natural for Common Lisp. Several aops functions have been implemented for data-frame. For those that haven’t, you can transform arrays to data frames using the df:matrix-df function, and a data-frame to an array using df:as-array. This make it convenient to work with the data sets using either system.

Version

1.2.1

Dependencies
Source

array-operations.asd.


2.2 array-operations/all

Long Name

Array operations for array-like data structures

Maintainer

Steve Nunez <>

Author

Tamas K. Papp <>

Home Page

https://lisp-stat.dev/docs/manuals/array-operations

Bug Tracker

https://github.com/Lisp-Stat/array-operations/issues

License

MS-PL

Dependencies
Source

array-operations.asd.


2.3 array-operations/generic

Long Name

Array operations for array-like data structures

Maintainer

Steve Nunez <>

Author

Tamas K. Papp <>

Home Page

https://lisp-stat.dev/docs/manuals/array-operations

Bug Tracker

https://github.com/Lisp-Stat/array-operations/issues

License

MS-PL

Dependency

let-plus (system).

Source

array-operations.asd.


2.4 array-operations/reducing

Long Name

Array operations for array-like data structures

Maintainer

Steve Nunez <>

Author

Tamas K. Papp <>

Home Page

https://lisp-stat.dev/docs/manuals/array-operations

Bug Tracker

https://github.com/Lisp-Stat/array-operations/issues

License

MS-PL

Source

array-operations.asd.


2.5 array-operations/matrices

Long Name

Array operations for array-like data structures

Maintainer

Steve Nunez <>

Author

Tamas K. Papp <>

Home Page

https://lisp-stat.dev/docs/manuals/array-operations

Bug Tracker

https://github.com/Lisp-Stat/array-operations/issues

License

MS-PL

Dependencies
Source

array-operations.asd.


2.6 array-operations/creating

Long Name

Array operations for array-like data structures

Maintainer

Steve Nunez <>

Author

Tamas K. Papp <>

Home Page

https://lisp-stat.dev/docs/manuals/array-operations

Bug Tracker

https://github.com/Lisp-Stat/array-operations/issues

License

MS-PL

Dependencies
Source

array-operations.asd.


2.7 array-operations/utilities

Long Name

Array operations for array-like data structures

Maintainer

Steve Nunez <>

Author

Tamas K. Papp <>

Home Page

https://lisp-stat.dev/docs/manuals/array-operations

Bug Tracker

https://github.com/Lisp-Stat/array-operations/issues

License

MS-PL

Dependencies
Source

array-operations.asd.


2.8 array-operations/indexing

Long Name

Array operations for array-like data structures

Maintainer

Steve Nunez <>

Author

Tamas K. Papp <>

Home Page

https://lisp-stat.dev/docs/manuals/array-operations

Bug Tracker

https://github.com/Lisp-Stat/array-operations/issues

License

MS-PL

Dependencies
Source

array-operations.asd.


2.9 array-operations/displacing

Long Name

Array operations for array-like data structures

Maintainer

Steve Nunez <>

Author

Tamas K. Papp <>

Home Page

https://lisp-stat.dev/docs/manuals/array-operations

Bug Tracker

https://github.com/Lisp-Stat/array-operations/issues

License

MS-PL

Dependencies
Source

array-operations.asd.


2.10 array-operations/transforming

Long Name

Array operations for array-like data structures

Maintainer

Steve Nunez <>

Author

Tamas K. Papp <>

Home Page

https://lisp-stat.dev/docs/manuals/array-operations

Bug Tracker

https://github.com/Lisp-Stat/array-operations/issues

License

MS-PL

Dependencies
Source

array-operations.asd.


2.11 array-operations/stacking

Long Name

Array operations for array-like data structures

Maintainer

Steve Nunez <>

Author

Tamas K. Papp <>

Home Page

https://lisp-stat.dev/docs/manuals/array-operations

Bug Tracker

https://github.com/Lisp-Stat/array-operations/issues

License

MS-PL

Dependencies
Source

array-operations.asd.


3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


3.1 Lisp


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

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

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

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

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

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
Internals

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
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
Internals

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
Internals

stack*0 (function).


4 Packages

Packages are listed by definition order.


4.1 array-operations/matrices

Functions for representing matrices as 2D arrays. A matrix is a two-dimensional array often used for linear algebra. See also the matrix functions in NUM-UTILS, which should be migrated to AOPS.

Source

file-type.lisp.

Use List
Used By List

array-operations/all.

Public Interface

4.2 array-operations/transforming

Functions for transforming arrays in various ways.

Source

file-type.lisp.

Use List
Used By List

array-operations/all.

Public Interface
Internals

4.3 array-operations/reducing

Functions for reducing arrays, or performing reducing like operations over the elements of an array.

Source

file-type.lisp.

Use List

common-lisp.

Used By List

array-operations/all.

Public Interface

4.5 array-operations/creating

Functions for creating arrays or data frames filled with various values.

Source

file-type.lisp.

Use List
Used By List

array-operations/all.

Public Interface

4.6 array-operations/all

This top level package re-exports the individual packages: generic, reducing, matrices, creating, indexing, displacing, transforming and stacking. It does not export utilities. The reason for this structure is the use of the ASDF package-inferred-system, where each file is its own package. None of Papp’s other libraries use this, and it seems to have been added after he abandoned the library.

Source

file-type.lisp.

Nicknames
  • array-operations
  • aops
Use List

4.7 array-operations/stacking

Functions for composing arrays into new arrays, by stacking.

One may think of stacking blocks as the guiding metaphor.

For example, stack two row vectors to yield a 2x2 matrix:

(stack-rows #(1 2) #(3 4)) -> #2A((1 2)
(3 4))

Source

file-type.lisp.

Use List
Used By List

array-operations/all.

Public Interface
Internals

stack*0 (function).


4.8 array-operations/indexing

Macros for operating over indexes of arrays.

Source

file-type.lisp.

Use List
Used By List

array-operations/all.

Public Interface
Internals

4.9 array-operations/displacing

Functions that return arrays displaced in various ways from another array.

Source

file-type.lisp.

Use List
Used By List
Public Interface
Internals

sub-location% (function).


4.10 array-operations/generic

Generic functions for elementary array operations, with methods on ’array. Enables new methods to be defined to enable treating other data structures as arrays.

Source

file-type.lisp.

Use List
  • common-lisp.
  • let-plus.
Used By List
Public Interface

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


5.1 Public Interface


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 Internals


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.


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   &   (  
A   B   C   D   E   F   G   I   L   M   N   O   P   R   S   T   V   W   Z  
Index Entry  Section

&
&dims: Public macros

(
(setf partition): Public ordinary functions
(setf sub): Public ordinary functions
(setf subvec): Public ordinary functions

A
argmax: Public ordinary functions
argmin: Public ordinary functions
array-index-row-major: Public ordinary functions
as-array: Public generic functions
as-array: Public generic functions
as-array: Public generic functions

B
best: Public ordinary functions

C
check-permutation: Public ordinary functions
coercing: Public ordinary functions
combine: Public ordinary functions
complement-permutation: Public ordinary functions
complete-permutation: Public ordinary functions
copy-into: Public ordinary functions
copy-row-major-block: Public ordinary functions

D
dim: Public generic functions
dim: Public generic functions
dim: Public generic functions
dims: Public generic functions
dims: Public generic functions
dims: Public generic functions
displace: Public ordinary functions

E
each: Public ordinary functions
each*: Public ordinary functions
each-index: Public macros
each-index!: Public macros
each-index*: Public macros
element-type: Public generic functions
element-type: Public generic functions
element-type: Public generic functions
ensure-dimensions: Public ordinary functions

F
fill!: Public ordinary functions
fill-in-dimensions: Public ordinary functions
find-array-dimensions: Private ordinary functions
flatten: Public ordinary functions
foreach: Private macros
Function, (setf partition): Public ordinary functions
Function, (setf sub): Public ordinary functions
Function, (setf subvec): Public ordinary functions
Function, argmax: Public ordinary functions
Function, argmin: Public ordinary functions
Function, array-index-row-major: Public ordinary functions
Function, best: Public ordinary functions
Function, check-permutation: Public ordinary functions
Function, coercing: Public ordinary functions
Function, combine: Public ordinary functions
Function, complement-permutation: Public ordinary functions
Function, complete-permutation: Public ordinary functions
Function, copy-into: Public ordinary functions
Function, copy-row-major-block: Public ordinary functions
Function, displace: Public ordinary functions
Function, each: Public ordinary functions
Function, each*: Public ordinary functions
Function, ensure-dimensions: Public ordinary functions
Function, fill!: Public ordinary functions
Function, fill-in-dimensions: Public ordinary functions
Function, find-array-dimensions: Private ordinary functions
Function, flatten: Public ordinary functions
Function, generate: Public ordinary functions
Function, generate*: Public ordinary functions
Function, identity-permutation-p: Public ordinary functions
Function, identity-permutation?: Public ordinary functions
Function, invert-permutation: Public ordinary functions
Function, linspace: Public ordinary functions
Function, linspace!: Public ordinary functions
Function, linspace*: Public ordinary functions
Function, make-array-like: Public ordinary functions
Function, margin: Public ordinary functions
Function, margin*: Public ordinary functions
Function, matrix?: Public ordinary functions
Function, matrixp: Public ordinary functions
Function, most: Public ordinary functions
Function, ones: Public ordinary functions
Function, ones!: Public ordinary functions
Function, ones*: Public ordinary functions
Function, outer: Public ordinary functions
Function, outer*: Public ordinary functions
Function, partition: Public ordinary functions
Function, permutation-flags: Private ordinary functions
Function, permute: Public ordinary functions
Function, product: Public ordinary functions
Function, rand: Public ordinary functions
Function, rand!: Public ordinary functions
Function, rand*: Public ordinary functions
Function, randn: Public ordinary functions
Function, randn!: Public ordinary functions
Function, randn*: Public ordinary functions
Function, recycle: Public ordinary functions
Function, reshape: Public ordinary functions
Function, reshape-col: Public ordinary functions
Function, reshape-row: Public ordinary functions
Function, same-dimensions-p: Public ordinary functions
Function, similar-array: Public ordinary functions
Function, split: Public ordinary functions
Function, square-matrix-p: Public ordinary functions
Function, square-matrix?: Public ordinary functions
Function, stack: Public ordinary functions
Function, stack*: Public ordinary functions
Function, stack*0: Private ordinary functions
Function, stack-cols: Public ordinary functions
Function, stack-cols*: Public ordinary functions
Function, stack-rows: Public ordinary functions
Function, stack-rows*: Public ordinary functions
Function, sub: Public ordinary functions
Function, sub-location%: Private ordinary functions
Function, subvec: Public ordinary functions
Function, turn: Public ordinary functions
Function, zeros: Public ordinary functions
Function, zeros!: Public ordinary functions
Function, zeros*: Public ordinary functions

G
generate: Public ordinary functions
generate*: Public ordinary functions
Generic Function, as-array: Public generic functions
Generic Function, dim: Public generic functions
Generic Function, dims: Public generic functions
Generic Function, element-type: Public generic functions
Generic Function, map-array: Public generic functions
Generic Function, ncol: Public generic functions
Generic Function, nrow: Public generic functions
Generic Function, rank: Public generic functions
Generic Function, size: Public generic functions
Generic Function, stack-cols-copy: Public generic functions
Generic Function, stack-rows-copy: Public generic functions

I
identity-permutation-p: Public ordinary functions
identity-permutation?: Public ordinary functions
invert-permutation: Public ordinary functions

L
linspace: Public ordinary functions
linspace!: Public ordinary functions
linspace*: Public ordinary functions

M
Macro, &dims: Public macros
Macro, each-index: Public macros
Macro, each-index!: Public macros
Macro, each-index*: Public macros
Macro, foreach: Private macros
Macro, multf: Public macros
Macro, nested-loop: Public macros
Macro, reduce-index: Public macros
Macro, sum-index: Public macros
Macro, vectorize: Public macros
Macro, vectorize!: Public macros
Macro, vectorize*: Public macros
Macro, vectorize-reduce: Public macros
Macro, walk-subscripts: Public macros
Macro, walk-subscripts-list: Public macros
make-array-like: Public ordinary functions
map-array: Public generic functions
map-array: Public generic functions
margin: Public ordinary functions
margin*: Public ordinary functions
matrix?: Public ordinary functions
matrixp: Public ordinary functions
Method, as-array: Public generic functions
Method, as-array: Public generic functions
Method, dim: Public generic functions
Method, dim: Public generic functions
Method, dims: Public generic functions
Method, dims: Public generic functions
Method, element-type: Public generic functions
Method, element-type: Public generic functions
Method, map-array: Public generic functions
Method, ncol: Public generic functions
Method, ncol: Public generic functions
Method, nrow: Public generic functions
Method, nrow: Public generic functions
Method, rank: Public generic functions
Method, rank: Public generic functions
Method, size: Public generic functions
Method, size: Public generic functions
Method, stack-cols-copy: Public generic functions
Method, stack-cols-copy: Public generic functions
Method, stack-rows-copy: Public generic functions
Method, stack-rows-copy: Public generic functions
most: Public ordinary functions
multf: Public macros

N
ncol: Public generic functions
ncol: Public generic functions
ncol: Public generic functions
nested-loop: Public macros
nrow: Public generic functions
nrow: Public generic functions
nrow: Public generic functions

O
ones: Public ordinary functions
ones!: Public ordinary functions
ones*: Public ordinary functions
outer: Public ordinary functions
outer*: Public ordinary functions

P
partition: Public ordinary functions
permutation-flags: Private ordinary functions
permute: Public ordinary functions
product: Public ordinary functions

R
rand: Public ordinary functions
rand!: Public ordinary functions
rand*: Public ordinary functions
randn: Public ordinary functions
randn!: Public ordinary functions
randn*: Public ordinary functions
rank: Public generic functions
rank: Public generic functions
rank: Public generic functions
recycle: Public ordinary functions
reduce-index: Public macros
reshape: Public ordinary functions
reshape-col: Public ordinary functions
reshape-row: Public ordinary functions

S
same-dimensions-p: Public ordinary functions
similar-array: Public ordinary functions
size: Public generic functions
size: Public generic functions
size: Public generic functions
split: Public ordinary functions
square-matrix-p: Public ordinary functions
square-matrix?: Public ordinary functions
stack: Public ordinary functions
stack*: Public ordinary functions
stack*0: Private ordinary functions
stack-cols: Public ordinary functions
stack-cols*: Public ordinary functions
stack-cols-copy: Public generic functions
stack-cols-copy: Public generic functions
stack-cols-copy: Public generic functions
stack-rows: Public ordinary functions
stack-rows*: Public ordinary functions
stack-rows-copy: Public generic functions
stack-rows-copy: Public generic functions
stack-rows-copy: Public generic functions
sub: Public ordinary functions
sub-location%: Private ordinary functions
subvec: Public ordinary functions
sum-index: Public macros

T
turn: Public ordinary functions

V
vectorize: Public macros
vectorize!: Public macros
vectorize*: Public macros
vectorize-reduce: Public macros

W
walk-subscripts: Public macros
walk-subscripts-list: Public macros

Z
zeros: Public ordinary functions
zeros!: Public ordinary functions
zeros*: Public ordinary functions


A.3 Variables

Jump to:   I   S  
Index Entry  Section

I
index: Public conditions
index: Public conditions

S
Slot, index: Public conditions
Slot, index: Public conditions


A.4 Data types

Jump to:   A   C   F   P   S   T  
Index Entry  Section

A
array-matrix: Public types
array-operations: The array-operations system
array-operations.asd: The array-operations/array-operations․asd file
array-operations/all: The array-operations/all system
array-operations/all: The array-operations/all package
array-operations/creating: The array-operations/creating system
array-operations/creating: The array-operations/creating package
array-operations/displacing: The array-operations/displacing system
array-operations/displacing: The array-operations/displacing package
array-operations/generic: The array-operations/generic system
array-operations/generic: The array-operations/generic package
array-operations/indexing: The array-operations/indexing system
array-operations/indexing: The array-operations/indexing package
array-operations/matrices: The array-operations/matrices system
array-operations/matrices: The array-operations/matrices package
array-operations/reducing: The array-operations/reducing system
array-operations/reducing: The array-operations/reducing package
array-operations/stacking: The array-operations/stacking system
array-operations/stacking: The array-operations/stacking package
array-operations/transforming: The array-operations/transforming system
array-operations/transforming: The array-operations/transforming package
array-operations/utilities: The array-operations/utilities system
array-operations/utilities: The array-operations/utilities package
array-rank-element: Private types

C
Condition, permutation-incompatible-rank: Public conditions
Condition, permutation-invalid-index: Public conditions
Condition, permutation-repeated-index: Public conditions

F
File, array-operations.asd: The array-operations/array-operations․asd file
File, file-type.lisp: The array-operations/all/file-type․lisp file
File, file-type.lisp: The array-operations/generic/file-type․lisp file
File, file-type.lisp: The array-operations/reducing/file-type․lisp file
File, file-type.lisp: The array-operations/matrices/file-type․lisp file
File, file-type.lisp: The array-operations/creating/file-type․lisp file
File, file-type.lisp: The array-operations/utilities/file-type․lisp file
File, file-type.lisp: The array-operations/indexing/file-type․lisp file
File, file-type.lisp: The array-operations/displacing/file-type․lisp file
File, file-type.lisp: The array-operations/transforming/file-type․lisp file
File, file-type.lisp: The array-operations/stacking/file-type․lisp file
file-type.lisp: The array-operations/all/file-type․lisp file
file-type.lisp: The array-operations/generic/file-type․lisp file
file-type.lisp: The array-operations/reducing/file-type․lisp file
file-type.lisp: The array-operations/matrices/file-type․lisp file
file-type.lisp: The array-operations/creating/file-type․lisp file
file-type.lisp: The array-operations/utilities/file-type․lisp file
file-type.lisp: The array-operations/indexing/file-type․lisp file
file-type.lisp: The array-operations/displacing/file-type․lisp file
file-type.lisp: The array-operations/transforming/file-type․lisp file
file-type.lisp: The array-operations/stacking/file-type․lisp file

P
Package, array-operations/all: The array-operations/all package
Package, array-operations/creating: The array-operations/creating package
Package, array-operations/displacing: The array-operations/displacing package
Package, array-operations/generic: The array-operations/generic package
Package, array-operations/indexing: The array-operations/indexing package
Package, array-operations/matrices: The array-operations/matrices package
Package, array-operations/reducing: The array-operations/reducing package
Package, array-operations/stacking: The array-operations/stacking package
Package, array-operations/transforming: The array-operations/transforming package
Package, array-operations/utilities: The array-operations/utilities package
permutation-incompatible-rank: Public conditions
permutation-invalid-index: Public conditions
permutation-repeated-index: Public conditions

S
System, array-operations: The array-operations system
System, array-operations/all: The array-operations/all system
System, array-operations/creating: The array-operations/creating system
System, array-operations/displacing: The array-operations/displacing system
System, array-operations/generic: The array-operations/generic system
System, array-operations/indexing: The array-operations/indexing system
System, array-operations/matrices: The array-operations/matrices system
System, array-operations/reducing: The array-operations/reducing system
System, array-operations/stacking: The array-operations/stacking system
System, array-operations/transforming: The array-operations/transforming system
System, array-operations/utilities: The array-operations/utilities system

T
Type, array-matrix: Public types
Type, array-rank-element: Private types