The lla Reference Manual

This is the lla Reference Manual, version 0.3.1, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Sep 15 05:57:14 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 lla

Lisp Linear Algebra

Author

Steven Nunez

License

ML-PL

Long Description

LLA is a high-level Common Lisp library built on on BLAS and LAPACK, but providing a more abstract interface with the purpose of freeing the user from low-level concerns and reducing the number of bugs in numerical code.

There are four main objectives:

- Provide a high-level, user friendly, interface that hides the details.
- Stay in Lisp and expose the innards of the objects as much as possible.
- Keeping it simple; LLA is only about 3000 lines of code.
- Speed is important, but reliability comes first.

Version

0.3.1

Dependencies
  • anaphora (system).
  • alexandria (system).
  • cffi (system).
  • num-utils (system).
  • select (system).
  • let-plus (system).
Source

lla.asd.

Child Components

3 Files

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


3.1 Lisp


3.1.1 lla/lla.asd

Source

lla.asd.

Parent Component

lla (system).

ASDF Systems

lla.


3.1.2 lla/package.lisp

Source

lla.asd.

Parent Component

lla (system).

Packages

lla.


3.1.3 lla/configuration-interface.lisp

Dependency

package.lisp (file).

Source

lla.asd.

Parent Component

lla (system).

Internals

3.1.4 lla/configuration.lisp

Dependency

configuration-interface.lisp (file).

Source

lla.asd.

Parent Component

lla (system).

Internals

default-libraries (function).


3.1.5 lla/libraries.lisp

Dependency

configuration.lisp (file).

Source

lla.asd.

Parent Component

lla (system).


3.1.6 lla/conditions.lisp

Dependency

libraries.lisp (file).

Source

lla.asd.

Parent Component

lla (system).

Public Interface

3.1.7 lla/types.lisp

Dependency

conditions.lisp (file).

Source

lla.asd.

Parent Component

lla (system).

Public Interface
Internals

3.1.8 lla/foreign-memory.lisp

Dependency

types.lisp (file).

Source

lla.asd.

Parent Component

lla (system).

Internals

3.1.9 lla/pinned-array.lisp

Dependency

foreign-memory.lisp (file).

Source

lla.asd.

Parent Component

lla (system).

Internals

3.1.10 lla/factorizations.lisp

Dependency

pinned-array.lisp (file).

Source

lla.asd.

Parent Component

lla (system).

Public Interface
Internals

3.1.11 lla/fortran-call.lisp

Dependency

factorizations.lisp (file).

Source

lla.asd.

Parent Component

lla (system).

Public Interface

with-fp-traps-masked (macro).

Internals

3.1.12 lla/linear-algebra.lisp

Dependency

fortran-call.lisp (file).

Source

lla.asd.

Parent Component

lla (system).

Public Interface
Internals

3.1.13 lla/blas.lisp

Dependency

linear-algebra.lisp (file).

Source

lla.asd.

Parent Component

lla (system).

Public Interface

4 Packages

Packages are listed by definition order.


4.1 lla

Source

package.lisp.

Use List
  • alexandria.
  • anaphora.
  • cffi.
  • common-lisp.
  • let-plus.
  • num-utils.
  • select.
Public Interface
Internals

5 Definitions

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


5.1 Public Interface


5.1.1 Special variables

Special Variable: *lla-efficiency-warning-array-conversion*

Toggles whether conversion of array elements to another type when used with foreign functions raises an LLA-EFFICIENCY-WARNING-ARRAY-CONVERSION warning.

Effective only when LLA was loaded & compiled with the appropriate settings in CL-USER::*LLA-CONFIGURATION*. See the documentation on configuration in the README.

Package

lla.

Source

conditions.lisp.

Special Variable: *lla-efficiency-warning-array-type*

Toggles whether arrays with types not recognized as LLA types raise an LLA-EFFICIENCY-WARNING-ARRAY-TYPE warning.

Effective only when LLA was loaded & compiled with the appropriate settings in CL-USER::*LLA-CONFIGURATION*. See the documentation on configuration in the README.

Package

lla.

Source

conditions.lisp.


5.1.2 Macros

Macro: with-fp-traps-masked (&body body)
Package

lla.

Source

fortran-call.lisp.


5.1.3 Ordinary functions

Function: asum (x &key n incx)

Return the L1 norm of X.

Package

lla.

Source

blas.lisp.

Function: axpy! (alpha x y &key n incx incy)
Package

lla.

Source

blas.lisp.

Function: copy! (x y &key n incx incy)
Package

lla.

Source

blas.lisp.

Function: det (matrix)

Determinant of a matrix. If you need the log of this, use LOGDET directly.

Package

lla.

Source

linear-algebra.lisp.

Function: dot (x y &key n incx incy)
Package

lla.

Source

blas.lisp.

Function: eigenvalues (a &key abstol)

Return the eigenvalues of A. See the documentation of SPECTRAL-FACTORIZATION about ABSTOL.

Package

lla.

Source

linear-algebra.lisp.

Function: gemm! (alpha a b beta c &key transpose-a? transpose-b? m n k lda ldb ldc)

Basically C = ALPHA * A’ * B’ + BETA * C. A’ is A or its transpose depending on TRANSPOSE-A?. B’ is B or its transpose depending on TRANSPOSE-B?. Returns C.

A’ is an MxK matrix. B’ is a KxN matrix. C is an MxN matrix.

LDA is the width of the matrix A (not of A’). If A is not transposed, then K <= LDA, if it’s transposed then M <= LDA.

LDB is the width of the matrix B (not of B’). If B is not transposed, then N <= LDB, if it’s transposed then K <= LDB.

In the example below M=3, N=2, K=5, LDA=6, LDB=3, LDC=4. The cells marked with + do not feature in the calculation.

N
–+
–+
K -B+
–+
–+
+++
K
—–+ –++
M –A–+ -C++
—–+ –++
++++++ ++++

Package

lla.

Source

blas.lisp.

Function: ipiv (object)

Pivot indices, counting from 0, in a format understood by SELECT. Example:

(let+ (((&accessors-r/o lu-l lu-u ipiv) (lu a)))
(num= (select a ipiv) (mm lu-l lu-u) ipiv-inverse t)) ; => T

Package

lla.

Source

factorizations.lisp.

Function: ipiv-inverse (object)

Inverted permutation for pivot indices, in a format understood by SELECT.

Example:

(let+ (((&accessors-r/o lu-l lu-u ipiv-inverse) (lu a)))
(num= a (select (mm lu-l lu-u) ipiv-inverse t))) ; => T

Package

lla.

Source

factorizations.lisp.

Function: least-squares (y x &rest rest &key method &allow-other-keys)
Package

lla.

Source

linear-algebra.lisp.

Function: lu-l (lu)

Return the L part of an LU factorization.

Package

lla.

Source

factorizations.lisp.

Function: lu-u (lu)

Return the U part of an LU factorization.

Package

lla.

Source

factorizations.lisp.

Function: mmm (&rest matrices)

Multiply arguments from left to right using MM.

Package

lla.

Source

linear-algebra.lisp.

Function: nrm2 (x &key n incx)

Return the L2 norm of X.

Package

lla.

Source

blas.lisp.

Function: qr-r (qr)

Return the R part of a QR factorization.

Package

lla.

Source

factorizations.lisp.

Function: scal! (alpha x &key n incx)

X = alpha * X.

Package

lla.

Source

blas.lisp.

Function: spectral-factorization (a &key abstol)

Return a spectral factorization of A.

The LAPACK manual says the following about ABSTOL:

The absolute error tolerance for the eigenvalues. An approximate eigenvalue is accepted as converged when it is determined to lie in an interval [a,b] of width less than or equal to

ABSTOL + EPS * max( |a|,|b| ) ,

where EPS is the machine precision. If ABSTOL is less than or equal to zero, then EPS*|T| will be used in its place, where |T| is the 1-norm of the tridiagonal matrix obtained by reducing A to tridiagonal form.

See "Computing Small Singular Values of Bidiagonal Matrices with Guaranteed High Relative Accuracy," by Demmel and Kahan, LAPACK Working Note #3.

If high relative accuracy is important, set ABSTOL to DLAMCH( ’Safe minimum’). Doing so will guarantee that eigenvalues are computed to high relative accuracy when possible in future releases. The current code does not make any guarantees about high relative accuracy, but furutre releases will. See J. Barlow and J. Demmel, "Computing Accurate Eigensystems of Scaled Diagonally Dominant Matrices", LAPACK Working Note #7, for a discussion of which matrices define their eigenvalues to high relative accuracy.

Package

lla.

Source

linear-algebra.lisp.

Reader: spectral-factorization-w (instance)
Writer: (setf spectral-factorization-w) (instance)
Package

lla.

Source

factorizations.lisp.

Target Slot

w.

Reader: spectral-factorization-z (instance)
Writer: (setf spectral-factorization-z) (instance)
Package

lla.

Source

factorizations.lisp.

Target Slot

z.

Reader: svd-d (instance)
Writer: (setf svd-d) (instance)
Package

lla.

Source

factorizations.lisp.

Target Slot

d.

Reader: svd-u (instance)
Writer: (setf svd-u) (instance)
Package

lla.

Source

factorizations.lisp.

Target Slot

u.

Reader: svd-vt (instance)
Writer: (setf svd-vt) (instance)
Package

