The lla Reference Manual
Table of Contents
The lla Reference Manual
This is the lla Reference Manual, version 0.2,
generated automatically by Declt version 3.0 "Montgomery Scott"
on Mon Apr 19 16:56:01 2021 GMT+0.
1 Introduction
Lisp Linear Algebra — a linear algebra library for Common Lisp
This library is unsupported.
LLA is a high-level Common Lisp library built on on BLAS and LAPACK, but providing a much more abstract interface with the purpose of freeing the user from low-level concerns and reducing the number of bugs in numerical code.
Documentation is mostly in docstrings at the moment, but I plan to write a decent tutorial at some point. In the meantime, please look at the unit tests.
Objectives
-
High-level, user friendly interface that hides the details.
(solve a b)
should return $X$, from $AX=B$, regardless of whether $A$ is a dense matrix, an $LU$ decomposition, or something else; similarly, $X$ should be a vector/matrix when $B$ is. Users should not need to memorize names like DGESV
, especially when CLOS makes it so easy to deal with these things. Also, you don't need to make sure that all arguments are of the same type (eg complex-double): LLA will find the common supertype for elements and convert if necessary.
-
Stay in Lisp and expose the innards of the objects as much as possible.
LLA aims to take advantage of CL's high level facilities such as CLOS and memory management. Data is kept in Lisp arrays instead of foreign arrays, so you can access it directly using aref
etc. You also benefit from garbage collection and all the clever stuff that comes with the GC. If you need more memory, just increase the heap size.
-
Keeping it simple.
Currently, LLA sources amount to less than 3000 lines of code (not including tests). The small size should make maintainance easier and bugs more rare (hopefully).
-
Speed is important, but reliability comes first.
Only optimize when necessary, and do extensive testing afterwards. Most of the speed comes from your LAPACK library anyway --- most linear algebra operations are $O(N^\alpha)$ with $\alpha > 1$, frequently $\alpha > 2$. That said, copying to memory is optimized, and in the long run LLA should make use of your implementation's array pinning features (when available). Currently, direct array sharing is disabled, it will be re-enabeld in the near future.
Configuration
Certain features of LLA can be configured before loading using the plist *lla-configuration*
in the CL-USER
package (for example, on SBCL you would do it in your ~/.sbclrc
). The following properties are supported:
-
:libraries
A list of objects, passed directly to cffi:load-foreign-library
. You can use strings, paths, or even symbols if you have defined these libraries using cffi:define-foreign-library
. If you don't define this, a reasonable platform-dependent default will be used. See the next section for details.
-
:int64
This makes LLA use 64-bit integers for array dimensions, pivot indices and other integer values passed to BLAS/LAPACK functions. Only use this if you are sure that your libraries have been compiled with 64-bit integers. The fact that you have a 64-bit platform does not necessarily mean that this is the case, in fact, it is still quite rare. Unless told otherwise, LLA expectes BLAS/LAPACK to use the (L)LP64 model for integers -- that is to say, integer types in Fortran are 32 bit.
-
:efficiency-warnings
Enable the possibility of efficiency warnings at compile time. You still have to set the appropriate flags, but without this option, they won't even be checked. There are two properties you can set: :array-type
and :array-conversion
. The first warns whenever an array has to be walked elementwise to determine its type, the second when some arrays need to be converted to a common type.
Example:
(defparameter cl-user:*lla-configuration*
'(:efficiency-warnings (:array-type :array-conversion)))
before loading LLA, and
(let ((lla:*lla-efficiency-warning-array-type* t)
(lla:*lla-efficiency-warning-array-conversion* t))
(code that you want to check))
Libraries
Dependencies and configuration
LLA needs BLAS and LAPACK shared libraries to work. When it comes to
loading libraries, LLA tries to pick a sensible default for each
platform, but in case it fails, you need to tell LLA where the libraries
are before loading.
You can do this by putting something like this in your startup script (eg ~/.sbclrc
, the symbol needs to be in the package cl-user
):
(defvar *lla-configuration*
'(:libraries ("/usr/lib/atlas-base/atlas/libblas.so.3gf"
"/usr/lib/atlas-base/libatlas.so.3gf")))
Debian
On Debian-based distributions, it is very likely that LLA will work out of the box if you just install ATLAS, eg
apt-get install libatlas3gf-base
However, you may want to build a version optimized for your architecture.
Building ATLAS on Debian
Prepare the build (as root):
apt-get build-dep atlas
apt-get install fakeroot devscripts
cpufreq-set -g performance -c 0 # do this for all CPUs
Then as a regular user,
apt-get source atlas
cd atlas-[fill in your version here]/
fakeroot debian/rules custom
Then install the .deb files that were created.
Selecting the right linear algebra library
update-alternatives --config libblas.so.3
update-alternatives --config liblapack.so.3
Intel MKL on Linux
In /etc/ld.so.conf.d/
, create a file that contains the paths, eg
/opt/intel/mkl/lib/intel64
/opt/intel/composerxe/lib/intel64
Then the configuration
(defvar *lla-configuration*
'("libgomp.so.1" "libiomp5.so" "libmkl_rt" "libpthread.so.0" "libpthread"))
should work.
Acknowledgements
LLA was inspired by packages written by AJ Rossini, Rif, Mark Hoemmen and others. I have borrowed code (whenever allowed by their licenses) and ideas freely from all of them.
Gábor Melis made substantial contributions to the library, especially the low-level pinning interface and the destructive BLAS routines.
Suggested editor settings for code contributions
No line breaks in (doc)strings, otherwise try to keep it within 80 columns. Remove trailing whitespace. 'modern' coding style. Suggested Emacs snippet:
(set-fill-column 9999)
(font-lock-add-keywords nil
'(("\\<\\(FIXME\\|TODO\\|QUESTION\\|NOTE\\)"
1 font-lock-warning-face t)))
(setq show-trailing-whitespace t)
(add-hook 'write-file-hooks
'(lambda()
(save-excursion
(delete-trailing-whitespace))
nil))
(visual-line-mode 1)
(setq slime-net-coding-system 'utf-8-unix)
(setq lisp-lambda-list-keyword-parameter-alignment t)
(setq lisp-lambda-list-keyword-alignment t)
(setq common-lisp-style-default 'modern)
Things to do (roughly in order of priority)
- write optimized pinning interfaces, especially ECL
- write documentation (probably w/ docudown, decide)
- write more tests (especially randomized ones, develop macros for
that)
- write a tuto
2 Systems
The main system appears first, followed by any subsystem dependency.
2.1 lla
- Author
Tamas K Papp <tkpapp@gmail.com>
- License
Boost Software License - Version 1.0
- Description
Lisp Linear Algebra
- Version
0.2
- Dependencies
- anaphora
- alexandria
- cffi
- cl-num-utils
- cl-slice
- let-plus
- Source
lla.asd (file)
- 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.asd
- Location
/home/quickref/quicklisp/dists/quicklisp/software/lla-20180328-git/lla.asd
- Systems
lla (system)
3.1.2 lla/package.lisp
- Parent
lla (system)
- Location
package.lisp
- Packages
lla
3.1.3 lla/configuration-interface.lisp
- Dependency
package.lisp (file)
- Parent
lla (system)
- Location
configuration-interface.lisp
- Internal Definitions
-
3.1.4 lla/configuration.lisp
- Dependency
configuration-interface.lisp (file)
- Parent
lla (system)
- Location
configuration.lisp
- Internal Definitions
default-libraries (function)
3.1.5 lla/libraries.lisp
- Dependency
configuration.lisp (file)
- Parent
lla (system)
- Location
libraries.lisp
3.1.6 lla/conditions.lisp
- Dependency
libraries.lisp (file)
- Parent
lla (system)
- Location
conditions.lisp
- Exported Definitions
-
3.1.7 lla/types.lisp
- Dependency
conditions.lisp (file)
- Parent
lla (system)
- Location
types.lisp
- Exported Definitions
-
- Internal Definitions
-
3.1.8 lla/foreign-memory.lisp
- Dependency
types.lisp (file)
- Parent
lla (system)
- Location
foreign-memory.lisp
- Internal Definitions
-
3.1.9 lla/pinned-array.lisp
- Dependency
foreign-memory.lisp (file)
- Parent
lla (system)
- Location
pinned-array.lisp
- Internal Definitions
-
3.1.10 lla/factorizations.lisp
- Dependency
pinned-array.lisp (file)
- Parent
lla (system)
- Location
factorizations.lisp
- Exported Definitions
-
- Internal Definitions
-
3.1.11 lla/fortran-call.lisp
- Dependency
factorizations.lisp (file)
- Parent
lla (system)
- Location
fortran-call.lisp
- Exported Definitions
with-fp-traps-masked (macro)
- Internal Definitions
-
3.1.12 lla/linear-algebra.lisp
- Dependency
fortran-call.lisp (file)
- Parent
lla (system)
- Location
linear-algebra.lisp
- Exported Definitions
-
- Internal Definitions
-
3.1.13 lla/blas.lisp
- Dependency
linear-algebra.lisp (file)
- Parent
lla (system)
- Location
blas.lisp
- Exported Definitions
-
4 Packages
Packages are listed by definition order.
4.1 lla
- Source
package.lisp (file)
- Use List
- let-plus
- cl-slice
- cl-num-utils
- cffi
- anaphora
- alexandria
- common-lisp
- Exported Definitions
-
- Internal Definitions
-
5 Definitions
Definitions are sorted by export status, category, package, and then by
lexicographic order.
5.1 Exported definitions
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 (file)
- 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 (file)
5.1.2 Macros
- Macro: with-fp-traps-masked &body BODY
-
- Package
lla
- Source
fortran-call.lisp (file)
5.1.3 Functions
- Function: asum X &key N INCX
-
Return the L1 norm of X.
- Package
lla
- Source
blas.lisp (file)
- Function: axpy! ALPHA X Y &key N INCX INCY
-
- Package
lla
- Source
blas.lisp (file)
- Function: copy! X Y &key N INCX INCY
-
- Package
lla
- Source
blas.lisp (file)
- Function: det MATRIX
-
Determinant of a matrix. If you need the log of this, use LOGDET
directly.
- Package
lla
- Source
linear-algebra.lisp (file)
- Function: dot X Y &key N INCX INCY
-
- Package
lla
- Source
blas.lisp (file)
- Function: eigenvalues A &key ABSTOL
-
Return the eigenvalues of A. See the documentation of
SPECTRAL-FACTORIZATION about ABSTOL.
- Package
lla
- Source
linear-algebra.lisp (file)
- 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 (file)
- Function: ipiv OBJECT
-
Pivot indices, counting from 0, in a format understood by SLICE.
Example:
(let+ (((&accessors-r/o lu-l lu-u ipiv) (lu a)))
(num= (slice a ipiv) (mm lu-l lu-u) ipiv-inverse t)) ; => T
- Package
lla
- Source
factorizations.lisp (file)
- Function: ipiv-inverse OBJECT
-
Inverted permutation for pivot indices, in a format understood by SLICE.
Example:
(let+ (((&accessors-r/o lu-l lu-u ipiv-inverse) (lu a)))
(num= a (slice (mm lu-l lu-u) ipiv-inverse t))) ; => T
- Package
lla
- Source
factorizations.lisp (file)
- Function: least-squares Y X &rest REST &key METHOD &allow-other-keys
-
- Package
lla
- Source
linear-algebra.lisp (file)
- Function: lu-l LU
-
Return the L part of an LU factorization.
- Package
lla
- Source
factorizations.lisp (file)
- Function: lu-u LU
-
Return the U part of an LU factorization.
- Package
lla
- Source
factorizations.lisp (file)
- Function: mmm &rest MATRICES
-
Multiply arguments from left to right using MM.
- Package
lla
- Source
linear-algebra.lisp (file)
- Function: nrm2 X &key N INCX
-
Return the L2 norm of X.
- Package
lla
- Source
blas.lisp (file)
- Function: qr-r QR
-
Return the R part of a QR factorization.
- Package
lla
- Source
factorizations.lisp (file)
- Function: scal! ALPHA X &key N INCX
-
X = alpha * X.
- Package
lla
- Source
blas.lisp (file)
- 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 (file)
- Function: spectral-factorization-w INSTANCE
-
- Function: (setf spectral-factorization-w) VALUE INSTANCE
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: spectral-factorization-z INSTANCE
-
- Function: (setf spectral-factorization-z) VALUE INSTANCE
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: svd-d INSTANCE
-
- Function: (setf svd-d) VALUE INSTANCE
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: svd-u INSTANCE
-
- Function: (setf svd-u) VALUE INSTANCE
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: svd-vt INSTANCE
-
- Function: (setf svd-vt) VALUE INSTANCE
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: xx LEFT-SQUARE-ROOT
-
Convenience function to create a matrix from a left square root.
- Package
lla
- Source
factorizations.lisp (file)
5.1.4 Generic functions
- Generic Function: cholesky A
-
Cholesky factorization.
- Package
lla
- Source
linear-algebra.lisp (file)
- Methods
- Method: cholesky (A hermitian-matrix)
-
- Generic Function: hermitian-factorization A
-
Compute the hermitian factorization.
- Package
lla
- Source
linear-algebra.lisp (file)
- 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 (file)
- 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 (file)
- Methods
- Method: invert-xx (QR qr)
-
- Generic Function: left-square-root A
-
Return X such that XX^T=A.
- Package
lla
- Source
factorizations.lisp (file)
- Methods
- Method: left-square-root (A diagonal-matrix)
-
- Source
linear-algebra.lisp (file)
- Method: left-square-root (HERMITIAN-MATRIX hermitian-matrix)
-
- Source
linear-algebra.lisp (file)
- 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 (file)
- 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 (file)
- Methods
- Method: lu (A array)
-
- Generic Function: mm A B
-
Matrix multiplication of A and B.
- Package
lla
- Source
linear-algebra.lisp (file)
- 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 (file)
- 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 (file)
- Method: qr (QR qr)
-
matrix storing the QR factorization.
- Source
factorizations.lisp (file)
- 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 (file)
- 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 (file)
- 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 (file)
- Methods
- Method: svd (A array) &optional VECTORS
-
- Generic Function: tr A
-
Trace of a square matrix.
- Package
lla
- Source
linear-algebra.lisp (file)
- Methods
- Method: tr (A array)
-
- Method: tr (A wrapped-matrix)
-
- Method: tr (A diagonal-matrix)
-
5.1.5 Conditions
- Condition: lapack-error ()
-
The LAPACK procedure returned a nonzero info code.
- Package
lla
- Source
conditions.lisp (file)
- Direct superclasses
error (condition)
- Direct subclasses
-
- Condition: lapack-failure ()
-
Superclass of all LAPACK errors with a positive INFO
- Package
lla
- Source
conditions.lisp (file)
- Direct superclasses
lapack-error (condition)
- Direct subclasses
lapack-singular-matrix (condition)
- 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 (file)
- Direct superclasses
-
- Direct slots
- Slot: position
-
Position of the illegal argument
- Initargs
:position
- Condition: lapack-singular-matrix ()
-
- Package
lla
- Source
conditions.lisp (file)
- Direct superclasses
lapack-failure (condition)
- Condition: lla-efficiency-warning ()
-
- Package
lla
- Source
conditions.lisp (file)
- Direct superclasses
warning (condition)
- Direct subclasses
-
- Condition: lla-efficiency-warning-array-conversion ()
-
- Package
lla
- Source
conditions.lisp (file)
- Direct superclasses
lla-efficiency-warning (condition)
- Direct slots
- Slot: array
-
The array that had to be copied.
- Initargs
:array
- Slot: type
-
Required element type.
- Initargs
:type
- Condition: lla-efficiency-warning-array-type ()
-
See *LLA-EFFICIENCY-WARNING-ARRAY-TYPE*.
- Package
lla
- Source
conditions.lisp (file)
- Direct superclasses
lla-efficiency-warning (condition)
- Direct methods
print-object (method)
- Direct slots
- Slot: array
-
- Initargs
:array
- Condition: lla-incompatible-dimensions ()
-
- Package
lla
- Source
conditions.lisp (file)
- Direct superclasses
lapack-error (condition)
- Condition: lla-internal-error ()
-
Internal error in LLA.
- Package
lla
- Source
conditions.lisp (file)
- Direct superclasses
error (condition)
- Direct subclasses
lapack-invalid-argument (condition)
- Direct slots
- Slot: message
-
- Initargs
:message
- Initform
(quote "")
- Condition: lla-unhandled-type ()
-
Could not classify object as a numeric type handled by LLA.
- Package
lla
- Source
conditions.lisp (file)
- Direct superclasses
error (condition)
- Direct slots
- Slot: object
-
- Initform
(quote :object)
5.1.6 Structures
- Structure: cholesky ()
-
Cholesky factorization a matrix.
- Package
lla
- Source
factorizations.lisp (file)
- Direct superclasses
matrix-square-root (structure)
- 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 (file)
- Direct superclasses
structure-object (structure)
- Direct subclasses
cholesky (structure)
- Direct methods
-
- Direct slots
- Slot: left
-
- Readers
matrix-square-root-left (function)
- Writers
(setf matrix-square-root-left) (function)
- 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 (file)
- Direct superclasses
structure-object (structure)
- Direct methods
as-array (method)
- Direct slots
- Slot: z
-
- Readers
spectral-factorization-z (function)
- Writers
(setf spectral-factorization-z) (function)
- Slot: w
-
- Readers
spectral-factorization-w (function)
- Writers
(setf spectral-factorization-w) (function)
- 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 (file)
- Direct superclasses
structure-object (structure)
- Direct methods
as-array (method)
- Direct slots
- Slot: u
-
- Readers
svd-u (function)
- Writers
(setf svd-u) (function)
- Slot: d
-
- Readers
svd-d (function)
- Writers
(setf svd-d) (function)
- Slot: vt
-
- Readers
svd-vt (function)
- Writers
(setf svd-vt) (function)
5.1.7 Classes
- Class: hermitian-factorization ()
-
Factorization for an indefinite hermitian matrix with
pivoting.
- Package
lla
- Source
factorizations.lisp (file)
- Direct superclasses
ipiv-mixin (class)
- 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 (generic function)
- Class: lu ()
-
LU factorization of a matrix with pivoting. (SLICE A IPIV) is (MM L U), when IPIV is used to obtain the permutation.
- Package
lla
- Source
factorizations.lisp (file)
- Direct superclasses
ipiv-mixin (class)
- Direct methods
-
- Direct slots
- Slot: lu
-
matrix storing the transpose of the LU factorization.
- Initargs
:lu
- Readers
lu-matrix (generic function)
- Class: qr ()
-
QR factorization of a matrix.
- Package
lla
- Source
factorizations.lisp (file)
- Direct superclasses
standard-object (class)
- Direct methods
-
- Direct slots
- Slot: qr
-
matrix storing the QR factorization.
- Initargs
:qr
- Readers
qr (generic function)
- Slot: tau
-
complex scalar for elementary reflectors (see documentation of xGEQRF).
- Initargs
:tau
- Readers
tau (generic function)
- Writers
(setf tau) (generic function)
5.1.8 Types
- Type: lla-complex-double ()
-
- Package
lla
- Source
types.lisp (file)
- Type: lla-complex-single ()
-
- Package
lla
- Source
types.lisp (file)
- Type: lla-double ()
-
- Package
lla
- Source
types.lisp (file)
- Type: lla-integer ()
-
- Package
lla
- Source
types.lisp (file)
- Type: lla-single ()
-
- Package
lla
- Source
types.lisp (file)
5.2 Internal definitions
5.2.1 Constants
- Constant: +complex-double+
-
- Package
lla
- Source
types.lisp (file)
- Constant: +complex-single+
-
- Package
lla
- Source
types.lisp (file)
- Constant: +double+
-
- Package
lla
- Source
types.lisp (file)
- Constant: +float-types+
-
List of all internal float types.
- Package
lla
- Source
types.lisp (file)
- Constant: +integer+
-
- Package
lla
- Source
types.lisp (file)
- Constant: +internal-types+
-
List of all internal types.
- Package
lla
- Source
types.lisp (file)
- Constant: +single+
-
- Package
lla
- Source
types.lisp (file)
5.2.2 Symbol macros
- Symbol Macro: &info
-
- Package
lla
- Source
fortran-call.lisp (file)
- Expansion
(lla::&info)
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 (file)
- Macro: &array-in/out (&key INPUT (TYPE INPUT-TYPE) (TRANSPOSE? INPUT-TRANSPOSE?) (FORCE-COPY? INPUT-FORCE-COPY?)) (&key OUTPUT (DIMENSIONS OUTPUT-DIMENSIONS) (TYPE OUTPUT-TYPE) (TRANSPOSE? OUTPUT-TRANSPOSE?))
-
Input/output array. See FORTRAN-INPUT-OUTPUT-ARRAY.
- Package
lla
- Source
fortran-call.lisp (file)
- Macro: &array-out OUTPUT &key DIMENSIONS TYPE TRANSPOSE?
-
Output array. See FORTRAN-OUTPUT-ARRAY.
- Package
lla
- Source
fortran-call.lisp (file)
- 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 (file)
- Macro: &char CHARACTER
-
Shorthand for character.
- Package
lla
- Source
fortran-call.lisp (file)
- 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 (file)
- Macro: &integer VALUE &key OUTPUT
-
Shorthand for integer atom.
- Package
lla
- Source
fortran-call.lisp (file)
- Macro: &integers &rest VALUES
-
Shorthand for integer atoms (which are not modified). Useful for combining arguments.
- Package
lla
- Source
fortran-call.lisp (file)
- 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 (file)
- 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 (file)
- Macro: &work-query &optional TYPE
-
Work area query, takes the place of TWO fortran arguments.
- Package
lla
- Source
fortran-call.lisp (file)
- 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 (file)
- 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 (file)
- Macro: define-factorization-eops% TYPE CONVERSION
-
Define elementwise operations for TYPE, trying to convert into arrays.
- Package
lla
- Source
factorizations.lisp (file)
- Macro: define-foreign-aref ()
-
- Package
lla
- Source
foreign-memory.lisp (file)
- Macro: define-matrix-square-root-scalar-multiplication TYPE &key MAKE
-
- Package
lla
- Source
factorizations.lisp (file)
- 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 (file)
- 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 (file)
- 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 (file)
- 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 (file)
- 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 (file)
- 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 (file)
- 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 (file)
- 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 (file)
- Macro: with-pinned-array (POINTER ARRAY) &body BODY
-
- Package
lla
- Source
pinned-array.lisp (file)
- 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 (file)
5.2.4 Functions
- Function: absolute-square-type INTERNAL-TYPE
-
Type of (* x (conjugate x)).
- Package
lla
- Source
types.lisp (file)
- Function: all-from-specifications% ()
-
Return an optimization specification for all functions that copy from foreign memory.
- Package
lla
- Source
foreign-memory.lisp (file)
- Function: all-to-specifications% ()
-
Return an optimization specification for all functions that copy to foreign memory.
- Package
lla
- Source
foreign-memory.lisp (file)
- Function: argument-pointers ARGUMENTS
-
Return the list of pointers for all the arguments.
- Package
lla
- Source
fortran-call.lisp (file)
- Function: arguments-for-cffi ARGUMENTS
-
Return a list that can be use in a CFFI call.
- Package
lla
- Source
fortran-call.lisp (file)
- 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 (file)
- Function: assert-single-lapack-info ARGUMENTS
-
Assert that there is at most one LAPACK-INFO in ARGUMENTS.
- Package
lla
- Source
fortran-call.lisp (file)
- 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 (file)
- 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 (file)
- 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 (file)
- Function: blas-return-types RETURN-TYPES
-
- Package
lla
- Source
fortran-call.lisp (file)
- Function: cholesky-left INSTANCE
-
- Function: (setf cholesky-left) VALUE INSTANCE
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: cholesky-p OBJECT
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: common-float-type &rest ARRAYS-OR-NUMBERS
-
Return the common (internal) float type for the arguments.
- Package
lla
- Source
types.lisp (file)
- Function: complex? INTERNAL-TYPE
-
True iff the internal type is complex.
- Package
lla
- Source
types.lisp (file)
- 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 (file)
- 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 (file)
- Function: copy-cholesky INSTANCE
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: copy-matrix-square-root INSTANCE
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: copy-spectral-factorization INSTANCE
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: copy-svd INSTANCE
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: count-permutations% IPIV-INTERNAL
-
Count the permutations in a pivoting vector.
- Package
lla
- Source
factorizations.lisp (file)
- 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 (file)
- 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 (file)
- 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 (file)
- 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 (file)
- 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 (file)
- Function: epsilon INTERNAL-TYPE
-
Return the float epsilon for the given internal float type.
- Package
lla
- Source
types.lisp (file)
- Function: expand-specifications% CLAUSE SPECIFICATIONS
-
Expand specifications using (clause internal-type element-type).
- Package
lla
- Source
foreign-memory.lisp (file)
- Function: foreign-size TYPE
-
Return the size of an internal type in bytes.
- Package
lla
- Source
foreign-memory.lisp (file)
- Function: fortran-argument/new-variable FORM
-
If FORM is (&NEW VARIABLE), return VARIABLE, otherwise NIL.
- Package
lla
- Source
fortran-call.lisp (file)
- 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 (file)
- 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 (file)
- 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 (file)
- 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 (file)
- Function: lisp-type INTERNAL-TYPE
-
- Package
lla
- Source
types.lisp (file)
- Function: make-cholesky LEFT
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: make-cholesky% LEFT
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: make-matrix-square-root LEFT
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: make-spectral-factorization &key (Z Z) (W W)
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: make-svd &key (U U) (D D) (VT VT)
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: matrix-square-root-left INSTANCE
-
- Function: (setf matrix-square-root-left) VALUE INSTANCE
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: matrix-square-root-p OBJECT
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: maybe-default-type TYPE PARAMETERS
-
Return default type from PARAMETERS when TYPE is NIL.
- Package
lla
- Source
fortran-call.lisp (file)
- 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 (file)
- Function: number-float-type NUMBER
-
Return an (internal) float type for a number.
- Package
lla
- Source
types.lisp (file)
- 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 (file)
- 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 (file)
- 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 (file)
- Function: set-feature SYMBOL SET?
-
Ensure that symbol is in *FEATURES* iff SET?. Returns no values.
- Package
lla
- Source
configuration-interface.lisp (file)
- Function: shareable-array? ARRAY INTERNAL-TYPE
-
- Package
lla
- Source
pinned-array.lisp (file)
- Function: spectral-factorization-p OBJECT
-
- Package
lla
- Source
factorizations.lisp (file)
- Function: sum-diagonal% ARRAY
-
Sum diagonal of array, checking that it is square.
- Package
lla
- Source
linear-algebra.lisp (file)
- Function: svd-p OBJECT
-
- Package
lla
- Source
factorizations.lisp (file)
- 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 (file)
- 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 (file)
- Function: trsm% A A-UPPER? B
-
Wrapper for BLAS routine xTRSM. Solve AX=B, where A is triangular.
- Package
lla
- Source
linear-algebra.lisp (file)
- 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 (file)
- 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 (file)
- Function: wrap-arguments ARGUMENTS PASS PARAMETERS BODY
-
Wrap BODY in arguments. Convenience function used to implement the expansion.
- Package
lla
- Source
fortran-call.lisp (file)
5.2.5 Generic functions
- Generic Function: argument-pointer OBJECT
-
- Package
lla
- Methods
- Method: argument-pointer (FORTRAN-ARGUMENT fortran-argument)
-
Pointer passed to FORTRAN.
- Source
fortran-call.lisp (file)
- Generic Function: factor OBJECT
-
- Package
lla
- Methods
- 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 (file)
- 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 (file)
- 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 Function: ipiv-internal OBJECT
-
- Package
lla
- Methods
- Method: ipiv-internal (IPIV-MIXIN ipiv-mixin)
-
pivot indices in LAPACK’s representation, counting from 1
- Source
factorizations.lisp (file)
- Generic Function: lu-matrix OBJECT
-
- Package
lla
- Methods
- Method: lu-matrix (LU lu)
-
matrix storing the transpose of the LU factorization.
- Source
factorizations.lisp (file)
- 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 (file)
- 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 (file)
- 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 Function: tau OBJECT
-
- Generic Function: (setf tau) NEW-VALUE OBJECT
-
- Package
lla
- Methods
- Method: tau (QR qr)
-
- Method: (setf tau) NEW-VALUE (QR qr)
-
complex scalar for elementary reflectors (see documentation of xGEQRF).
- Source
factorizations.lisp (file)
- 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 (file)
- Methods
- Method: wrap-argument (ARGUMENT lapack-work-query-size) (PASS (eql call)) PARAMETERS BODY
-
- Method: wrap-argument (ARGUMENT lapack-work-query-area) (PASS (eql call)) PARAMETERS BODY
-
- Method: wrap-argument (ARGUMENT lapack-work-query-size) (PASS (eql query)) PARAMETERS BODY
-
- Method: wrap-argument (ARGUMENT lapack-work-query-area) (PASS (eql query)) PARAMETERS BODY
-
- Method: wrap-argument (ARGUMENT lapack-work-query-area) (PASS (eql bindings)) PARAMETERS BODY
-
- Method: wrap-argument (ARGUMENT lapack-info) (PASS (eql query)) PARAMETERS BODY
-
- Method: wrap-argument (ARGUMENT lapack-info) (PASS (eql call)) PARAMETERS BODY
-
- Method: wrap-argument (ARGUMENT fortran-work-area) (PASS (eql main)) PARAMETERS BODY
-
- Method: wrap-argument (ARGUMENT fortran-input-output-array) (PASS (eql main)) PARAMETERS BODY
-
- Method: wrap-argument (ARGUMENT fortran-output-array) (PASS (eql main)) PARAMETERS BODY
-
- Method: wrap-argument (ARGUMENT fortran-input-array) (PASS (eql main)) PARAMETERS BODY
-
- Method: wrap-argument (ARGUMENT fortran-atom) (PASS (eql main)) PARAMETERS BODY
-
- Method: wrap-argument (ARGUMENT fortran-character) (PASS (eql main)) PARAMETERS BODY
-
- Method: wrap-argument (ARGUMENT fortran-argument/output) (PASS (eql 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 (file)
- Direct superclasses
standard-object (class)
- Direct subclasses
-
- Direct methods
argument-pointer (method)
- Direct slots
- Slot: pointer
-
Pointer passed to FORTRAN.
- Initargs
:pointer
- Initform
(gensym)
- Readers
argument-pointer (generic function)
- 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 (file)
- Direct superclasses
fortran-argument (class)
- 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 (file)
- Direct superclasses
fortran-argument (class)
- 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 (file)
- Direct superclasses
fortran-argument (class)
- Direct subclasses
-
- Direct slots
- Slot: type
-
Determines (internal) type for array mapped to the pointer.
- Initargs
:type
- Class: fortran-atom ()
-
Atoms passed to FORTRAN. Input/output (when OUTPUT is given).
- Package
lla
- Source
fortran-call.lisp (file)
- Direct superclasses
-
- Direct methods
wrap-argument (method)
- 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 (file)
- Direct superclasses
fortran-argument (class)
- Direct methods
wrap-argument (method)
- Direct slots
- Slot: character
-
- 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 (file)
- Direct superclasses
fortran-argument (class)
- Direct subclasses
fortran-input-output-array (class)
- Direct methods
wrap-argument (method)
- 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 (file)
- 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 (file)
- Direct superclasses
fortran-argument/output (class)
- Direct subclasses
fortran-input-output-array (class)
- 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 (file)
- Direct superclasses
-
- Direct methods
wrap-argument (method)
- Class: ipiv-mixin ()
-
Mixin class for objects with pivoting.
- Package
lla
- Source
factorizations.lisp (file)
- Direct superclasses
standard-object (class)
- Direct subclasses
-
- Direct methods
ipiv-internal (method)
- Direct slots
- Slot: ipiv-internal
-
pivot indices in LAPACK’s representation, counting from 1
- Type
vector
- Initargs
:ipiv-internal
- Readers
ipiv-internal (generic function)
- Class: lapack-info ()
-
Information from a LAPACK call. See the LAPACK manual for error codes.
- Package
lla
- Source
fortran-call.lisp (file)
- Direct superclasses
fortran-argument (class)
- Direct methods
-
- Direct slots
- Slot: condition
-
- Initargs
:condition
- Slot: variable
-
- Initargs
:variable
- Class: lapack-work-query-area ()
-
- Package
lla
- Source
fortran-call.lisp (file)
- Direct superclasses
-
- Direct methods
-
- Class: lapack-work-query-size ()
-
- Package
lla
- Source
fortran-call.lisp (file)
- Direct superclasses
fortran-argument/size (class)
- Direct methods
-
5.2.7 Types
- Type: float-type ()
-
- Package
lla
- Source
types.lisp (file)
- Type: internal-type ()
-
- Package
lla
- Source
types.lisp (file)
- Type: maximum-array-size ()
-
- Package
lla
- Source
foreign-memory.lisp (file)
Appendix A Indexes
A.1 Concepts
| Index Entry | | Section |
|
F | | |
| File, Lisp, lla.asd: | | The lla․asd file |
| File, Lisp, lla/blas.lisp: | | The lla/blas․lisp file |
| File, Lisp, lla/conditions.lisp: | | The lla/conditions․lisp file |
| File, Lisp, lla/configuration-interface.lisp: | | The lla/configuration-interface․lisp file |
| File, Lisp, lla/configuration.lisp: | | The lla/configuration․lisp file |
| File, Lisp, lla/factorizations.lisp: | | The lla/factorizations․lisp file |
| File, Lisp, lla/foreign-memory.lisp: | | The lla/foreign-memory․lisp file |
| File, Lisp, lla/fortran-call.lisp: | | The lla/fortran-call․lisp file |
| File, Lisp, lla/libraries.lisp: | | The lla/libraries․lisp file |
| File, Lisp, lla/linear-algebra.lisp: | | The lla/linear-algebra․lisp file |
| File, Lisp, lla/package.lisp: | | The lla/package․lisp file |
| File, Lisp, lla/pinned-array.lisp: | | The lla/pinned-array․lisp file |
| File, Lisp, lla/types.lisp: | | The lla/types․lisp file |
|
L | | |
| Lisp File, lla.asd: | | The lla․asd file |
| Lisp File, lla/blas.lisp: | | The lla/blas․lisp file |
| Lisp File, lla/conditions.lisp: | | The lla/conditions․lisp file |
| Lisp File, lla/configuration-interface.lisp: | | The lla/configuration-interface․lisp file |
| Lisp File, lla/configuration.lisp: | | The lla/configuration․lisp file |
| Lisp File, lla/factorizations.lisp: | | The lla/factorizations․lisp file |
| Lisp File, lla/foreign-memory.lisp: | | The lla/foreign-memory․lisp file |
| Lisp File, lla/fortran-call.lisp: | | The lla/fortran-call․lisp file |
| Lisp File, lla/libraries.lisp: | | The lla/libraries․lisp file |
| Lisp File, lla/linear-algebra.lisp: | | The lla/linear-algebra․lisp file |
| Lisp File, lla/package.lisp: | | The lla/package․lisp file |
| Lisp File, lla/pinned-array.lisp: | | The lla/pinned-array․lisp file |
| Lisp File, lla/types.lisp: | | The lla/types․lisp file |
| lla.asd: | | The lla․asd file |
| lla/blas.lisp: | | The lla/blas․lisp file |
| lla/conditions.lisp: | | The lla/conditions․lisp file |
| lla/configuration-interface.lisp: | | The lla/configuration-interface․lisp file |
| lla/configuration.lisp: | | The lla/configuration․lisp file |
| lla/factorizations.lisp: | | The lla/factorizations․lisp file |
| lla/foreign-memory.lisp: | | The lla/foreign-memory․lisp file |
| lla/fortran-call.lisp: | | The lla/fortran-call․lisp file |
| lla/libraries.lisp: | | The lla/libraries․lisp file |
| lla/linear-algebra.lisp: | | The lla/linear-algebra․lisp file |
| lla/package.lisp: | | The lla/package․lisp file |
| lla/pinned-array.lisp: | | The lla/pinned-array․lisp file |
| lla/types.lisp: | | The lla/types․lisp file |
|
A.2 Functions
| Index Entry | | Section |
|
& | | |
| &array-in : | | Internal macros |
| &array-in/out : | | Internal macros |
| &array-out : | | Internal macros |
| &atom : | | Internal macros |
| &char : | | Internal macros |
| &info : | | Internal macros |
| &integer : | | Internal macros |
| &integers : | | Internal macros |
| &new : | | Internal macros |
| &work : | | Internal macros |
| &work-query : | | Internal macros |
|
( | | |
| (setf cholesky-left) : | | Internal functions |
| (setf matrix-square-root-left) : | | Internal functions |
| (setf spectral-factorization-w) : | | Exported functions |
| (setf spectral-factorization-z) : | | Exported functions |
| (setf svd-d) : | | Exported functions |
| (setf svd-u) : | | Exported functions |
| (setf svd-vt) : | | Exported functions |
| (setf tau) : | | Internal generic functions |
| (setf tau) : | | Internal generic functions |
|
A | | |
| absolute-square-type : | | Internal functions |
| all-from-specifications% : | | Internal functions |
| all-to-specifications% : | | Internal functions |
| argument-pointer : | | Internal generic functions |
| argument-pointer : | | Internal generic functions |
| argument-pointers : | | Internal functions |
| arguments-for-cffi : | | Internal functions |
| array-clause% : | | Internal macros |
| array-float-type : | | Internal functions |
| assert-single-lapack-info : | | Internal functions |
| asum : | | Exported functions |
| axpy! : | | Exported functions |
|
B | | |
| backing-array : | | Internal functions |
| blas-call : | | Internal macros |
| blas-lapack-call-form : | | Internal functions |
| blas-lapack-function-name : | | Internal functions |
| blas-return-types : | | Internal functions |
|
C | | |
| cholesky : | | Exported generic functions |
| cholesky : | | Exported generic functions |
| cholesky-left : | | Internal functions |
| cholesky-p : | | Internal functions |
| common-float-type : | | Internal functions |
| complex? : | | Internal functions |
| copy! : | | Exported functions |
| copy-array-from-memory : | | Internal functions |
| copy-array-to-memory : | | Internal functions |
| copy-cholesky : | | Internal functions |
| copy-matrix-square-root : | | Internal functions |
| copy-spectral-factorization : | | Internal functions |
| copy-svd : | | Internal functions |
| count-permutations% : | | Internal functions |
| create-array-from-memory : | | Internal functions |
| create-transposed-matrix-from-memory : | | Internal functions |
|
D | | |
| default-libraries : | | Internal functions |
| define-factorization-eops% : | | Internal macros |
| define-foreign-aref : | | Internal macros |
| define-matrix-square-root-scalar-multiplication : | | Internal macros |
| det : | | Exported functions |
| diagonal-log-sum% : | | Internal functions |
| dimensions-as-matrix : | | Internal functions |
| dot : | | Exported functions |
|
E | | |
| eigenvalues : | | Exported functions |
| epsilon : | | Internal functions |
| expand-specifications% : | | Internal functions |
|
F | | |
| factor : | | Internal generic functions |
| factor : | | Internal generic functions |
| foreign-size : | | Internal functions |
| fortran-argument/new-variable : | | Internal functions |
| fortran-argument/output-initializer-form : | | Internal generic functions |
| fortran-argument/output-initializer-form : | | Internal generic functions |
| fortran-argument/output-initializer-form : | | Internal generic functions |
| fortran-argument/output-initializer-form : | | Internal generic functions |
| Function, (setf cholesky-left) : | | Internal functions |
| Function, (setf matrix-square-root-left) : | | Internal functions |
| Function, (setf spectral-factorization-w) : | | Exported functions |
| Function, (setf spectral-factorization-z) : | | Exported functions |
| Function, (setf svd-d) : | | Exported functions |
| Function, (setf svd-u) : | | Exported functions |
| Function, (setf svd-vt) : | | Exported functions |
| Function, absolute-square-type : | | Internal functions |
| Function, all-from-specifications% : | | Internal functions |
| Function, all-to-specifications% : | | Internal functions |
| Function, argument-pointers : | | Internal functions |
| Function, arguments-for-cffi : | | Internal functions |
| Function, array-float-type : | | Internal functions |
| Function, assert-single-lapack-info : | | Internal functions |
| Function, asum : | | Exported functions |
| Function, axpy! : | | Exported functions |
| Function, backing-array : | | Internal functions |
| Function, blas-lapack-call-form : | | Internal functions |
| Function, blas-lapack-function-name : | | Internal functions |
| Function, blas-return-types : | | Internal functions |
| Function, cholesky-left : | | Internal functions |
| Function, cholesky-p : | | Internal functions |
| Function, common-float-type : | | Internal functions |
| Function, complex? : | | Internal functions |
| Function, copy! : | | Exported functions |
| Function, copy-array-from-memory : | | Internal functions |
| Function, copy-array-to-memory : | | Internal functions |
| Function, copy-cholesky : | | Internal functions |
| Function, copy-matrix-square-root : | | Internal functions |
| Function, copy-spectral-factorization : | | Internal functions |
| Function, copy-svd : | | Internal functions |
| Function, count-permutations% : | | Internal functions |
| Function, create-array-from-memory : | | Internal functions |
| Function, create-transposed-matrix-from-memory : | | Internal functions |
| Function, default-libraries : | | Internal functions |
| Function, det : | | Exported functions |
| Function, diagonal-log-sum% : | | Internal functions |
| Function, dimensions-as-matrix : | | Internal functions |
| Function, dot : | | Exported functions |
| Function, eigenvalues : | | Exported functions |
| Function, epsilon : | | Internal functions |
| Function, expand-specifications% : | | Internal functions |
| Function, foreign-size : | | Internal functions |
| Function, fortran-argument/new-variable : | | Internal functions |
| Function, gemm! : | | Exported functions |
| Function, invert-triangular% : | | Internal functions |
| Function, ipiv : | | Exported functions |
| Function, ipiv-inverse : | | Exported functions |
| Function, lapack-info-wrap-argument : | | Internal functions |
| Function, last-rows-ss : | | Internal functions |
| Function, least-squares : | | Exported functions |
| Function, least-squares-qr : | | Internal functions |
| Function, lisp-type : | | Internal functions |
| Function, lu-l : | | Exported functions |
| Function, lu-u : | | Exported functions |
| Function, make-cholesky : | | Internal functions |
| Function, make-cholesky% : | | Internal functions |
| Function, make-matrix-square-root : | | Internal functions |
| Function, make-spectral-factorization : | | Internal functions |
| Function, make-svd : | | Internal functions |
| Function, matrix-square-root-left : | | Internal functions |
| Function, matrix-square-root-p : | | Internal functions |
| Function, maybe-default-type : | | Internal functions |
| Function, mm-hermitian% : | | Internal functions |
| Function, mmm : | | Exported functions |
| Function, nrm2 : | | Exported functions |
| Function, number-float-type : | | Internal functions |
| Function, output-array-form : | | Internal functions |
| Function, process-forms : | | Internal functions |
| Function, qr-r : | | Exported functions |
| Function, query-configuration : | | Internal functions |
| Function, scal! : | | Exported functions |
| Function, set-feature : | | Internal functions |
| Function, shareable-array? : | | Internal functions |
| Function, spectral-factorization : | | Exported functions |
| Function, spectral-factorization-p : | | Internal functions |
| Function, spectral-factorization-w : | | Exported functions |
| Function, spectral-factorization-z : | | Exported functions |
| Function, sum-diagonal% : | | Internal functions |
| Function, svd-d : | | Exported functions |
| Function, svd-p : | | Internal functions |
| Function, svd-u : | | Exported functions |
| Function, svd-vt : | | Exported functions |
| Function, transpose-matrix-from-memory : | | Internal functions |
| Function, transpose-matrix-to-memory : | | Internal functions |
| Function, trsm% : | | Internal functions |
| Function, value-from-memory% : | | Internal functions |
| Function, value-to-memory% : | | Internal functions |
| Function, wrap-arguments : | | Internal functions |
| Function, xx : | | Exported functions |
|
G | | |
| gemm! : | | Exported functions |
| Generic Function, (setf tau) : | | Internal generic functions |
| Generic Function, argument-pointer : | | Internal generic functions |
| Generic Function, cholesky : | | Exported generic functions |
| Generic Function, factor : | | Internal generic functions |
| Generic Function, fortran-argument/output-initializer-form : | | Internal generic functions |
| Generic Function, hermitian-factorization : | | Exported generic functions |
| Generic Function, invert : | | Exported generic functions |
| Generic Function, invert-xx : | | Exported generic functions |
| Generic Function, ipiv-internal : | | Internal generic functions |
| Generic Function, left-square-root : | | Exported generic functions |
| Generic Function, logdet : | | Exported generic functions |
| Generic Function, lu : | | Exported generic functions |
| Generic Function, lu-matrix : | | Internal generic functions |
| Generic Function, mm : | | Exported generic functions |
| Generic Function, outer : | | Exported generic functions |
| Generic Function, permutations : | | Internal generic functions |
| Generic Function, process-form : | | Internal generic functions |
| Generic Function, qr : | | Exported generic functions |
| Generic Function, right-square-root : | | Exported generic functions |
| Generic Function, solve : | | Exported generic functions |
| Generic Function, svd : | | Exported generic functions |
| Generic Function, tau : | | Internal generic functions |
| Generic Function, tr : | | Exported generic functions |
| Generic Function, wrap-argument : | | Internal generic functions |
|
H | | |
| hermitian-factorization : | | Exported generic functions |
| hermitian-factorization : | | Exported generic functions |
|
I | | |
| invert : | | Exported generic functions |
| invert : | | Exported generic functions |
| invert : | | Exported generic functions |
| invert : | | Exported generic functions |
| invert : | | Exported generic functions |
| invert : | | Exported generic functions |
| invert : | | Exported generic functions |
| invert : | | Exported generic functions |
| invert : | | Exported generic functions |
| invert-triangular% : | | Internal functions |
| invert-xx : | | Exported generic functions |
| invert-xx : | | Exported generic functions |
| ipiv : | | Exported functions |
| ipiv-internal : | | Internal generic functions |
| ipiv-internal : | | Internal generic functions |
| ipiv-inverse : | | Exported functions |
|
L | | |
| lapack-call : | | Internal macros |
| lapack-call-w/query : | | Internal macros |
| lapack-info-wrap-argument : | | Internal functions |
| last-rows-ss : | | Internal functions |
| least-squares : | | Exported functions |
| least-squares-qr : | | Internal functions |
| left-square-root : | | Exported generic functions |
| left-square-root : | | Exported generic functions |
| left-square-root : | | Exported generic functions |
| left-square-root : | | Exported generic functions |
| lisp-type : | | Internal functions |
| log-with-sign% : | | Internal macros |
| logdet : | | Exported generic functions |
| logdet : | | Exported generic functions |
| logdet : | | Exported generic functions |
| logdet : | | Exported generic functions |
| lu : | | Exported generic functions |
| lu : | | Exported generic functions |
| lu-l : | | Exported functions |
| lu-matrix : | | Internal generic functions |
| lu-matrix : | | Internal generic functions |
| lu-u : | | Exported functions |
|
M | | |
| Macro, &array-in : | | Internal macros |
| Macro, &array-in/out : | | Internal macros |
| Macro, &array-out : | | Internal macros |
| Macro, &atom : | | Internal macros |
| Macro, &char : | | Internal macros |
| Macro, &info : | | Internal macros |
| Macro, &integer : | | Internal macros |
| Macro, &integers : | | Internal macros |
| Macro, &new : | | Internal macros |
| Macro, &work : | | Internal macros |
| Macro, &work-query : | | Internal macros |
| Macro, array-clause% : | | Internal macros |
| Macro, blas-call : | | Internal macros |
| Macro, define-factorization-eops% : | | Internal macros |
| Macro, define-foreign-aref : | | Internal macros |
| Macro, define-matrix-square-root-scalar-multiplication : | | Internal macros |
| Macro, lapack-call : | | Internal macros |
| Macro, lapack-call-w/query : | | Internal macros |
| Macro, log-with-sign% : | | Internal macros |
| Macro, with-array-input : | | Internal macros |
| Macro, with-array-input-output : | | Internal macros |
| Macro, with-array-output : | | Internal macros |
| Macro, with-fortran-atom : | | Internal macros |
| Macro, with-fortran-character : | | Internal macros |
| Macro, with-fp-traps-masked : | | Exported macros |
| Macro, with-pinned-array : | | Internal macros |
| Macro, with-work-area : | | Internal macros |
| make-cholesky : | | Internal functions |
| make-cholesky% : | | Internal functions |
| make-matrix-square-root : | | Internal functions |
| make-spectral-factorization : | | Internal functions |
| make-svd : | | Internal functions |
| matrix-square-root-left : | | Internal functions |
| matrix-square-root-p : | | Internal functions |
| maybe-default-type : | | Internal functions |
| Method, (setf tau) : | | Internal generic functions |
| Method, argument-pointer : | | Internal generic functions |
| Method, cholesky : | | Exported generic functions |
| Method, factor : | | Internal generic functions |
| Method, fortran-argument/output-initializer-form : | | Internal generic functions |
| Method, fortran-argument/output-initializer-form : | | Internal generic functions |
| Method, fortran-argument/output-initializer-form : | | Internal generic functions |
| Method, hermitian-factorization : | | Exported generic functions |
| Method, invert : | | Exported generic functions |
| Method, invert : | | Exported generic functions |
| Method, invert : | | Exported generic functions |
| Method, invert : | | Exported generic functions |
| Method, invert : | | Exported generic functions |
| Method, invert : | | Exported generic functions |
| Method, invert : | | Exported generic functions |
| Method, invert : | | Exported generic functions |
| Method, invert-xx : | | Exported generic functions |
| Method, ipiv-internal : | | Internal generic functions |
| Method, left-square-root : | | Exported generic functions |
| Method, left-square-root : | | Exported generic functions |
| Method, left-square-root : | | Exported generic functions |
| Method, logdet : | | Exported generic functions |
| Method, logdet : | | Exported generic functions |
| Method, logdet : | | Exported generic functions |
| Method, lu : | | Exported generic functions |
| Method, lu-matrix : | | Internal generic functions |
| Method, mm : | | Exported generic functions |
| Method, mm : | | Exported generic functions |
| Method, mm : | | Exported generic functions |
| Method, mm : | | Exported generic functions |
| Method, mm : | | Exported generic functions |
| Method, mm : | | Exported generic functions |
| Method, mm : | | Exported generic functions |
| Method, mm : | | Exported generic functions |
| Method, mm : | | Exported generic functions |
| Method, mm : | | Exported generic functions |
| Method, mm : | | Exported generic functions |
| Method, mm : | | Exported generic functions |
| Method, mm : | | Exported generic functions |
| Method, mm : | | Exported generic functions |
| Method, mm : | | Exported generic functions |
| Method, mm : | | Exported generic functions |
| Method, mm : | | Exported generic functions |
| Method, outer : | | Exported generic functions |
| Method, outer : | | Exported generic functions |
| Method, outer : | | Exported generic functions |
| Method, permutations : | | Internal generic functions |
| Method, process-form : | | Internal generic functions |
| Method, process-form : | | Internal generic functions |
| Method, process-form : | | Internal generic functions |
| Method, process-form : | | Internal generic functions |
| Method, process-form : | | Internal generic functions |
| Method, qr : | | Exported generic functions |
| Method, qr : | | Exported generic functions |
| Method, right-square-root : | | Exported generic functions |
| Method, right-square-root : | | Exported generic functions |
| Method, solve : | | Exported generic functions |
| Method, solve : | | Exported generic functions |
| Method, solve : | | Exported generic functions |
| Method, solve : | | Exported generic functions |
| Method, solve : | | Exported generic functions |
| Method, solve : | | Exported generic functions |
| Method, solve : | | Exported generic functions |
| Method, solve : | | Exported generic functions |
| Method, solve : | | Exported generic functions |
| Method, solve : | | Exported generic functions |
| Method, svd : | | Exported generic functions |
| Method, tau : | | Internal generic functions |
| Method, tr : | | Exported generic functions |
| Method, tr : | | Exported generic functions |
| Method, tr : | | Exported generic functions |
| Method, wrap-argument : | | Internal generic functions |
| Method, wrap-argument : | | Internal generic functions |
| Method, wrap-argument : | | Internal generic functions |
| Method, wrap-argument : | | Internal generic functions |
| Method, wrap-argument : | | Internal generic functions |
| Method, wrap-argument : | | Internal generic functions |
| Method, wrap-argument : | | Internal generic functions |
| Method, wrap-argument : | | Internal generic functions |
| Method, wrap-argument : | | Internal generic functions |
| Method, wrap-argument : | | Internal generic functions |
| Method, wrap-argument : | | Internal generic functions |
| Method, wrap-argument : | | Internal generic functions |
| Method, wrap-argument : | | Internal generic functions |
| Method, wrap-argument : | | Internal generic functions |
| Method, wrap-argument : | | Internal generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm : | | Exported generic functions |
| mm-hermitian% : | | Internal functions |
| mmm : | | Exported functions |
|
N | | |
| nrm2 : | | Exported functions |
| number-float-type : | | Internal functions |
|
O | | |
| outer : | | Exported generic functions |
| outer : | | Exported generic functions |
| outer : | | Exported generic functions |
| outer : | | Exported generic functions |
| output-array-form : | | Internal functions |
|
P | | |
| permutations : | | Internal generic functions |
| permutations : | | Internal generic functions |
| process-form : | | Internal generic functions |
| process-form : | | Internal generic functions |
| process-form : | | Internal generic functions |
| process-form : | | Internal generic functions |
| process-form : | | Internal generic functions |
| process-form : | | Internal generic functions |
| process-forms : | | Internal functions |
|
Q | | |
| qr : | | Exported generic functions |
| qr : | | Exported generic functions |
| qr : | | Exported generic functions |
| qr-r : | | Exported functions |
| query-configuration : | | Internal functions |
|
R | | |
| right-square-root : | | Exported generic functions |
| right-square-root : | | Exported generic functions |
| right-square-root : | | Exported generic functions |
|
S | | |
| scal! : | | Exported functions |
| set-feature : | | Internal functions |
| shareable-array? : | | Internal functions |
| solve : | | Exported generic functions |
| solve : | | Exported generic functions |
| solve : | | Exported generic functions |
| solve : | | Exported generic functions |
| solve : | | Exported generic functions |
| solve : | | Exported generic functions |
| solve : | | Exported generic functions |
| solve : | | Exported generic functions |
| solve : | | Exported generic functions |
| solve : | | Exported generic functions |
| solve : | | Exported generic functions |
| spectral-factorization : | | Exported functions |
| spectral-factorization-p : | | Internal functions |
| spectral-factorization-w : | | Exported functions |
| spectral-factorization-z : | | Exported functions |
| sum-diagonal% : | | Internal functions |
| svd : | | Exported generic functions |
| svd : | | Exported generic functions |
| svd-d : | | Exported functions |
| svd-p : | | Internal functions |
| svd-u : | | Exported functions |
| svd-vt : | | Exported functions |
|
T | | |
| tau : | | Internal generic functions |
| tau : | | Internal generic functions |
| tr : | | Exported generic functions |
| tr : | | Exported generic functions |
| tr : | | Exported generic functions |
| tr : | | Exported generic functions |
| transpose-matrix-from-memory : | | Internal functions |
| transpose-matrix-to-memory : | | Internal functions |
| trsm% : | | Internal functions |
|
V | | |
| value-from-memory% : | | Internal functions |
| value-to-memory% : | | Internal functions |
|
W | | |
| with-array-input : | | Internal macros |
| with-array-input-output : | | Internal macros |
| with-array-output : | | Internal macros |
| with-fortran-atom : | | Internal macros |
| with-fortran-character : | | Internal macros |
| with-fp-traps-masked : | | Exported macros |
| with-pinned-array : | | Internal macros |
| with-work-area : | | Internal macros |
| wrap-argument : | | Internal generic functions |
| wrap-argument : | | Internal generic functions |
| wrap-argument : | | Internal generic functions |
| wrap-argument : | | Internal generic functions |
| wrap-argument : | | Internal generic functions |
| wrap-argument : | | Internal generic functions |
| wrap-argument : | | Internal generic functions |
| wrap-argument : | | Internal generic functions |
| wrap-argument : | | Internal generic functions |
| wrap-argument : | | Internal generic functions |
| wrap-argument : | | Internal generic functions |
| wrap-argument : | | Internal generic functions |
| wrap-argument : | | Internal generic functions |
| wrap-argument : | | Internal generic functions |
| wrap-argument : | | Internal generic functions |
| wrap-argument : | | Internal generic functions |
| wrap-arguments : | | Internal functions |
|
X | | |
| xx : | | Exported functions |
|
A.3 Variables
| Index Entry | | Section |
|
& | | |
| &info : | | Internal symbol macros |
|
* | | |
| *lla-efficiency-warning-array-conversion* : | | Exported special variables |
| *lla-efficiency-warning-array-type* : | | Exported special variables |
|
+ | | |
| +complex-double+ : | | Internal constants |
| +complex-single+ : | | Internal constants |
| +double+ : | | Internal constants |
| +float-types+ : | | Internal constants |
| +integer+ : | | Internal constants |
| +internal-types+ : | | Internal constants |
| +single+ : | | Internal constants |
|
A | | |
| array : | | Exported conditions |
| array : | | Exported conditions |
|
C | | |
| character : | | Internal classes |
| condition : | | Internal classes |
| Constant, +complex-double+ : | | Internal constants |
| Constant, +complex-single+ : | | Internal constants |
| Constant, +double+ : | | Internal constants |
| Constant, +float-types+ : | | Internal constants |
| Constant, +integer+ : | | Internal constants |
| Constant, +internal-types+ : | | Internal constants |
| Constant, +single+ : | | Internal constants |
|
D | | |
| d : | | Exported structures |
|
F | | |
| factor : | | Exported classes |
|
I | | |
| info : | | Exported conditions |
| input : | | Internal classes |
| input-force-copy? : | | Internal classes |
| input-transpose? : | | Internal classes |
| input-type : | | Internal classes |
| ipiv-internal : | | Internal classes |
|
L | | |
| left : | | Exported structures |
| lu : | | Exported classes |
|
M | | |
| message : | | Exported conditions |
|
O | | |
| object : | | Exported conditions |
| output : | | Internal classes |
| output : | | Internal classes |
| output-dimensions : | | Internal classes |
| output-transpose? : | | Internal classes |
| output-type : | | Internal classes |
|
P | | |
| pointer : | | Internal classes |
| position : | | Exported conditions |
|
Q | | |
| qr : | | Exported classes |
|
S | | |
| size : | | Internal classes |
| Slot, array : | | Exported conditions |
| Slot, array : | | Exported conditions |
| Slot, character : | | Internal classes |
| Slot, condition : | | Internal classes |
| Slot, d : | | Exported structures |
| Slot, factor : | | Exported classes |
| Slot, info : | | Exported conditions |
| Slot, input : | | Internal classes |
| Slot, input-force-copy? : | | Internal classes |
| Slot, input-transpose? : | | Internal classes |
| Slot, input-type : | | Internal classes |
| Slot, ipiv-internal : | | Internal classes |
| Slot, left : | | Exported structures |
| Slot, lu : | | Exported classes |
| Slot, message : | | Exported conditions |
| Slot, object : | | Exported conditions |
| Slot, output : | | Internal classes |
| Slot, output : | | Internal classes |
| Slot, output-dimensions : | | Internal classes |
| Slot, output-transpose? : | | Internal classes |
| Slot, output-type : | | Internal classes |
| Slot, pointer : | | Internal classes |
| Slot, position : | | Exported conditions |
| Slot, qr : | | Exported classes |
| Slot, size : | | Internal classes |
| Slot, tau : | | Exported classes |
| Slot, type : | | Exported conditions |
| Slot, type : | | Internal classes |
| Slot, u : | | Exported structures |
| Slot, value : | | Internal classes |
| Slot, variable : | | Internal classes |
| Slot, vt : | | Exported structures |
| Slot, w : | | Exported structures |
| Slot, z : | | Exported structures |
| Special Variable, *lla-efficiency-warning-array-conversion* : | | Exported special variables |
| Special Variable, *lla-efficiency-warning-array-type* : | | Exported special variables |
| Symbol Macro, &info : | | Internal symbol macros |
|
T | | |
| tau : | | Exported classes |
| type : | | Exported conditions |
| type : | | Internal classes |
|
U | | |
| u : | | Exported structures |
|
V | | |
| value : | | Internal classes |
| variable : | | Internal classes |
| vt : | | Exported structures |
|
W | | |
| w : | | Exported structures |
|
Z | | |
| z : | | Exported structures |
|
A.4 Data types
| Index Entry | | Section |
|
C | | |
| cholesky : | | Exported structures |
| Class, fortran-argument : | | Internal classes |
| Class, fortran-argument/output : | | Internal classes |
| Class, fortran-argument/size : | | Internal classes |
| Class, fortran-argument/type : | | Internal classes |
| Class, fortran-atom : | | Internal classes |
| Class, fortran-character : | | Internal classes |
| Class, fortran-input-array : | | Internal classes |
| Class, fortran-input-output-array : | | Internal classes |
| Class, fortran-output-array : | | Internal classes |
| Class, fortran-work-area : | | Internal classes |
| Class, hermitian-factorization : | | Exported classes |
| Class, ipiv-mixin : | | Internal classes |
| Class, lapack-info : | | Internal classes |
| Class, lapack-work-query-area : | | Internal classes |
| Class, lapack-work-query-size : | | Internal classes |
| Class, lu : | | Exported classes |
| Class, qr : | | Exported classes |
| Condition, lapack-error : | | Exported conditions |
| Condition, lapack-failure : | | Exported conditions |
| Condition, lapack-invalid-argument : | | Exported conditions |
| Condition, lapack-singular-matrix : | | Exported conditions |
| Condition, lla-efficiency-warning : | | Exported conditions |
| Condition, lla-efficiency-warning-array-conversion : | | Exported conditions |
| Condition, lla-efficiency-warning-array-type : | | Exported conditions |
| Condition, lla-incompatible-dimensions : | | Exported conditions |
| Condition, lla-internal-error : | | Exported conditions |
| Condition, lla-unhandled-type : | | Exported conditions |
|
F | | |
| float-type : | | Internal types |
| fortran-argument : | | Internal classes |
| fortran-argument/output : | | Internal classes |
| fortran-argument/size : | | Internal classes |
| fortran-argument/type : | | Internal classes |
| fortran-atom : | | Internal classes |
| fortran-character : | | Internal classes |
| fortran-input-array : | | Internal classes |
| fortran-input-output-array : | | Internal classes |
| fortran-output-array : | | Internal classes |
| fortran-work-area : | | Internal classes |
|
H | | |
| hermitian-factorization : | | Exported classes |
|
I | | |
| internal-type : | | Internal types |
| ipiv-mixin : | | Internal classes |
|
L | | |
| lapack-error : | | Exported conditions |
| lapack-failure : | | Exported conditions |
| lapack-info : | | Internal classes |
| lapack-invalid-argument : | | Exported conditions |
| lapack-singular-matrix : | | Exported conditions |
| lapack-work-query-area : | | Internal classes |
| lapack-work-query-size : | | Internal classes |
| lla : | | The lla system |
| lla : | | The lla package |
| lla-complex-double : | | Exported types |
| lla-complex-single : | | Exported types |
| lla-double : | | Exported types |
| lla-efficiency-warning : | | Exported conditions |
| lla-efficiency-warning-array-conversion : | | Exported conditions |
| lla-efficiency-warning-array-type : | | Exported conditions |
| lla-incompatible-dimensions : | | Exported conditions |
| lla-integer : | | Exported types |
| lla-internal-error : | | Exported conditions |
| lla-single : | | Exported types |
| lla-unhandled-type : | | Exported conditions |
| lu : | | Exported classes |
|
M | | |
| matrix-square-root : | | Exported structures |
| maximum-array-size : | | Internal types |
|
P | | |
| Package, lla : | | The lla package |
|
Q | | |
| qr : | | Exported classes |
|
S | | |
| spectral-factorization : | | Exported structures |
| Structure, cholesky : | | Exported structures |
| Structure, matrix-square-root : | | Exported structures |
| Structure, spectral-factorization : | | Exported structures |
| Structure, svd : | | Exported structures |
| svd : | | Exported structures |
| System, lla : | | The lla system |
|
T | | |
| Type, float-type : | | Internal types |
| Type, internal-type : | | Internal types |
| Type, lla-complex-double : | | Exported types |
| Type, lla-complex-single : | | Exported types |
| Type, lla-double : | | Exported types |
| Type, lla-integer : | | Exported types |
| Type, lla-single : | | Exported types |
| Type, maximum-array-size : | | Internal types |
|