lla.

Source

factorizations.lisp.

Target Slot

vt.

Function: xx (left-square-root)

Convenience function to create a matrix from a left square root.

Package

lla.

Source

factorizations.lisp.


5.1.4 Generic functions

Generic Function: cholesky (a)

Cholesky factorization.

Package

lla.

Source

linear-algebra.lisp.

Methods
Method: cholesky ((a hermitian-matrix))
Generic Function: hermitian-factorization (a)

Compute the hermitian factorization.

Package

lla.

Source

linear-algebra.lisp.

Methods
Method: hermitian-factorization ((a hermitian-matrix))
Generic Function: invert (a &key tolerance &allow-other-keys)

Invert A. The inverse of matrix factorizations are other factorizations when appropriate, otherwise the result is a matrix. Usage note: inverting dense matrices is unnecessary and unwise in most cases, because it is numerically unstable. If you are solving many Ax=b equations with the same A, use a matrix factorization like LU.

Package

lla.

Source

linear-algebra.lisp.

Methods
Method: invert ((diagonal diagonal-matrix) &key tolerance)

For pseudoinverse, suppressing diagonal elements below TOLERANCE (if given, otherwise / is just used without any checking.

Method: invert ((a cholesky) &key)
Method: invert ((a lower-triangular-matrix) &key)
Method: invert ((a upper-triangular-matrix) &key)
Method: invert ((a hermitian-matrix) &key)
Method: invert ((a hermitian-factorization) &key)
Method: invert ((lu lu) &key)
Method: invert ((a array) &key)
Generic Function: invert-xx (xx)

Calculate (X^T X)-1 (which is used for calculating the variance of estimates) and return as a decomposition. Usually XX is a decomposition itself, eg QR returned by least squares. Note: this can be used to generate random draws, etc.

Package

lla.

Source

linear-algebra.lisp.

Methods
Method: invert-xx ((qr qr))
Generic Function: left-square-root (a)

Return X such that XX^T=A.

Package

lla.

Source

factorizations.lisp.

Methods
Method: left-square-root ((a diagonal-matrix))
Source

linear-algebra.lisp.

Method: left-square-root ((hermitian-matrix hermitian-matrix))
Source

linear-algebra.lisp.

Method: left-square-root ((a matrix-square-root))
Generic Function: logdet (matrix)

Logarithm of the determinant of a matrix. Return -1, 1 or 0 (or equivalent) to correct for the sign, as a second value.

Package

lla.

Source

linear-algebra.lisp.

Methods
Method: logdet ((matrix upper-triangular-matrix))
Method: logdet ((matrix lower-triangular-matrix))
Method: logdet ((matrix array))
Generic Function: lu (a)

LU decomposition of A

Package

lla.

Source

linear-algebra.lisp.

Methods
Method: lu ((a array))
Generic Function: mm (a b)

Matrix multiplication of A and B.

Package

lla.

Source

linear-algebra.lisp.

Methods
Method: mm ((a (eql t)) (b diagonal-matrix))
Method: mm ((a diagonal-matrix) (b (eql t)))
Method: mm ((a diagonal-matrix) (b diagonal-matrix))
Method: mm ((a diagonal-matrix) (b vector))
Method: mm ((a vector) (b diagonal-matrix))
Method: mm ((a array) (b diagonal-matrix))
Method: mm ((a diagonal-matrix) (b array))
Method: mm ((a (eql t)) (b vector))
Method: mm ((a vector) (b (eql t)))
Method: mm ((a vector) (b vector))
Method: mm (a (b wrapped-matrix))
Method: mm ((a wrapped-matrix) b)
Method: mm ((a wrapped-matrix) (b wrapped-matrix))
Method: mm ((a (eql t)) (b array))
Method: mm ((a array) (b (eql t)))
Method: mm ((a array) (b array))
Method: mm (a b)
Generic Function: outer (a b)

Return the outer product column(a) row(b)^H. If either A or B is T, they are taken to be conjugate transposes of the other argument.

Package

lla.

Source

linear-algebra.lisp.

Methods
Method: outer ((a vector) (b (eql t)))
Method: outer ((a (eql t)) (b vector))
Method: outer ((a vector) (b vector))
Generic Function: qr (object)
Package

lla.

Methods
Method: qr ((a array))
Source

linear-algebra.lisp.

Reader Method: qr ((qr qr))

matrix storing the QR factorization.

Source

factorizations.lisp.

Target Slot

qr.

Generic Function: right-square-root (a)

Return Y such that Y^T Y=A.

Efficiency note: decompositions should store the left square root X, and compute Y=X^T on demand, so getting X directly might be more efficient if you don’t need X^T.

Package

lla.

Source

factorizations.lisp.

Methods
Method: right-square-root ((a matrix-square-root))
Method: right-square-root (a)
Generic Function: solve (a b)

Return X that solves AX=B. When B is a vector, so is X.

Package

lla.

Source

linear-algebra.lisp.

Methods
Method: solve ((a diagonal-matrix) b)
Method: solve ((a upper-triangular-matrix) b)
Method: solve ((a lower-triangular-matrix) b)
Method: solve ((a hermitian-matrix) (b array))
Method: solve ((a hermitian-factorization) (b array))
Method: solve ((hermitian-matrix hermitian-matrix) b)
Method: solve ((cholesky cholesky) b)
Method: solve ((a array) (b array))
Method: solve ((lu lu) (b array))
Method: solve (a (b wrapped-matrix))
Generic Function: svd (a &optional vectors)

Return singular value decomposition A.

VECTORS determines how singular vectors are calculated:

- NIL sets U and VT to NIL
- :ALL makes U and VT square, with dimensions conforming to A
- :THIN makes the larger of U and VT rectangular. This means that not all of the singular vectors are calculates, and saves computational time when A is far from square.

Package

lla.

Source

linear-algebra.lisp.

Methods
Method: svd ((a array) &optional vectors)
Generic Function: tr (a)

Trace of a square matrix.

Package

lla.

Source

linear-algebra.lisp.

Methods
Method: tr ((a array))
Method: tr ((a wrapped-matrix))
Method: tr ((a diagonal-matrix))

5.1.5 Standalone methods

Method: as-array ((svd svd))
Package

array-operations/generic.

Source

linear-algebra.lisp.

Method: as-array ((sf spectral-factorization))
Package

array-operations/generic.

Source

linear-algebra.lisp.

Method: as-array ((matrix-square-root matrix-square-root))
Package

array-operations/generic.

Source

linear-algebra.lisp.

Method: e2* ((a number) (b matrix-square-root))
Package

num-utils.elementwise.

Source

factorizations.lisp.

Method: e2* ((a matrix-square-root) (b number))
Package

num-utils.elementwise.

Source

factorizations.lisp.

Method: e2+ (a (b matrix-square-root))
Package

num-utils.elementwise.

Source

factorizations.lisp.

Method: e2+ ((a matrix-square-root) b)
Package

num-utils.elementwise.

Source

factorizations.lisp.

Method: e2/ ((a matrix-square-root) (b number))
Package

num-utils.elementwise.

Source

factorizations.lisp.

Method: print-object ((lu lu) stream)
Source

factorizations.lisp.

Method: print-object ((object lla-efficiency-warning-array-type) stream)
Source

conditions.lisp.


5.1.6 Conditions

Condition: lapack-error

The LAPACK procedure returned a nonzero info code.

Package

lla.

Source

conditions.lisp.

Direct superclasses

error.

Direct subclasses
Condition: lapack-failure

Superclass of all LAPACK errors with a positive INFO

Package

lla.

Source

conditions.lisp.

Direct superclasses

lapack-error.

Direct subclasses

lapack-singular-matrix.

Direct slots
Slot: info

INFO corresponding to error message.

Initargs

:info

Condition: lapack-invalid-argument

An argument to a LAPACK procedure had an illegal value. It is very likely that this indicates a bug in LLA and should not happen.

Package

lla.

Source

conditions.lisp.

Direct superclasses
Direct slots
Slot: position

Position of the illegal argument

Package

common-lisp.

Initargs

:position

Condition: lapack-singular-matrix
Package

lla.

Source

conditions.lisp.

Direct superclasses

lapack-failure.

Condition: lla-efficiency-warning
Package

lla.

Source

conditions.lisp.

Direct superclasses

warning.

Direct subclasses
Condition: lla-efficiency-warning-array-conversion
Package

lla.

Source

conditions.lisp.

Direct superclasses

lla-efficiency-warning.

Direct slots
Slot: array

The array that had to be copied.

Package

common-lisp.

Initargs

:array

Slot: type

Required element type.

Package

common-lisp.

Initargs

:type

Condition: lla-efficiency-warning-array-type

See *LLA-EFFICIENCY-WARNING-ARRAY-TYPE*.

Package

lla.

Source

conditions.lisp.

Direct superclasses

lla-efficiency-warning.

Direct methods

print-object.

Direct slots
Slot: array
Package

common-lisp.

Initargs

:array

Condition: lla-incompatible-dimensions
Package

lla.

Source

conditions.lisp.

Direct superclasses

lapack-error.

Condition: lla-internal-error

Internal error in LLA.

Package

lla.

Source

conditions.lisp.

Direct superclasses

error.

Direct subclasses

lapack-invalid-argument.

Direct slots
Slot: message
Initform

(quote "")

Initargs

:message

Condition: lla-unhandled-type

Could not classify object as a numeric type handled by LLA.

Package

lla.

Source

conditions.lisp.

Direct superclasses

error.

Direct slots
Slot: object
Initform

(quote :object)


5.1.7 Structures

Structure: cholesky

Cholesky factorization a matrix.

Package

lla.

Source

factorizations.lisp.

Direct superclasses

matrix-square-root.

Direct methods
Structure: matrix-square-root

General class for representing XX^T decompositions of matrices, regardless of how they were computed. The convention is to store X, the left square root.

Package

lla.

Source

factorizations.lisp.

Direct superclasses

structure-object.

Direct subclasses

cholesky.

Direct methods
Direct slots
Slot: left
Package

num-utils.interval.

Readers

matrix-square-root-left.

Writers

(setf matrix-square-root-left).

Structure: spectral-factorization

Z W Z^T factorization of a Hermitian matrix, where the columns of Z contain the eigenvectors and W is a diagonal matrix of the eigenvalues. Z is a unitary matrix.

Package

lla.

Source

factorizations.lisp.

Direct superclasses

structure-object.

Direct methods

as-array.

Direct slots
Slot: z
Readers

spectral-factorization-z.

Writers

(setf spectral-factorization-z).

Slot: w
Readers

spectral-factorization-w.

Writers

(setf spectral-factorization-w).

Structure: svd

Singular value decomposition. Singular values are in S, in descending order. U and VT may be NIL in case they are not computed.

Package

lla.

Source

factorizations.lisp.

Direct superclasses

structure-object.

Direct methods

as-array.

Direct slots
Slot: u
Readers

svd-u.

Writers

(setf svd-u).

Slot: d
Readers

svd-d.

Writers

(setf svd-d).

Slot: vt
Readers

svd-vt.

Writers

(setf svd-vt).


5.1.8 Classes

Class: hermitian-factorization

Factorization for an indefinite hermitian matrix with pivoting.

Package

lla.

Source

factorizations.lisp.

Direct superclasses

ipiv-mixin.

Direct methods
Direct slots
Slot: factor

see documentation of *SYTRF and *HETRF, storage is
in the half specified by HERMITIAN-ORIENTATION and otherwise treated as opaque.

Initargs

:factor

Readers

factor.

Writers

This slot is read-only.

Class: lu

LU factorization of a matrix with pivoting. (SELECT A IPIV) is (MM L U), when IPIV is used to obtain the permutation.

Package

lla.

Source

factorizations.lisp.

Direct superclasses

ipiv-mixin.

Direct methods
Direct slots
Slot: lu

matrix storing the transpose of the LU factorization.

Initargs

:lu

Readers

lu-matrix.

Writers

This slot is read-only.

Class: qr

QR factorization of a matrix.

Package

lla.

Source

factorizations.lisp.

Direct methods
Direct slots
Slot: qr

matrix storing the QR factorization.

Initargs

:qr

Readers

qr.

Writers

This slot is read-only.

Slot: tau

complex scalar for elementary reflectors (see documentation of xGEQRF).

Initargs

:tau

Readers

tau.

Writers

(setf tau).


5.1.9 Types

Type: lla-complex-double ()
Package

lla.

Source

types.lisp.

Type: lla-complex-single ()
Package

lla.

Source

types.lisp.

Type: lla-double ()
Package

lla.

Source

types.lisp.

Type: lla-integer ()
Package

lla.

Source

types.lisp.

Type: lla-single ()
Package

lla.

Source

types.lisp.


5.2 Internals


5.2.1 Constants

Constant: +complex-double+
Package

lla.

Source

types.lisp.

Constant: +complex-single+
Package

lla.

Source

types.lisp.

Constant: +double+
Package

lla.

Source

types.lisp.

Constant: +float-types+

List of all internal float types.

Package

lla.

Source

types.lisp.

Constant: +integer+
Package

lla.

Source

types.lisp.

Constant: +internal-types+

List of all internal types.

Package

lla.

Source

types.lisp.

Constant: +single+
Package

lla.

Source

types.lisp.


5.2.2 Symbol macros

Symbol Macro: &info
Package

lla.

Source

fortran-call.lisp.


5.2.3 Macros

Macro: &array-in (input &key type transpose? force-copy?)

Array which serves as an input. See FORTRAN-INPUT-ARRAY.

Package

lla.

Source

fortran-call.lisp.

Macro: &array-in/out ((&key input type transpose? force-copy?) (&key output dimensions type transpose?))

Input/output array. See FORTRAN-INPUT-OUTPUT-ARRAY.

Package

lla.

Source

fortran-call.lisp.

Macro: &array-out (output &key dimensions type transpose?)

Output array. See FORTRAN-OUTPUT-ARRAY.

Package

lla.

Source

fortran-call.lisp.

Macro: &atom (value &key type output)

Atoms passed to FORTRAN. When not given, TYPE is inferred from the call’s default. VALUE is coerced to the desired type. When OUTPUT is given, value is read after the call and placed there.

Package

lla.

Source

fortran-call.lisp.

Macro: &char (character)

Shorthand for character.

Package

lla.

Source

fortran-call.lisp.

Macro: &info (&key condition variable)

Argument for checking whether the call was executed without an error. Automatically takes care of raising the appropriate condition if it wasn’t. CONDITION specifies the condition to raise in case of positive error codes, use NIL to ignore these. VARIABLE can be used to specify

Package

lla.

Source

fortran-call.lisp.

Macro: &integer (value &key output)

Shorthand for integer atom.

Package

lla.

Source

fortran-call.lisp.

Macro: &integers (&rest values)

Shorthand for integer atoms (which are not modified). Useful for combining arguments.

Package

lla.

Source

fortran-call.lisp.

Macro: &new (variable)

Placeholder macro for newly allocated output variables. Using (&NEW VARIABLE) allocates a new array within the scope of the outer macro, and is usually used for output. See &ARRAY-OUT and &ARRAY-IN/OUT.

Package

lla.

Source

fortran-call.lisp.

Macro: &work (size &optional type)

Allocate a work area of SIZE. When TYPE is not given, the call’s default is used.

Package

lla.

Source

fortran-call.lisp.

Macro: &work-query (&optional type)

Work area query, takes the place of TWO fortran arguments.

Package

lla.

Source

fortran-call.lisp.

Macro: array-clause% ((array internal-type clause-element-type clause-internal-type) &body body)

Macro that generates a lambda form that can bed used in EXPAND-SPECIFICATIONS%.

Package

lla.

Source

foreign-memory.lisp.

Macro: blas-call ((name type &optional value return-types) &body forms)

BLAS call. NAME is either a string or a list of two strings (real/complex). TYPE (internal-type) selects the function to call. VALUE is the form returned after the call.

Package

lla.

Source

fortran-call.lisp.

Macro: define-factorization-eops% (type conversion)

Define elementwise operations for TYPE, trying to convert into arrays.

Package

lla.

Source

factorizations.lisp.

Macro: define-foreign-aref ()
Package

lla.

Source

foreign-memory.lisp.

Macro: define-matrix-square-root-scalar-multiplication (type &key make)
Package

lla.

Source

factorizations.lisp.

Macro: lapack-call ((name type value) &body forms)

LAPACK call, takes an &info argument. NAME is either a string or a list of two strings (real/complex). TYPE (internal-type) selects the function to call. VALUE is the form returned after the call.

Package

lla.

Source

fortran-call.lisp.

Macro: lapack-call-w/query ((name type value) &body forms)

LAPACK call which also takes &work-query arguments (in place of two FORTRAN arguments).

Package

lla.

Source

fortran-call.lisp.

Macro: log-with-sign% (value sign-changes block-name)

Log of (ABS VALUE), increments SIGN-CHANGES when negative, return-from block-name (values nil 0) when zero.

Package

lla.

Source

linear-algebra.lisp.

Macro: with-array-input (((pointer &optional copied?) array internal-type transpose? force-copy?) &body body)

Ensure that ARRAY is mapped to a corresponding memory area for the duration of BODY (see below for details of semantics). POINTER is bound to the start of the memory address. The representation of values in the memory is determined by INTERNAL-TYPE. When TRANSPOSE?, transpose the array before BODY (only works for matrices, otherwise signal an error).

If FORCE-COPY? is false, POINTER may or may not point to the memory backing ARRAY.

If FORCE-COPY? is true, POINTER always points to a copy of the contents of ARRAY.

COPIED? is bound to indicate whether POINTER points to a copy or the actual array contents.

The value of the expression is always the value of BODY.

Package

lla.

Source

pinned-array.lisp.

Macro: with-array-input-output (((pointer &optional copied?) input-array input-internal-type input-transpose? input-force-copy? output-array output-internal-type output-transpose?) &body body)

Similar to WITH-ARRAY-INPUT, it also ensures that OUTPUT-ARRAY contains the contents the memory area pointed to by POINTER when BODY is finished. If OUTPUT-ARRAY is NIL then it is equivalent to WITH-ARRAY-INPUT.

Package

lla.

Source

pinned-array.lisp.

Macro: with-array-output (((pointer &optional copied?) array internal-type transpose?) &body body)

Ensure that ARRAY is mapped to a corresponding memory area for the duration of BODY (see below for details of semantics). POINTER is bound to the start of the memory address. The representation of values in the memory is determined by INTERNAL-TYPE. When TRANSPOSE?, transpose the array after BODY (only works for matrices, otherwise signal an error).

COPIED? is bound to indicate whether POINTER points to a copy or the actual array contents.

The value of the expression is always the value of BODY.

Package

lla.

Source

pinned-array.lisp.

Macro: with-fortran-atom ((pointer value type output) &body body)

Allocate memory for internal TYPE and set it to VALUE for body, which can use POINTER to access it. When OUTPUT is given, the value is assigned to it after BODY. The atom is automatically coerced to the correct type (by FOREIGN-AREF).

Package

lla.

Source

foreign-memory.lisp.

Macro: with-fortran-character ((pointer character) &body body)

Make character available in an allocated memory area at POINTER for BODY.

Package

lla.

Source

foreign-memory.lisp.

Macro: with-pinned-array ((pointer array) &body body)
Package

lla.

Source

pinned-array.lisp.

Macro: with-work-area ((pointer internal-type size) &body body)

Allocate a work area of SIZE and INTERNAL-TYPE, and bind the POINTER to its start during BODY.

Package

lla.

Source

pinned-array.lisp.


5.2.4 Ordinary functions

Function: absolute-square-type (internal-type)

Type of (* x (conjugate x)).

Package

lla.

Source

types.lisp.

Function: all-from-specifications% ()

Return an optimization specification for all functions that copy from foreign memory.

Package

lla.

Source

foreign-memory.lisp.

Function: all-to-specifications% ()

Return an optimization specification for all functions that copy to foreign memory.

Package

lla.

Source

foreign-memory.lisp.

Function: argument-pointers (arguments)

Return the list of pointers for all the arguments.

Package

lla.

Source

fortran-call.lisp.

Function: arguments-for-cffi (arguments)

Return a list that can be use in a CFFI call.

Package

lla.

Source

fortran-call.lisp.

Function: array-float-type (array)

Return an (internal) float type for an array. O(1) when the type can be detected from the specialized array element type, O(n) otherwise.

Package

lla.

Source

types.lisp.

Function: assert-single-lapack-info (arguments)

Assert that there is at most one LAPACK-INFO in ARGUMENTS.

Package

lla.

Source

fortran-call.lisp.

Function: backing-array (array)

Return the array in which the contents of ARRAY are stored. For simple arrays, this is always the array itself. The second value is the displacement.

Package

lla.

Source

pinned-array.lisp.

Function: blas-lapack-call-form (type-var name arguments &optional return-types)

Return a form BLAS/LAPACK calls, conditioning on TYPE-VAR. See BLAS-LAPACK-FUNCTION-NAME for the interpretation of FIXME

Package

lla.

Source

fortran-call.lisp.

Function: blas-lapack-function-name (type name)

Return the BLAS/LAPACK foreign function name. TYPE is the internal type, NAME is one of the following: NAME, (NAME), which are used for both complex and real names, or (REAL-NAME COMPLEX-NAME).

Package

lla.

Source

fortran-call.lisp.

Function: blas-return-types (return-types)
Package

lla.

Source

fortran-call.lisp.

Function: cholesky-left (instance)
Package

lla.

Source

factorizations.lisp.

Function: (setf cholesky-left) (instance)
Package

lla.

Source

factorizations.lisp.

Function: cholesky-p (object)
Package

lla.

Source

factorizations.lisp.

Function: common-float-type (&rest arrays-or-numbers)

Return the common (internal) float type for the arguments.

Package

lla.

Source

types.lisp.

Function: complex? (internal-type)

True iff the internal type is complex.

Package

lla.

Source

types.lisp.

Function: copy-array-from-memory (array pointer internal-type)

Copy the memory area of type INTERNAL-TYPE at POINTER to ARRAY.

Package

lla.

Source

foreign-memory.lisp.

Function: copy-array-to-memory (array pointer internal-type)

Copy the contents of ARRAY to the memory area of type INTERNAL-TYPE at POINTER.

Package

lla.

Source

foreign-memory.lisp.

Function: copy-cholesky (instance)
Package

lla.

Source

factorizations.lisp.

Function: copy-matrix-square-root (instance)
Package

lla.

Source

factorizations.lisp.

Function: copy-spectral-factorization (instance)
Package

lla.

Source

factorizations.lisp.

Function: copy-svd (instance)
Package

lla.

Source

factorizations.lisp.

Function: count-permutations% (ipiv-internal)

Count the permutations in a pivoting vector.

Package

lla.

Source

factorizations.lisp.

Function: create-array-from-memory (pointer internal-type dimensions &optional element-type)

Create an array from contents at POINTER.

Package

lla.

Source

foreign-memory.lisp.

Function: create-transposed-matrix-from-memory (pointer internal-type dimensions &optional element-type)

Create a matrix from transposed contents at POINTER.

Package

lla.

Source

foreign-memory.lisp.

Function: default-libraries ()

Return a list of libraries. The source conditions on the platform, relying TRIVIAL-FEATURES. This function is only called when the libraries were not configured by the user, see the documentation on how to do that.

Package

lla.

Source

configuration.lisp.

Function: diagonal-log-sum% (matrix &optional sign-changes)

Sum of the log of the elements in the diagonal. Sign-changes counts the negative values, and may be started at something else than 0 (eg in case of pivoting). Return (values NIL 0) in case of encountering a 0.

Package

lla.

Source

linear-algebra.lisp.

Function: dimensions-as-matrix (array orientation)

If ARRAY is a vector, return its dimensions as a matrix with given ORIENTATION (:ROW or :COLUMN) as multiple values, and T as the third value. If it is matrix, just return the dimensions and NIL. Used for considering vectors as conforming matrices (eg see MM).

Package

lla.

Source

linear-algebra.lisp.

Function: epsilon (internal-type)

Return the float epsilon for the given internal float type.

Package

lla.

Source

types.lisp.

Function: expand-specifications% (clause specifications)

Expand specifications using (clause internal-type element-type).

Package

lla.

Source

foreign-memory.lisp.

Function: foreign-size (type)

Return the size of an internal type in bytes.

Package

lla.

Source

foreign-memory.lisp.

Function: fortran-argument/new-variable (form)

If FORM is (&NEW VARIABLE), return VARIABLE, otherwise NIL.

Package

lla.

Source

fortran-call.lisp.

Function: invert-triangular% (a upper? unit-diag?)

Invert a dense (triangular) matrix using the LAPACK routine *TRTRI. UPPER? indicates if the matrix is in the upper or the lower triangle of a matrix, UNIT-DIAG? indicates whether the diagonal is supposed to consist of 1s. For internal use, not exported.

Package

lla.

Source

linear-algebra.lisp.

Function: lapack-info-wrap-argument (argument body)

Generate a wrapper for a LAPACK INFO argument, also checking the result and raising a condition if applicable. Useful for WRAP-ARGUMENT.

Package

lla.

Source

fortran-call.lisp.

Function: last-rows-ss (matrix nrhs common-type)

Calculate the sum of squares of the last rows of MATRIX columnwise,
omitting the first NRHS rows. If MATRIX is a vector, just do this for the last elements. Used for interfacing with xGELS.

Package

lla.

Source

linear-algebra.lisp.

Function: least-squares-qr (y x &key &allow-other-keys)

Least squares using QR decomposition. Additional values returned: the QR decomposition of X. See LEAST-SQUARES for additional documentation. Usage note: SVD-based methods are recommended over this one, unless X is well-conditioned.

Package

lla.

Source

linear-algebra.lisp.

Function: lisp-type (internal-type)
Package

lla.

Source

types.lisp.

Function: make-cholesky (left)
Package

lla.

Source

factorizations.lisp.

Function: make-cholesky% (left)
Package

lla.

Source

factorizations.lisp.

Function: make-matrix-square-root (left)
Package

lla.

Source

factorizations.lisp.

Function: make-spectral-factorization (&key z w)
Package

lla.

Source

factorizations.lisp.

Function: make-svd (&key u d vt)
Package

lla.

Source

factorizations.lisp.

Reader: matrix-square-root-left (instance)
Writer: (setf matrix-square-root-left) (instance)
Package

lla.

Source

factorizations.lisp.

Target Slot

left.

Function: matrix-square-root-p (object)
Package

lla.

Source

factorizations.lisp.

Function: maybe-default-type (type parameters)

Return default type from PARAMETERS when TYPE is NIL.

Package

lla.

Source

fortran-call.lisp.

Function: mm-hermitian% (a transpose-left?)

Calculate A*op(A) if TRANSPOSE-LEFT? is NIL, and op(A)*A otherwise. op() is always conjugate transpose, but may be implemented as a transpose if A is real, in which case the two are equivalent. This function is meant to be used internally, and is not exported.

Package

lla.

Source

linear-algebra.lisp.

Function: number-float-type (number)

Return an (internal) float type for a number.

Package

lla.

Source

types.lisp.

Function: output-array-form (form)

Return a form that can be passed to WITH-OUTPUT-ARRAY (or similar) as an output. The variable is extracted from &NEW forms, otherwise the form is passed as is.

Package

lla.

Source

fortran-call.lisp.

Function: process-forms (forms environment)

Process forms and return a list of argument specifications. A form may correspond to multiple arguments.

Package

lla.

Source

fortran-call.lisp.

Function: query-configuration (indicator &optional default)

Return the property for INDICATOR from the configuration variable, with an optional default, which can be a function (called on demand).

Package

lla.

Source

configuration-interface.lisp.

Function: set-feature (symbol set?)

Ensure that symbol is in *FEATURES* iff SET?. Returns no values.

Package

lla.

Source

configuration-interface.lisp.

Function: shareable-array? (array internal-type)
Package

lla.

Source

pinned-array.lisp.

Function: spectral-factorization-p (object)
Package

lla.

Source

factorizations.lisp.

Function: sum-diagonal% (array)

Sum diagonal of array, checking that it is square.

Package

lla.

Source

linear-algebra.lisp.

Function: svd-p (object)
Package

lla.

Source

factorizations.lisp.

Function: transpose-matrix-from-memory (matrix pointer internal-type)

Transpose the contents of ARRAY to the memory area of type INTERNAL-TYPE at POINTER. VECTORs are also handled.

Package

lla.

Source

foreign-memory.lisp.

Function: transpose-matrix-to-memory (matrix pointer internal-type)

Transpose the contents of ARRAY to the memory area of type INTERNAL-TYPE at POINTER. VECTORs are also handled.

Package

lla.

Source

foreign-memory.lisp.

Function: trsm% (a a-upper? b)

Wrapper for BLAS routine xTRSM. Solve AX=B, where A is triangular.

Package

lla.

Source

linear-algebra.lisp.

Function: value-from-memory% (internal-type)

Return a (LAMBDA (POINTER INDEX) ...) form that can be used to read an element from an array in memory.

Package

lla.

Source

foreign-memory.lisp.

Function: value-to-memory% (internal-type)

Return a (LAMBDA (POINTER INDEX VALUE) ...) form that can be used to write an element to an array in memory.

Package

lla.

Source

foreign-memory.lisp.

Function: wrap-arguments (arguments pass parameters body)

Wrap BODY in arguments. Convenience function used to implement the expansion.

Package

lla.

Source

fortran-call.lisp.


5.2.5 Generic functions

Generic Reader: argument-pointer (object)
Package

lla.

Methods
Reader Method: argument-pointer ((fortran-argument fortran-argument))

Pointer passed to FORTRAN.

Source

fortran-call.lisp.

Target Slot

pointer.

Generic Reader: factor (object)
Package

lla.

Methods
Reader Method: factor ((hermitian-factorization hermitian-factorization))

see documentation of *SYTRF and *HETRF, storage is
in the half specified by HERMITIAN-ORIENTATION and otherwise treated as opaque.

Source

factorizations.lisp.

Target Slot

factor.

Generic Function: fortran-argument/output-initializer-form (argument parameters)

When applicable, return a form that is used to initialize the OUTPUT variable. When NIL is returned, no binding is established.

Package

lla.

Source

fortran-call.lisp.

Methods
Method: fortran-argument/output-initializer-form ((argument fortran-input-output-array) parameters)
Method: fortran-argument/output-initializer-form ((argument fortran-output-array) parameters)
Method: fortran-argument/output-initializer-form ((argument fortran-argument/output) parameters)
Generic Reader: ipiv-internal (object)
Package

lla.

Methods
Reader Method: ipiv-internal ((ipiv-mixin ipiv-mixin))

pivot indices in LAPACK’s representation, counting from 1

Source

factorizations.lisp.

Target Slot

ipiv-internal.

Generic Reader: lu-matrix (object)
Package

lla.

Methods
Reader Method: lu-matrix ((lu lu))

matrix storing the transpose of the LU factorization.

Source

factorizations.lisp.

Target Slot

lu.

Generic Function: permutations (object)

Return the number of permutations in object (which is usually a matrix factorization, or a pivot index.

Package

lla.

Source

factorizations.lisp.

Methods
Method: permutations ((lu lu))
Generic Function: process-form (form environment)

Return a list of argument specifications (atoms are converted into lists).

The code in this file defines a DSL for calling BLAS and LAPACK procedures in FORTRAN, which expect pointers to memory locations. The high-level macros BLAS-CALL and LAPACK-CALL take care of pinning arrays or allocating memory and copying array contents (when applicable), and use PROCESS-FORM to interpret their arguments, which correspond to one or more FORTRAN arguments. These are then expanded into code using WRAP-ARGUMENT.

Package

lla.

Source

fortran-call.lisp.

Methods
Method: process-form ((form (eql 1)) env)
Method: process-form ((form (eql 0)) env)
Method: process-form ((form character) env)
Method: process-form ((form null) environment)
Method: process-form (form environment)
Generic Reader: tau (object)
Generic Writer: (setf tau) (object)
Package

lla.

Methods
Reader Method: tau ((qr qr))
Writer Method: (setf tau) ((qr qr))

complex scalar for elementary reflectors (see documentation of xGEQRF).

Source

factorizations.lisp.

Target Slot

tau.

Generic Function: wrap-argument (argument pass parameters body)

Return BODY wrapped in an environment generated for ARGUMENT in a given PASS.

The code for calling the function is built using nested calls of WRAP-ARGUMENT. The setup is somewhat complicated because some functions require that they are called twice (eg in order to calculate work area size), and we don’t necessarily want to allocate and free memory twice. Because of this, expansions take place in ’passes’.

Currently, the following passes are used:

- BINDINGS: establishes the bindings (also empty variables)

- MAIN: for arguments that are the same regardless of what kind of call is made

- QUERY: for querying work area sizes

- CALL: the actual function call

PARAMETERS is used to specify information that is applicable for all arguments (eg a default array element type).

Package

lla.

Source

fortran-call.lisp.

Methods
Method: wrap-argument ((argument lapack-work-query-size) (pass (eql lla::call)) parameters body)
Method: wrap-argument ((argument lapack-work-query-area) (pass (eql lla::call)) parameters body)
Method: wrap-argument ((argument lapack-work-query-size) (pass (eql lla::query)) parameters body)
Method: wrap-argument ((argument lapack-work-query-area) (pass (eql lla::query)) parameters body)
Method: wrap-argument ((argument lapack-work-query-area) (pass (eql lla::bindings)) parameters body)
Method: wrap-argument ((argument lapack-info) (pass (eql lla::query)) parameters body)
Method: wrap-argument ((argument lapack-info) (pass (eql lla::call)) parameters body)
Method: wrap-argument ((argument fortran-work-area) (pass (eql lla::main)) parameters body)
Method: wrap-argument ((argument fortran-input-output-array) (pass (eql lla::main)) parameters body)
Method: wrap-argument ((argument fortran-output-array) (pass (eql lla::main)) parameters body)
Method: wrap-argument ((argument fortran-input-array) (pass (eql lla::main)) parameters body)
Method: wrap-argument ((argument fortran-atom) (pass (eql lla::main)) parameters body)
Method: wrap-argument ((argument fortran-character) (pass (eql lla::main)) parameters body)
Method: wrap-argument ((argument fortran-argument/output) (pass (eql lla::bindings)) parameters body)
Method: wrap-argument (argument pass parameters body)

5.2.6 Classes

Class: fortran-argument

Superclass of all arguments with pointers.

Package

lla.

Source

fortran-call.lisp.

Direct subclasses
Direct methods

argument-pointer.

Direct slots
Slot: pointer

Pointer passed to FORTRAN.

Initform

(gensym)

Initargs

:pointer

Readers

argument-pointer.

Writers

This slot is read-only.

Class: fortran-argument/output

Class for arguments that return an output. When FORTRAN-ARGUMENT/OUTPUT-INITIALIZER-FORM returns non-NIL, a local binding of OUTPUT to this form will be wrapped around the relevant BODY. Also see &NEW.

Package

lla.

Source

fortran-call.lisp.

Direct superclasses

fortran-argument.

Direct subclasses
Direct methods
Direct slots
Slot: output

Lisp variable or initialization form mapped to an output.

Initargs

:output

Class: fortran-argument/size

Number of elements in array mapped to a pointer.

Package

lla.

Source

fortran-call.lisp.

Direct superclasses

fortran-argument.

Direct subclasses
Direct slots
Slot: size

Number of elements.

Initargs

:size

Class: fortran-argument/type

For arguments which may have multiple types, mostly arrays or atoms (implemented as single-cell arrays).

Package

lla.

Source

fortran-call.lisp.

Direct superclasses

fortran-argument.

Direct subclasses
Direct slots
Slot: type

Determines (internal) type for array mapped to the pointer.

Package

common-lisp.

Initargs

:type

Class: fortran-atom

Atoms passed to FORTRAN. Input/output (when OUTPUT is given).

Package

lla.

Source

fortran-call.lisp.

Direct superclasses
Direct methods

wrap-argument.

Direct slots
Slot: value
Initargs

:value

Class: fortran-character

Character passed to FORTRAN. Input only, for specifying triangle orientation, etc.

Package

lla.

Source

fortran-call.lisp.

Direct superclasses

fortran-argument.

Direct methods

wrap-argument.

Direct slots
Slot: character
Package

common-lisp.

Initargs

:character

Class: fortran-input-array

Arrays which serve as inputs. See WITH-ARRAY-INPUT for the semantics of the arguments.

Package

lla.

Source

fortran-call.lisp.

Direct superclasses

fortran-argument.

Direct subclasses

fortran-input-output-array.

Direct methods

wrap-argument.

Direct slots
Slot: input
Initargs

:input

Slot: input-type
Initargs

:input-type

Slot: input-transpose?
Initargs

:input-transpose?

Slot: input-force-copy?
Initargs

:input-force-copy?

Class: fortran-input-output-array

Input/output array. See WITH-ARRAY-INPUT-OUTPUT for the semantics of the arguments.

Package

lla.

Source

fortran-call.lisp.

Direct superclasses
Direct methods
Class: fortran-output-array

Output array. See WITH-ARRAY-OUTPUT for the semantics of the arguments.

Package

lla.

Source

fortran-call.lisp.

Direct superclasses

fortran-argument/output.

Direct subclasses

fortran-input-output-array.

Direct methods
Direct slots
Slot: output
Initargs

:output

Slot: output-dimensions
Initargs

:output-dimensions

Slot: output-type
Initargs

:output-type

Slot: output-transpose?
Initargs

:output-transpose?

Class: fortran-work-area

Work area.

Package

lla.

Source

fortran-call.lisp.

Direct superclasses
Direct methods

wrap-argument.

Class: ipiv-mixin

Mixin class for objects with pivoting.

Package

lla.

Source

factorizations.lisp.

Direct subclasses
Direct methods

ipiv-internal.

Direct slots
Slot: ipiv-internal

pivot indices in LAPACK’s representation, counting from 1

Type

vector

Initargs

:ipiv-internal

Readers

ipiv-internal.

Writers

This slot is read-only.

Class: lapack-info

Information from a LAPACK call. See the LAPACK manual for error codes.

Package

lla.

Source

fortran-call.lisp.

Direct superclasses

fortran-argument.

Direct methods
Direct slots
Slot: condition
Package

common-lisp.

Initargs

:condition

Slot: variable
Package

common-lisp.

Initargs

:variable

Class: lapack-work-query-area
Package

lla.

Source

fortran-call.lisp.

Direct superclasses
Direct methods
Class: lapack-work-query-size
Package

lla.

Source

fortran-call.lisp.

Direct superclasses

fortran-argument/size.

Direct methods

5.2.7 Types

Type: float-type ()
Package

lla.

Source

types.lisp.

Type: internal-type ()
Package

lla.

Source

types.lisp.

Type: maximum-array-size ()
Package

lla.

Source

foreign-memory.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

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

&
&array-in: Private macros
&array-in/out: Private macros
&array-out: Private macros
&atom: Private macros
&char: Private macros
&info: Private macros
&integer: Private macros
&integers: Private macros
&new: Private macros
&work: Private macros
&work-query: Private macros

(
(setf cholesky-left): Private ordinary functions
(setf matrix-square-root-left): Private ordinary functions
(setf spectral-factorization-w): Public ordinary functions
(setf spectral-factorization-z): Public ordinary functions
(setf svd-d): Public ordinary functions
(setf svd-u): Public ordinary functions
(setf svd-vt): Public ordinary functions
(setf tau): Private generic functions
(setf tau): Private generic functions

A
absolute-square-type: Private ordinary functions
all-from-specifications%: Private ordinary functions
all-to-specifications%: Private ordinary functions
argument-pointer: Private generic functions
argument-pointer: Private generic functions
argument-pointers: Private ordinary functions
arguments-for-cffi: Private ordinary functions
array-clause%: Private macros
array-float-type: Private ordinary functions
as-array: Public standalone methods
as-array: Public standalone methods
as-array: Public standalone methods
assert-single-lapack-info: Private ordinary functions
asum: Public ordinary functions
axpy!: Public ordinary functions

B
backing-array: Private ordinary functions
blas-call: Private macros
blas-lapack-call-form: Private ordinary functions
blas-lapack-function-name: Private ordinary functions
blas-return-types: Private ordinary functions

C
cholesky: Public generic functions
cholesky: Public generic functions
cholesky-left: Private ordinary functions
cholesky-p: Private ordinary functions
common-float-type: Private ordinary functions
complex?: Private ordinary functions
copy!: Public ordinary functions
copy-array-from-memory: Private ordinary functions
copy-array-to-memory: Private ordinary functions
copy-cholesky: Private ordinary functions
copy-matrix-square-root: Private ordinary functions
copy-spectral-factorization: Private ordinary functions
copy-svd: Private ordinary functions
count-permutations%: Private ordinary functions
create-array-from-memory: Private ordinary functions
create-transposed-matrix-from-memory: Private ordinary functions

D
default-libraries: Private ordinary functions
define-factorization-eops%: Private macros
define-foreign-aref: Private macros
define-matrix-square-root-scalar-multiplication: Private macros
det: Public ordinary functions
diagonal-log-sum%: Private ordinary functions
dimensions-as-matrix: Private ordinary functions
dot: Public ordinary functions

E
e2*: Public standalone methods
e2*: Public standalone methods
e2+: Public standalone methods
e2+: Public standalone methods
e2/: Public standalone methods
eigenvalues: Public ordinary functions
epsilon: Private ordinary functions
expand-specifications%: Private ordinary functions

F
factor: Private generic functions
factor: Private generic functions
foreign-size: Private ordinary functions
fortran-argument/new-variable: Private ordinary functions
fortran-argument/output-initializer-form: Private generic functions
fortran-argument/output-initializer-form: Private generic functions
fortran-argument/output-initializer-form: Private generic functions
fortran-argument/output-initializer-form: Private generic functions
Function, (setf cholesky-left): Private ordinary functions
Function, (setf matrix-square-root-left): Private ordinary functions
Function, (setf spectral-factorization-w): Public ordinary functions
Function, (setf spectral-factorization-z): Public ordinary functions
Function, (setf svd-d): Public ordinary functions
Function, (setf svd-u): Public ordinary functions
Function, (setf svd-vt): Public ordinary functions
Function, absolute-square-type: Private ordinary functions
Function, all-from-specifications%: Private ordinary functions
Function, all-to-specifications%: Private ordinary functions
Function, argument-pointers: Private ordinary functions
Function, arguments-for-cffi: Private ordinary functions
Function, array-float-type: Private ordinary functions
Function, assert-single-lapack-info: Private ordinary functions
Function, asum: Public ordinary functions
Function, axpy!: Public ordinary functions
Function, backing-array: Private ordinary functions
Function, blas-lapack-call-form: Private ordinary functions
Function, blas-lapack-function-name: Private ordinary functions
Function, blas-return-types: Private ordinary functions
Function, cholesky-left: Private ordinary functions
Function, cholesky-p: Private ordinary functions
Function, common-float-type: Private ordinary functions
Function, complex?: Private ordinary functions
Function, copy!: Public ordinary functions
Function, copy-array-from-memory: Private ordinary functions
Function, copy-array-to-memory: Private ordinary functions
Function, copy-cholesky: Private ordinary functions
Function, copy-matrix-square-root: Private ordinary functions
Function, copy-spectral-factorization: Private ordinary functions
Function, copy-svd: Private ordinary functions
Function, count-permutations%: Private ordinary functions
Function, create-array-from-memory: Private ordinary functions
Function, create-transposed-matrix-from-memory: Private ordinary functions
Function, default-libraries: Private ordinary functions
Function, det: Public ordinary functions
Function, diagonal-log-sum%: Private ordinary functions
Function, dimensions-as-matrix: Private ordinary functions
Function, dot: Public ordinary functions
Function, eigenvalues: Public ordinary functions
Function, epsilon: Private ordinary functions
Function, expand-specifications%: Private ordinary functions
Function, foreign-size: Private ordinary functions
Function, fortran-argument/new-variable: Private ordinary functions
Function, gemm!: Public ordinary functions
Function, invert-triangular%: Private ordinary functions
Function, ipiv: Public ordinary functions
Function, ipiv-inverse: Public ordinary functions
Function, lapack-info-wrap-argument: Private ordinary functions
Function, last-rows-ss: Private ordinary functions
Function, least-squares: Public ordinary functions
Function, least-squares-qr: Private ordinary functions
Function, lisp-type: Private ordinary functions
Function, lu-l: Public ordinary functions
Function, lu-u: Public ordinary functions
Function, make-cholesky: Private ordinary functions
Function, make-cholesky%: Private ordinary functions
Function, make-matrix-square-root: Private ordinary functions
Function, make-spectral-factorization: Private ordinary functions
Function, make-svd: Private ordinary functions
Function, matrix-square-root-left: Private ordinary functions
Function, matrix-square-root-p: Private ordinary functions
Function, maybe-default-type: Private ordinary functions
Function, mm-hermitian%: Private ordinary functions
Function, mmm: Public ordinary functions
Function, nrm2: Public ordinary functions
Function, number-float-type: Private ordinary functions
Function, output-array-form: Private ordinary functions
Function, process-forms: Private ordinary functions
Function, qr-r: Public ordinary functions
Function, query-configuration: Private ordinary functions
Function, scal!: Public ordinary functions
Function, set-feature: Private ordinary functions
Function, shareable-array?: Private ordinary functions
Function, spectral-factorization: Public ordinary functions
Function, spectral-factorization-p: Private ordinary functions
Function, spectral-factorization-w: Public ordinary functions
Function, spectral-factorization-z: Public ordinary functions
Function, sum-diagonal%: Private ordinary functions
Function, svd-d: Public ordinary functions
Function, svd-p: Private ordinary functions
Function, svd-u: Public ordinary functions
Function, svd-vt: Public ordinary functions
Function, transpose-matrix-from-memory: Private ordinary functions
Function, transpose-matrix-to-memory: Private ordinary functions
Function, trsm%: Private ordinary functions
Function, value-from-memory%: Private ordinary functions
Function, value-to-memory%: Private ordinary functions
Function, wrap-arguments: Private ordinary functions
Function, xx: Public ordinary functions

G
gemm!: Public ordinary functions
Generic Function, (setf tau): Private generic functions
Generic Function, argument-pointer: Private generic functions
Generic Function, cholesky: Public generic functions
Generic Function, factor: Private generic functions
Generic Function, fortran-argument/output-initializer-form: Private generic functions
Generic Function, hermitian-factorization: Public generic functions
Generic Function, invert: Public generic functions
Generic Function, invert-xx: Public generic functions
Generic Function, ipiv-internal: Private generic functions
Generic Function, left-square-root: Public generic functions
Generic Function, logdet: Public generic functions
Generic Function, lu: Public generic functions
Generic Function, lu-matrix: Private generic functions
Generic Function, mm: Public generic functions
Generic Function, outer: Public generic functions
Generic Function, permutations: Private generic functions
Generic Function, process-form: Private generic functions
Generic Function, qr: Public generic functions
Generic Function, right-square-root: Public generic functions
Generic Function, solve: Public generic functions
Generic Function, svd: Public generic functions
Generic Function, tau: Private generic functions
Generic Function, tr: Public generic functions
Generic Function, wrap-argument: Private generic functions

H
hermitian-factorization: Public generic functions
hermitian-factorization: Public generic functions

I
invert: Public generic functions
invert: Public generic functions
invert: Public generic functions
invert: Public generic functions
invert: Public generic functions
invert: Public generic functions
invert: Public generic functions
invert: Public generic functions
invert: Public generic functions
invert-triangular%: Private ordinary functions
invert-xx: Public generic functions
invert-xx: Public generic functions
ipiv: Public ordinary functions
ipiv-internal: Private generic functions
ipiv-internal: Private generic functions
ipiv-inverse: Public ordinary functions

L
lapack-call: Private macros
lapack-call-w/query: Private macros
lapack-info-wrap-argument: Private ordinary functions
last-rows-ss: Private ordinary functions
least-squares: Public ordinary functions
least-squares-qr: Private ordinary functions
left-square-root: Public generic functions
left-square-root: Public generic functions
left-square-root: Public generic functions
left-square-root: Public generic functions
lisp-type: Private ordinary functions
log-with-sign%: Private macros
logdet: Public generic functions
logdet: Public generic functions
logdet: Public generic functions
logdet: Public generic functions
lu: Public generic functions
lu: Public generic functions
lu-l: Public ordinary functions
lu-matrix: Private generic functions
lu-matrix: Private generic functions
lu-u: Public ordinary functions

M
Macro, &array-in: Private macros
Macro, &array-in/out: Private macros
Macro, &array-out: Private macros
Macro, &atom: Private macros
Macro, &char: Private macros
Macro, &info: Private macros
Macro, &integer: Private macros
Macro, &integers: Private macros
Macro, &new: Private macros
Macro, &work: Private macros
Macro, &work-query: Private macros
Macro, array-clause%: Private macros
Macro, blas-call: Private macros
Macro, define-factorization-eops%: Private macros
Macro, define-foreign-aref: Private macros
Macro, define-matrix-square-root-scalar-multiplication: Private macros
Macro, lapack-call: Private macros
Macro, lapack-call-w/query: Private macros
Macro, log-with-sign%: Private macros
Macro, with-array-input: Private macros
Macro, with-array-input-output: Private macros
Macro, with-array-output: Private macros
Macro, with-fortran-atom: Private macros
Macro, with-fortran-character: Private macros
Macro, with-fp-traps-masked: Public macros
Macro, with-pinned-array: Private macros
Macro, with-work-area: Private macros
make-cholesky: Private ordinary functions
make-cholesky%: Private ordinary functions
make-matrix-square-root: Private ordinary functions
make-spectral-factorization: Private ordinary functions
make-svd: Private ordinary functions
matrix-square-root-left: Private ordinary functions
matrix-square-root-p: Private ordinary functions
maybe-default-type: Private ordinary functions
Method, (setf tau): Private generic functions
Method, argument-pointer: Private generic functions
Method, as-array: Public standalone methods
Method, as-array: Public standalone methods
Method, as-array: Public standalone methods
Method, cholesky: Public generic functions
Method, e2*: Public standalone methods
Method, e2*: Public standalone methods
Method, e2+: Public standalone methods
Method, e2+: Public standalone methods
Method, e2/: Public standalone methods
Method, factor: Private generic functions
Method, fortran-argument/output-initializer-form: Private generic functions
Method, fortran-argument/output-initializer-form: Private generic functions
Method, fortran-argument/output-initializer-form: Private generic functions
Method, hermitian-factorization: Public generic functions
Method, invert: Public generic functions
Method, invert: Public generic functions
Method, invert: Public generic functions
Method, invert: Public generic functions
Method, invert: Public generic functions
Method, invert: Public generic functions
Method, invert: Public generic functions
Method, invert: Public generic functions
Method, invert-xx: Public generic functions
Method, ipiv-internal: Private generic functions
Method, left-square-root: Public generic functions
Method, left-square-root: Public generic functions
Method, left-square-root: Public generic functions
Method, logdet: Public generic functions
Method, logdet: Public generic functions
Method, logdet: Public generic functions
Method, lu: Public generic functions
Method, lu-matrix: Private generic functions
Method, mm: Public generic functions
Method, mm: Public generic functions
Method, mm: Public generic functions
Method, mm: Public generic functions
Method, mm: Public generic functions
Method, mm: Public generic functions
Method, mm: Public generic functions
Method, mm: Public generic functions
Method, mm: Public generic functions
Method, mm: Public generic functions
Method, mm: Public generic functions
Method, mm: Public generic functions
Method, mm: Public generic functions
Method, mm: Public generic functions
Method, mm: Public generic functions
Method, mm: Public generic functions
Method, mm: Public generic functions
Method, outer: Public generic functions
Method, outer: Public generic functions
Method, outer: Public generic functions
Method, permutations: Private generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, process-form: Private generic functions
Method, process-form: Private generic functions
Method, process-form: Private generic functions
Method, process-form: Private generic functions
Method, process-form: Private generic functions
Method, qr: Public generic functions
Method, qr: Public generic functions
Method, right-square-root: Public generic functions
Method, right-square-root: Public generic functions
Method, solve: Public generic functions
Method, solve: Public generic functions
Method, solve: Public generic functions
Method, solve: Public generic functions
Method, solve: Public generic functions
Method, solve: Public generic functions
Method, solve: Public generic functions
Method, solve: Public generic functions
Method, solve: Public generic functions
Method, solve: Public generic functions
Method, svd: Public generic functions
Method, tau: Private generic functions
Method, tr: Public generic functions
Method, tr: Public generic functions
Method, tr: Public generic functions
Method, wrap-argument: Private generic functions
Method, wrap-argument: Private generic functions
Method, wrap-argument: Private generic functions
Method, wrap-argument: Private generic functions
Method, wrap-argument: Private generic functions
Method, wrap-argument: Private generic functions
Method, wrap-argument: Private generic functions
Method, wrap-argument: Private generic functions
Method, wrap-argument: Private generic functions
Method, wrap-argument: Private generic functions
Method, wrap-argument: Private generic functions
Method, wrap-argument: Private generic functions
Method, wrap-argument: Private generic functions
Method, wrap-argument: Private generic functions
Method, wrap-argument: Private generic functions
mm: Public generic functions
mm: Public generic functions
mm: Public generic functions
mm: Public generic functions
mm: Public generic functions
mm: Public generic functions
mm: Public generic functions
mm: Public generic functions
mm: Public generic functions
mm: Public generic functions
mm: Public generic functions
mm: Public generic functions
mm: Public generic functions
mm: Public generic functions
mm: Public generic functions
mm: Public generic functions
mm: Public generic functions
mm: Public generic functions
mm-hermitian%: Private ordinary functions
mmm: Public ordinary functions

N
nrm2: Public ordinary functions
number-float-type: Private ordinary functions

O
outer: Public generic functions
outer: Public generic functions
outer: Public generic functions
outer: Public generic functions
output-array-form: Private ordinary functions

P
permutations: Private generic functions
permutations: Private generic functions
print-object: Public standalone methods
print-object: Public standalone methods
process-form: Private generic functions
process-form: Private generic functions
process-form: Private generic functions
process-form: Private generic functions
process-form: Private generic functions
process-form: Private generic functions
process-forms: Private ordinary functions

Q
qr: Public generic functions
qr: Public generic functions
qr: Public generic functions
qr-r: Public ordinary functions
query-configuration: Private ordinary functions

R
right-square-root: Public generic functions
right-square-root: Public generic functions
right-square-root: Public generic functions

S
scal!: Public ordinary functions
set-feature: Private ordinary functions
shareable-array?: Private ordinary functions
solve: Public generic functions
solve: Public generic functions
solve: Public generic functions
solve: Public generic functions
solve: Public generic functions
solve: Public generic functions
solve: Public generic functions
solve: Public generic functions
solve: Public generic functions
solve: Public generic functions
solve: Public generic functions
spectral-factorization: Public ordinary functions
spectral-factorization-p: Private ordinary functions
spectral-factorization-w: Public ordinary functions
spectral-factorization-z: Public ordinary functions
sum-diagonal%: Private ordinary functions
svd: Public generic functions
svd: Public generic functions
svd-d: Public ordinary functions
svd-p: Private ordinary functions
svd-u: Public ordinary functions
svd-vt: Public ordinary functions

T
tau: Private generic functions
tau: Private generic functions
tr: Public generic functions
tr: Public generic functions
tr: Public generic functions
tr: Public generic functions
transpose-matrix-from-memory: Private ordinary functions
transpose-matrix-to-memory: Private ordinary functions
trsm%: Private ordinary functions

V
value-from-memory%: Private ordinary functions
value-to-memory%: Private ordinary functions

W
with-array-input: Private macros
with-array-input-output: Private macros
with-array-output: Private macros
with-fortran-atom: Private macros
with-fortran-character: Private macros
with-fp-traps-masked: Public macros
with-pinned-array: Private macros
with-work-area: Private macros
wrap-argument: Private generic functions
wrap-argument: Private generic functions
wrap-argument: Private generic functions
wrap-argument: Private generic functions
wrap-argument: Private generic functions
wrap-argument: Private generic functions
wrap-argument: Private generic functions
wrap-argument: Private generic functions
wrap-argument: Private generic functions
wrap-argument: Private generic functions
wrap-argument: Private generic functions
wrap-argument: Private generic functions
wrap-argument: Private generic functions
wrap-argument: Private generic functions
wrap-argument: Private generic functions
wrap-argument: Private generic functions
wrap-arguments: Private ordinary functions

X
xx: Public ordinary functions


A.3 Variables

Jump to:   &   *   +  
A   C   D   F   I   L   M   O   P   Q   S   T   U   V   W   Z  
Index Entry  Section

&
&info: Private symbol macros

*
*lla-efficiency-warning-array-conversion*: Public special variables
*lla-efficiency-warning-array-type*: Public special variables

+
+complex-double+: Private constants
+complex-single+: Private constants
+double+: Private constants
+float-types+: Private constants
+integer+: Private constants
+internal-types+: Private constants
+single+: Private constants

A
array: Public conditions
array: Public conditions

C
character: Private classes
condition: Private classes
Constant, +complex-double+: Private constants
Constant, +complex-single+: Private constants
Constant, +double+: Private constants
Constant, +float-types+: Private constants
Constant, +integer+: Private constants
Constant, +internal-types+: Private constants
Constant, +single+: Private constants

D
d: Public structures

F
factor: Public classes

I
info: Public conditions
input: Private classes
input-force-copy?: Private classes
input-transpose?: Private classes
input-type: Private classes
ipiv-internal: Private classes

L
left: Public structures
lu: Public classes

M
message: Public conditions

O
object: Public conditions
output: Private classes
output: Private classes
output-dimensions: Private classes
output-transpose?: Private classes
output-type: Private classes

P
pointer: Private classes
position: Public conditions

Q
qr: Public classes

S
size: Private classes
Slot, array: Public conditions
Slot, array: Public conditions
Slot, character: Private classes
Slot, condition: Private classes
Slot, d: Public structures
Slot, factor: Public classes
Slot, info: Public conditions
Slot, input: Private classes
Slot, input-force-copy?: Private classes
Slot, input-transpose?: Private classes
Slot, input-type: Private classes
Slot, ipiv-internal: Private classes
Slot, left: Public structures
Slot, lu: Public classes
Slot, message: Public conditions
Slot, object: Public conditions
Slot, output: Private classes
Slot, output: Private classes
Slot, output-dimensions: Private classes
Slot, output-transpose?: Private classes
Slot, output-type: Private classes
Slot, pointer: Private classes
Slot, position: Public conditions
Slot, qr: Public classes
Slot, size: Private classes
Slot, tau: Public classes
Slot, type: Public conditions
Slot, type: Private classes
Slot, u: Public structures
Slot, value: Private classes
Slot, variable: Private classes
Slot, vt: Public structures
Slot, w: Public structures
Slot, z: Public structures
Special Variable, *lla-efficiency-warning-array-conversion*: Public special variables
Special Variable, *lla-efficiency-warning-array-type*: Public special variables
Symbol Macro, &info: Private symbol macros

T
tau: Public classes
type: Public conditions
type: Private classes

U
u: Public structures

V
value: Private classes
variable: Private classes
vt: Public structures

W
w: Public structures

Z
z: Public structures


A.4 Data types

Jump to:   B   C   F   H   I   L   M   P   Q   S   T  
Index Entry  Section

B
blas.lisp: The lla/blas․lisp file

C
cholesky: Public structures
Class, fortran-argument: Private classes
Class, fortran-argument/output: Private classes
Class, fortran-argument/size: Private classes
Class, fortran-argument/type: Private classes
Class, fortran-atom: Private classes
Class, fortran-character: Private classes
Class, fortran-input-array: Private classes
Class, fortran-input-output-array: Private classes
Class, fortran-output-array: Private classes
Class, fortran-work-area: Private classes
Class, hermitian-factorization: Public classes
Class, ipiv-mixin: Private classes
Class, lapack-info: Private classes
Class, lapack-work-query-area: Private classes
Class, lapack-work-query-size: Private classes
Class, lu: Public classes
Class, qr: Public classes
Condition, lapack-error: Public conditions
Condition, lapack-failure: Public conditions
Condition, lapack-invalid-argument: Public conditions
Condition, lapack-singular-matrix: Public conditions
Condition, lla-efficiency-warning: Public conditions
Condition, lla-efficiency-warning-array-conversion: Public conditions
Condition, lla-efficiency-warning-array-type: Public conditions
Condition, lla-incompatible-dimensions: Public conditions
Condition, lla-internal-error: Public conditions
Condition, lla-unhandled-type: Public conditions
conditions.lisp: The lla/conditions․lisp file
configuration-interface.lisp: The lla/configuration-interface․lisp file
configuration.lisp: The lla/configuration․lisp file

F
factorizations.lisp: The lla/factorizations․lisp file
File, blas.lisp: The lla/blas․lisp file
File, conditions.lisp: The lla/conditions․lisp file
File, configuration-interface.lisp: The lla/configuration-interface․lisp file
File, configuration.lisp: The lla/configuration․lisp file
File, factorizations.lisp: The lla/factorizations․lisp file
File, foreign-memory.lisp: The lla/foreign-memory․lisp file
File, fortran-call.lisp: The lla/fortran-call․lisp file
File, libraries.lisp: The lla/libraries․lisp file
File, linear-algebra.lisp: The lla/linear-algebra․lisp file
File, lla.asd: The lla/lla․asd file
File, package.lisp: The lla/package․lisp file
File, pinned-array.lisp: The lla/pinned-array․lisp file
File, types.lisp: The lla/types․lisp file
float-type: Private types
foreign-memory.lisp: The lla/foreign-memory․lisp file
fortran-argument: Private classes
fortran-argument/output: Private classes
fortran-argument/size: Private classes
fortran-argument/type: Private classes
fortran-atom: Private classes
fortran-call.lisp: The lla/fortran-call․lisp file
fortran-character: Private classes
fortran-input-array: Private classes
fortran-input-output-array: Private classes
fortran-output-array: Private classes
fortran-work-area: Private classes

H
hermitian-factorization: Public classes

I
internal-type: Private types
ipiv-mixin: Private classes

L
lapack-error: Public conditions
lapack-failure: Public conditions
lapack-info: Private classes
lapack-invalid-argument: Public conditions
lapack-singular-matrix: Public conditions
lapack-work-query-area: Private classes
lapack-work-query-size: Private classes
libraries.lisp: The lla/libraries․lisp file
linear-algebra.lisp: The lla/linear-algebra․lisp file
lla: The lla system
lla: The lla package
lla-complex-double: Public types
lla-complex-single: Public types
lla-double: Public types
lla-efficiency-warning: Public conditions
lla-efficiency-warning-array-conversion: Public conditions
lla-efficiency-warning-array-type: Public conditions
lla-incompatible-dimensions: Public conditions
lla-integer: Public types
lla-internal-error: Public conditions
lla-single: Public types
lla-unhandled-type: Public conditions
lla.asd: The lla/lla․asd file
lu: Public classes

M
matrix-square-root: Public structures
maximum-array-size: Private types

P
Package, lla: The lla package
package.lisp: The lla/package․lisp file
pinned-array.lisp: The lla/pinned-array․lisp file

Q
qr: Public classes

S
spectral-factorization: Public structures
Structure, cholesky: Public structures
Structure, matrix-square-root: Public structures
Structure, spectral-factorization: Public structures
Structure, svd: Public structures
svd: Public structures
System, lla: The lla system

T
Type, float-type: Private types
Type, internal-type: Private types
Type, lla-complex-double: Public types
Type, lla-complex-single: Public types
Type, lla-double: Public types
Type, lla-integer: Public types
Type, lla-single: Public types
Type, maximum-array-size: Private types
types.lisp: The lla/types․lisp file