# FUNCTION

# Public

# COPY (MATRIX)

Return a deep copy of MATRIX with the same implementation and
element-type.

# COPY-MAYBE (MATRIX TEST)

Return a deep copy of MATRIX if TEST is satisfied, or return MATRIX
itself. TEST is a function of one argument that will be applied to
MATRIX.

# COPY-MAYBE* (MATRIX TEST IMPLEMENTATION)

Same as COPY-MAYBE but specify the implementation.

# DATATYPE->LETTER (DATATYPE)

Converts the given DATATYPE to the letter that symbolizes it in the
BLAS and LAPACK.
Use Example:
(string= "D" (datatype->letter 'double))

# DIAGONALF (MAT &KEY (TYPE ROW))

This function provides a deep copy alternative to the diagonal
class structure, and also might be cleaner to work with. But might
not be quite so flexible.

# EYE (NROWS NCOLS &KEY (IMPLEMENTATION *DEFAULT-IMPLEMENTATION*) (ELEMENT-TYPE *DEFAULT-ELEMENT-TYPE*))

Create a NROWS x NCOLS matrix with ones on the diagonal, and zeros
elsewhere. Mnemonic: eye for I(n,m)

# FLOAT (NUMBER &OPTIONAL (OTHER NIL OTHERP))

Converts any REAL to a float. If OTHER is not provided, it returns a
SINGLE-FLOAT if NUMBER is not already a FLOAT. If OTHER is provided, the
result is the same float format as OTHER.

# LIST->VECTOR-LIKE (LISTVAR &KEY (COERCE-TO 'DOUBLE-FLOAT) (ORIENTATION ROW))

Create a vector-like using default implementation. Use globals to
change implementation, etc. By default, we assume lists are
variables, not cases (i.e. follow lispstat convention), and therefore
convert to column.

# LIST-OF-COLUMNS (M)

Returns a list of vector-like elements from matrix M.
FIXME: AWFUL.

# LIST-OF-ROWS (M)

Returns a list of vector-like elements from matrix M.
FIXME: AWFUL IMPLEMENTATION

# MAKE-MATRIX (NROWS NCOLS &KEY (IMPLEMENTATION *DEFAULT-IMPLEMENTATION*) (ELEMENT-TYPE *DEFAULT-ELEMENT-TYPE*) (INITIAL-ELEMENT NIL INITIAL-ELEMENT-P) (INITIAL-CONTENTS NIL INITIAL-CONTENTS-P))

Create a NROWS x NCOLS matrix with
MATRIX-IMPLEMENTATION as underlying implementation. ELEMENT-TYPE is
the lisp type to be stored in the matrix, and INITIAL-ELEMENT an
element that may be used to initially fill the matrix.
If INITIAL-ELEMENT is not specified, the matrix is not initialized,
and accessing its elements will thus return spurious values.
If INITIAL-CONTENTS is specified, it is used to initialize the
matrix, by using the generic function COPY!.
IMPLEMENTATION can be one of :LISP-ARRAY and :FOREIGN-ARRAY

# MAKE-PREDICATE (FORM)

From an expression combining predicates, construct a function of
one argument that evaluates the logical expression on the element,
where each predicate is applied to the argument to obtain its
logical value.
FORM may be constructed as follows: a symbol whose f-value is a
function of one argument; a list whose car is 'OR and whose CDR is a
list of predicates; a list whose car is 'AND and whose CDR is a list
of predicates; T; NIL.

# MAKE-VECTOR (NELTS &KEY (TYPE ROW) (IMPLEMENTATION *DEFAULT-IMPLEMENTATION*) (ELEMENT-TYPE *DEFAULT-ELEMENT-TYPE*) (INITIAL-ELEMENT NIL INITIAL-ELEMENT-P) (INITIAL-CONTENTS NIL INITIAL-CONTENTS-P))

Make a vector containing NELTS elements of type ELEMENT-TYPE, and
with IMPLEMENTATION as underlying implementation. The vector is a
row vector if TYPE is :ROW, and a column vector if TYPE is :COLUMN.
If INITIAL-ELEMENT is not specified, the vector is not initialized,
and accessing its elements will thus return spurious values.
If INITIAL-CONTENTS is specified, it is used to initialize the
vector, by using the generic function COPY!.
IMPLEMENTATION can be one of :LISP-ARRAY and :FOREIGN-ARRAY

# MAP-VEC (UNIFCN VEC)

Apply univariate function to each element of old vector, returning
new one.
(map-vec #'(lambda (x) (* 2.0 x))
(make-vector 4 :initial-element 2d0))
=> #<LA-SIMPLE-VECTOR-DOUBLE (1 x 4) 4.0 4.0 4.0 4.0>
(map-vec #'sqrt
(make-vector 4 :initial-element 2d0))
=> #<LA-SIMPLE-VECTOR-DOUBLE (1 x 4) 1.4142135623730951 1.4142135623730951 1.4142135623730951 1.4142135623730951>

# MATRIX-LIKE-SYMMETRIC-P (M)

FIXME: basically right, but too long.

# MINV-CHOLESKY (A)

invert A using LU Factorization. A must be symmetric.

# MINV-LU (A)

invert A using LU Factorization

# MSOLVE-CHOLESKY (A B)

Compute `x1' solving `A x = b', with LU factorization.

# MSOLVE-LU (A B)

Compute `x1' solving `A x = b', with LU factorization.

# ONES (NROWS NCOLS &KEY (IMPLEMENTATION *DEFAULT-IMPLEMENTATION*) (ELEMENT-TYPE *DEFAULT-ELEMENT-TYPE*))

Create a NROWS x NCOLS matrix filled with ones.

# RAND (NROWS NCOLS &KEY (IMPLEMENTATION *DEFAULT-IMPLEMENTATION*) (ELEMENT-TYPE *DEFAULT-ELEMENT-TYPE*) (STATE *RANDOM-STATE*) (VALUE 1))

Create a NROWS x NCOLs matrix filled with uniformly distributed
pseudo-random numbers between 0 and VALUE.

# TRAP2MAT (M &KEY (TYPE UPPER))

Copy the trapezoid, lower or upper, into the other side (i.e. upper
triagular storage into full storage). For non-square matrices, there
might be a bit of excess to ignore; but we only handle the top square
of the rectangle.

# VECTOR-LIKE->LIST (VECVAR)

Create a list from a vector-like.

# ZEROS (NROWS NCOLS &KEY (IMPLEMENTATION *DEFAULT-IMPLEMENTATION*) (ELEMENT-TYPE *DEFAULT-ELEMENT-TYPE*))

Create a NROWS x NCOLS matrix filled with zeros.

# Undocumented

# ASSERT-VALID-MATRIX-INDEX (MATRIX I J)

# FLATTEN-MATRIX-INDICES-1 (MATRIX I J)

# OPPOSITE-ORIENTATION (ORIENTATION)

# VALID-ORIENTATION-P (ORIENTATION)

# Private

# %CLEAN-LAMBDA-LIST (LAMBDA-LIST)

Helper for DEF-LAPACK-METHOD.
Clean LAMBDA-LIST so that it can be the lambda-list of a generic
function.

# %GET-FUNCTIONS (NAME-AND-OPTIONS)

Used in DEF-LAPACK-METHOD.
NAME-AND-OPTIONS is either: NAME, or (NAME &KEY FUNCTION-NAMES).
If FUNCTION-NAMES is not set, the names are automatically generated by
prepending NAME by the character #\% and one of the characters '(#\s
#\d #\c #\z) which correspond to the data types supported by
fortran. If one function name does not exist, it is ignored so it is
safe to use this for example for xDOT which has only %SDOT and %DDOT
as functions. If FUNCTION-NAMES is set, then it is a list where each
element is of the form (FUNCTION-NAME TYPE) where FUNCTION-NAME is the
symbol to use for the function to call, and TYPE is the lisp type to
use, which is one of '(single-float double-float (complex
double-float) (complex single-float)).
Example use:
(%get-functions 'gemm)
(%get-functions '(nrm2 :function-names
((%snrm2 single-float)
(%dnrm2 double-float)
(%scnrm2 (complex single-float))
(%dznrm2 (complex double-float)))))

# %GET-NAME (NAME-AND-OPTIONS)

Used in DEF-LAPACK-METHOD.
NAME-AND-OPTIONS is either: NAME, or (NAME &KEY FUNCTION-NAMES).
Returns NAME.

# ADD-LA-DEFAULT-VALUE (ELEMENT-TYPE VALUE)

Add VALUE as default value for ELEMENT-TYPE.

# DEFINE-IMPLEMENTATION (KEYWORD SHORT-NAME)

Define an implementation named KEYWORD and with SHORT-NAME (a
string) as abbreviated name.

# ELEMENT-TYPE->FNV-TYPE (ELEMENT-TYPE)

Return the FNV type corresponding to ELEMENT-TYPE.

# FNV-TYPE->ELEMENT-TYPE (FNV-TYPE)

Return the lisp type corresponding to FNV-TYPE.

# LA-DEFAULT-VALUE (ELEMENT-TYPE)

Default value for a given ELEMENT-TYPE.

# LA-MATRIX-CLASS (ELEMENT-TYPE &OPTIONAL (TYPE SIMPLE))

Return the LA-MATRIX class name corresponding to ELEMENT-TYPE.

# LA-VECTOR-CLASS (ELEMENT-TYPE &OPTIONAL (TYPE SIMPLE))

Return the LA-VECTOR class name corresponding to ELEMENT-TYPE.

# LEAST-SQUARES-GELSY (X Y)

Solves:
X beta = Y,
for beta.

# LISP-MATRIX-TYPE->LISP-TYPE (LISP-MATRIX-TYPE)

Return the lisp type corresponding to LISP-MATRIX-TYPE.

# LISP-TYPE->LISP-MATRIX-TYPE (LISP-TYPE)

Return the LISP-MATRIX-TYPE corresponding to the lisp type
LISP-TYPE.

# MAKE-SYMBOL* (&REST ARGS)

build a symbol by concatenating each element of ARGS, and intern it
in the current package. Elements can be strings or symbols.

# MATRIX-CLASS (CLASS-TYPE &OPTIONAL IMPLEMENTATION ELEMENT-TYPE)

Return the matrix class name corresponding to CLASS-TYPE. When
IMPLEMENTATION-SHORTNAME is given, it gives the class for the given
implementation, and when ELEMENT-TYPE-SHORTNAME is given, a
specialized class for that element type.

# ORIENTATION->LETTER (ORIENTATION)

Return the LAPACK letter corresponding to ORIENTATION.

# ORIENTATION-LETTER (MATRIX)

Return the LAPACK letter corresponding to the orientation of
MATRIX.

# TYPE-INFO-CFFI-TYPE (INSTANCE)

@arg[extid]{A @class{extid}}
@return[sytemid]{puri:uri or nil}
Returns the System ID part of this External ID.

# TYPE-INFO-LISP-MATRIX-TYPE (INSTANCE)

@arg[extid]{A @class{extid}}
@return[sytemid]{puri:uri or nil}
Returns the System ID part of this External ID.

# TYPE-INFO-LISP-TYPE (INSTANCE)

@arg[extid]{A @class{extid}}
@return[sytemid]{puri:uri or nil}
Returns the System ID part of this External ID.

# TYPE-INFO-SIZE (INSTANCE)

# VECTOR-CLASS (CLASS-TYPE &OPTIONAL IMPLEMENTATION ELEMENT-TYPE)

Return the vector class name corresponding to CLASS-TYPE. When
IMPLEMENTATION-SHORTNAME is given, it gives the class for the given
implementation, and when ELEMENT-TYPE-SHORTNAME is given, a
specialized class for that element type.

# Undocumented

# ADD-TYPE (&KEY (LISP-TYPE T) (LISP-MATRIX-TYPE T) CFFI-TYPE)

# CHECK-INFO (INFO FUNCTION-NAME)

# COPY-TYPE-INFO (INSTANCE)

# IMPLEMENTATION-SHORT-NAME (IMPLEMENTATION)

# LA-MATRIX->POINTER (MATRIX)

# LISP-MATRIX-TYPE-INFO (LISP-MATRIX-TYPE)

# LISP-MATRIX-TYPE-SIZE (LISP-MATRIX-TYPE)

# LISP-TYPE-INFO (LISP-TYPE)

# LISP-TYPE-SIZE (LISP-TYPE)

# MAKE-TYPE-INFO (&KEY ((LISP-TYPE DUM45) T) ((LISP-MATRIX-TYPE DUM46) T) ((CFFI-TYPE DUM47) NIL) ((SIZE DUM48) 0))

# SETFTYPE-INFO-CFFI-TYPE (NEW-VALUE INSTANCE)

# SETFTYPE-INFO-LISP-MATRIX-TYPE (NEW-VALUE INSTANCE)

# SETFTYPE-INFO-LISP-TYPE (NEW-VALUE INSTANCE)

# TYPE-INFO-P (OBJECT)

# SETFTYPE-INFO-SIZE (NEW-VALUE INSTANCE)

# MACRO

# Public

# MAKE-PREDICATE-MACRO (FORM)

Trying to fix make-predicate, through a macro approach. DOES NOT
WORK! Idea: we want to return an anonymous function which implements
the predicate desired. However, this isn't used any where (though it
could be used in countless situations).

# Private

# CALL-WITH-WORK ((LWORK WORK TYPE) CALL)

This macro computes the needed workspace, and then recalls the
function with the correct-sized array (appropriately allocated).
lwork, work are the appropriate symbols, and type should be the
replaceable type from def-lapack-method.

# CONSTRUCT-LA-MATRIX (ELEMENT-TYPE DEFAULT-VALUE)

Construct a matrix class holding elements of type ELEMENT-TYPE
based on lisp arrays.

# DEF-LAPACK-METHOD (NAME-AND-OPTIONS (&REST LAMBDA-LIST) &BODY BODY)

Define methods for supported datatypes for the lapack method named
NAME. The symbols !FUNCTION, !DATA-TYPE, and !MATRIX-TYPE are
respectively bound to the actual lapack function to be called from
the package CL-BLAPACK, the data type (float, double, complex-float
or complex-double), and the corresponding abstract matrix
type (e.g. matrix-double-like).
NAME-AND-OPTIONS is either: NAME, or (NAME &KEY FUNCTION-NAMES).
If FUNCTION-NAMES is not set, the names are automatically generated
by prepending NAME by the character #\% and one of the characters
'(#\s #\d #\c #\z) which correspond to the data types supported
by fortran. If one function name does not exist, it is ignored so
it is safe to use this for example for xDOT which has only %SDOT and
%DDOT as functions. If FUNCTION-NAMES is set, then it is a list
where each element is of the form (FUNCTION-NAME TYPE) where
FUNCTION-NAME is the symbol to use for the function to call, and
TYPE is the lisp type to use, which is one of '(single-float
double-float (complex double-float) (complex single-float)).
See for example the definition of GEMM for how to use this macro.

# DEF-LISP-MATRIX-TYPE (NAME LISP-TYPE &KEY CFFI-TYPE)

Define a new lisp-matrix type of name NAME from the lisp type
TYPE.

# DEFINE-ABSTRACT-CLASS (CLASSNAME SUPER-LIST &BODY BODY)

A wrapper for DEFCLASS that lets you define abstract base classes.
If you try to instantiate an object of this class, a warning is signaled.

# WITH-COPIES ((&REST FORMS) RESULT &BODY BODY)

Each form in FORMS is a lambda-list defined as (VARIABLE PREDICATE
&optional COPY-BACK-P). VARIABLE is a symbol bound to a matrix,
that is to be copied if the predicate obtained from PREDICATE
applied to the matrix is true. All variables are bound
to (possible) copies of the original matrices, and body is executed.
After that, variables for which COPY-BACK-P is true are copied back
to the original matrices, and the evaluation of RESULT is returned
with the variables bound to the original matrices. (and hence are
destructive variants of the methods).
The PREDICATE value may be constructed as follows: a symbol whose
f-value is a function of one argument; a list whose car is 'OR and
whose CDR is a list of predicates; a list whose car is 'AND and
whose CDR is a list of predicates; T; NIL.
See the file `lapack-methods.lisp' for examples of use.

# WITH-PINNED-ARRAYS ((&REST ARRAYS) &BODY BODY)

Make sure that every array will not be moved by the GC in ARRAYS
is pinned during the execution of BODY.

# WITH-PINNED-COPIES ((&REST FORMS) RESULT &BODY BODY)

Same as WITH-COPIES, but make sure that the arrays obtained after
eventual copying are pinned while executing BODY.

# WITH-TYPED-VALUES ((&REST BINDINGS) MATRIX &BODY BODY)

Each binding in BINDINGS is of the form (VARIABLE VALUE). VARIABLE
is bound to VALUE coerced to the element type of MATRIX.

# Undocumented

# CONSTRUCT-FA-MATRIX (ELEMENT-TYPE)

# MAKE-MATRIX-CLASS-HIERARCHY (IMPLEMENTATION ELEMENT-TYPE)

# MAKE-VECTOR-CLASS-HIERARCHY (IMPLEMENTATION ELEMENT-TYPE)

# GENERIC-FUNCTION

# Public

# ASUM (X)

Wrapper for lapack methods %SASUM, %DASUM, %SCASUM, %DZASUM.

# AXPY (ALPHA X Y)

Wrapper for lapack methods %SAXPY, %DAXPY, %CAXPY, %ZAXPY.

# BIND2 (M1 M2 &KEY BY (BY ROW))

Simple experiment, not necessarily part of the API
yet! When type is :row, If the number of columns of m1 and m2
match, join them. Think of a sandwich approach, resulting in:
m1
--
m2
The ARGS can be matrices, vectors, or lists. Arguments are bound
into a matrix along their rows. Example:
(bind2 #2a((1 2)(3 4)) #(5 6) :by :row)
returns
#2a((1 2)(3 4)(5 6))
When type is :column, if the number of rows of m1 and m2 match, join
them. Think of a pair of columns, resulting in
m1 | m2
API should result with the ARGS as matrices, vectors, or
lists. Arguments are bound into a matrix along their columns.
Example:
(bind2 #2a((1 2)(3 4)) #(5 6) :by :column)
returns
#2a((1 2 5)(3 4 6))

# COL (MATRIX J)

Return a view on a given column of MATRIX.

# COPY! (A B)

Copy A into B if they are not the same object, and
return B. A and B should be matrices or vectors with the same
dimensions, but not necessarily of the same implementation.

# COPY* (MATRIX IMPLEMENTATION)

Same as COPY but specify the implementation.

# DIAGONAL! (MAT &KEY TYPE (TYPE ROW))

create a vector representing the diagonal of matrix
x. This is a deep copy, NOT a view. It might be easy to write the
view as a class with appropriate
vref x i
pulling out
mref x i i
should we write such a view?

# DOT (X Y)

Wrapper for lapack methods %SDOT, %DDOT.

# DOTC (X Y)

Wrapper for lapack methods %CDOTC, %ZDOTC.

# DOTU (X Y)

Wrapper for lapack methods %CDOTU, %ZDOTU.

# FILL-MATRIX (MATRIX FILL-ELEMENT)

Set each element of MATRIX to FILL-ELEMENT.

# FLATTEN-MATRIX-INDICES (MATRIX I J)

Given an index pair (I,J) into the given matrix
MATRIX, returns the 1-D index corresponding to the location in the
underlying storage in which the element MATRIX(i,j) is stored.
The default implementation is for a column-major dense storage,
corresponding to the default implementation of the generic function
ORIENTATION.

# GELSY (A B RCOND &OPTIONAL JPVT)

Wrapper for lapack methods %SGELSY, %DGELSY.

# GEMM (ALPHA A B BETA C)

Wrapper for lapack methods %SGEMM, %DGEMM, %CGEMM, %ZGEMM.

# GEQRF (A)

Wrapper for lapack methods %SGEQRF, %DGEQRF, %CGEQRF, %ZGEQRF.

# GETRF (A &OPTIONAL IPIV)

Wrapper for lapack methods %SGETRF, %DGETRF, %CGETRF, %ZGETRF.

# GETRI (A IPIV)

Wrapper for lapack methods %SGETRI, %DGETRI, %CGETRI, %ZGETRI.

# GETRS (A B IPIV-A)

Wrapper for lapack methods %SGETRS, %DGETRS, %CGETRS, %ZGETRS.

# IAMAX (X)

Wrapper for lapack methods %ISAMAX, %IDAMAX, %ICAMAX, %IZAMAX.

# M* (A B)

Matrix multiplication: A * B. Defaults to the
element type of the first matrix.
Better approach would be to consider lowest-common-type?

# M+ (A B)

Matrix addition: A + B.

# M- (A B)

Matrix subtraction: A - B.

# M.* (MATA MATB)

same as m+ which is inherently an element-wise
operation. How should we handle coercion? probably the right way to
do this will be to consider the least specific form, and coerce
back. HOWEVER, this could be done simpler by barfing (forcing
explicit coercion) and this would be safer, numerically.

# M.+ (MATA MATB)

same as m+ which is inherently an element-wise operation.

# M.- (MATA MATB)

same as m- which is inherently an element-wise operation.

# M= (A B)

Test for strict equality of dimensions and of each
matrix element of A and B.

# MAKE-MATRIX* (NROWS NCOLS IMPLEMENTATION &KEY ELEMENT-TYPE INITIAL-ELEMENT (INITIAL-ELEMENT NIL INITIAL-ELEMENT-P))

Create a NROWS x NCOLS matrix with IMPLEMENTATION
as underlying implementation. ELEMENT-TYPE is the lisp type to be
stored in the matrix, and INITIAL-ELEMENT an element that may be
used to initially fill the matrix.
If INITIAL-ELEMENT is not specified, the matrix is not initialized,
and accessing its elements will thus return spurious values.
Tony notes: principle seems to be to use a function for the API,
dispatching to generics for the meat of the work.

# MATRIX-DIMENSION (MATRIX AXIS-NUMBER)

Like ARRAY-DIMENSION for matrix-like objects.

# MATRIX-DIMENSIONS (MATRIX)

Like ARRAY-DIMENSIONS for matrix-like objects.

# MREF (MATRIX I J)

(MREF MATRIX I J) gives you the (I,J)-th element of
MATRIX. This method is slow as it requires CLOS method dispatch and
index calculation(s), and should thus be replaced with vectorized or
block operations whenever possible.

# SETFMREF (VALUE MATRIX I J)

Set the (I,J)-th element of MATRIX to VALUE. This
method is slow as it requires CLOS method dispatch and index
calculation(s), and should thus be replaced with vectorized or block
operations whenever possible.

# NELTS (MATRIX)

Default method for computing the number of elements
of a matrix. For obvious reasons, this will be overridden for
subclasses that implement sparse matrices.

# NRM2 (X)

Wrapper for lapack methods %SNRM2, %DNRM2, %SCNRM2, %DZNRM2.

# ORIENTATION (MATRIX)

lisp-matrix objects are stored by default in
column-major order for compatibility with the BLAS and LAPACK, which
are Fortran-based.

# POTRF (A)

Wrapper for lapack methods %SPOTRF, %DPOTRF, %CPOTRF, %ZPOTRF.

# POTRI (A)

Wrapper for lapack methods %SPOTRI, %DPOTRI, %CPOTRI, %ZPOTRI.

# POTRS (A B IPIV-A)

Wrapper for lapack methods %SPOTRS, %DPOTRS, %CPOTRS, %ZPOTRS.

# REAL-STRIDE (VECTOR)

Return the stride that VECTOR has when considering
the ancestor matrix as base. If VECTOR is constructed so that it
has no simple stride (for example a slice on a windowed matrix
considered as a vector may have a different stride when jumping
columns of the matrix), then return NIL.

# ROW (MATRIX I)

Return a view on a given row of MATRIX.

# SCAL (ALPHA X)

Wrapper for lapack methods %SSCAL, %DSCAL, %CSCAL, %ZSCAL.

# SLICE (MATRIX &KEY OFFSET STRIDE NELTS TYPE (TYPE ROW) (NELTS (NELTS MATRIX)) (STRIDE 1) (OFFSET 0))

Create a slice view of MATRIX. To be precise, this
results in a vector (matrix subclass) which is done by
:type : output shape (:column or :row)
:offset : number of observations (in col/row major
matrix-dependent order) to skip over before starting
extraction
:stride : index increment between current and next element, i.e.
0 = repeat same value; 1, as ordered, 2 every other,
etc...
one of the challenges is that this seems to prefer col-oriented
matrices, but we need to know whether we are column- or row-
oriented. Perhaps we should be checking so to decide how to walk
down the matrix?

# STRIDES (MATRIX &KEY NROWS NCOLS ROW-OFFSET COL-OFFSET ROW-STRIDE COL-STRIDE (COL-STRIDE 1) (ROW-STRIDE 1) (COL-OFFSET 0) (ROW-OFFSET 0) (NCOLS (NCOLS MATRIX)) (NROWS (NROWS MATRIX)))

Creates a strided view of the given matrix-like
object MATRIX. The resulting matrix may be a WINDOW-MATVIEW, a
STRIDED-MATVIEW or a SLICE-VECVIEW depending on the parameters.
FIXME: consider a variant of this which allows for vector-recycling
of the strides specification. For example, #(1 2) will do the
right indexing until the matrix range/indicies are exhausted. This
is good for data manipulation but not clear if the right motif for
numerics.

# TRANSPOSE-CLASS (MATRIX)

Return the name of the class to be used for a
transpose of MATRIX.

# TRANSPOSE-MATRIX (MATRIX)

Creates a transpose view of the given matrix-like
object MATRIX. Returns the original matrix if transposed two
times.
General approach is to ensure that we only change the class, not
the matrix itself, and we rely on reference semantics for this to
happen.
(FIXME: is that a good idea? It is probably ok since TRANSPOSE
does not copy the data anyway; if we want a copy, we do it
explicitly.)

# TRANSPOSED-P (MATRIX)

Is MATRIX a transposed view of its ancestor matrix?

# UNIT-STRIDES-P (MATRIX)

Tests for "unit stride." (The strided matrix view
is the only view which causes itself and its children possibly not
to have unit stride.)

# V* (X Y &OPTIONAL RETURN-TYPE)

add a vector-like, vector, or list and return in a
vector-like structure unless return-type is something else

# V+ (X Y &OPTIONAL RETURN-TYPE)

add a vector-like, vector, or list and return in a
vector-like structure unless return-type is something else

# V- (X Y &OPTIONAL RETURN-TYPE)

add a vector-like, vector, or list and return in a
vector-like structure unless return-type is something else

# V/ (X Y &OPTIONAL RETURN-TYPE)

# V= (X Y)

Test for equality of both number of elements and
of the elements themselves, for the two vectors X and Y.
A row vector and a column vector with the same number of elements
are equal. To distinguish them, use M= instead.

# VECTOR-DIMENSION (VECTOR)

Like ARRAY-DIMENSION for vector-like objects.

# VREF (VECTOR I)

Return the I-th element of VECTOR. This method is
slow as it requires CLOS method dispatch and index calculation(s),
and should thus be replaced with vectorized or block operations
whenever possible

# SETFVREF (VALUE VECTOR I)

Set the I-th element of VECTOR to VALUE. This
method is slow as it requires CLOS method dispatch and index
calculation(s), and should thus be replaced with vectorized or block
operations whenever possible.

# WINDOW (MATRIX &KEY NROWS NCOLS ROW-OFFSET COL-OFFSET (NROWS (NROWS MATRIX)) (NCOLS (NCOLS MATRIX)) (ROW-OFFSET 0) (COL-OFFSET 0))

Creates a window view of the given matrix-like
object MATRIX. Note that window views ALWAYS have the same
orientation as their parents.

# WINDOW-CLASS (MATRIX)

Return the name of the class to be used for a
window of MATRIX.

# ZERO-OFFSET-P (MATRIX)

Has MATRIX a zero offset (as for window and stride
views)?

# Undocumented

# COL-VECTOR-P (MATRIX)

# CROSS-PRODUCT (MATA MATB)

# PRINT-OBJECT (OBJECT STREAM)

# ROW-VECTOR-P (MATRIX)

# Private

# ANCESTOR (MATRIX)

For a MATVIEW matrix, return the ancestor matrix to
which this matrix view relates.

# CHECK-INVARIANT (VECTOR)

Check the class invariant of VECTOR, namely that it
has one column or one row.

# EIGENSYSTEMS (X)

Compute the eigenvectors and values of X.

# ELEMENT-TYPE (MATRIX)

Type of the elements of MATRIX.

# ELEMENT-TYPE-SIZE (MATRIX)

Size in memory of the elements of MATRIX (useful
for pointer arithmetic when calling foreign functions).

# FACTORIZE (A &KEY BY (BY QR))

matrix decomposition, M -> SVD/LU/AtA etc.
FIXME: do we want a default type? If BY is NIL then return A untouched.

# FACTORIZED-MATRIX (A)

Return the matrix (and not the structure). The
latter is the standard result from factorization routine.

# GESVD (A)

Wrapper for lapack methods %SGESVD, %DGESVD.

# IMPLEMENTATION (MATRIX)

Underlying implementation of MATRIX.

# INVERT (A &OPTIONAL BY)

compute inverse of A using the appropriate factorization.

# LEAST-SQUARES (Y X &KEY W)

Compute the (weighted/generalized) least-squares solution B to W(Y-XB)

# M./ (MATA MATB)

same as m+ which is inherently an element-wise
operation. How should we handle coercion? probably the right way to
do this will be to consider the least specific form, and coerce
back. HOWEVER, this could be done simpler by barfing (forcing
explicit coercion) and this would be safer, numerically.

# MAKE-FA-MATRIX (NROWS NCOLS FNV-TYPE &KEY INITIAL-ELEMENT)

Same as MAKE-MATRIX*, but specific to matrix of
implementation :FOREIGN-ARRAY and specialize on FNV-TYPE.

# MATVIEW-P (MATRIX)

Is MATRIX a MATVIEW?

# REAL-NCOLS (MATRIX)

Return the actual number of columns of the matrix
into which MATRIX is stored, i.e. the number of columns of the
ancestor of MATRIX.

# REAL-NELTS (MATRIX)

Return the actual number of elements of the vector
in which MATRIX is stored, namely the number of columns of the
ancestor of MATRIX.

# REAL-NROWS (MATRIX)

Return the actual number of rows of the matrix into
which MATRIX is stored, i.e. the number of rows of the ancestor of
MATRIX.

# SLICE-CLASS (MATRIX)

Return the name of the class to be used for a slice
of MATRIX.

# STRIDE-CLASS (MATRIX)

Return the name of the class to be used for a
stride of MATRIX.

# V=2 (&REST ARGS)

Test for equality of both number of elements and
of the elements themselves, for the two vectors X and Y.
A row vector and a column vector with the same number of elements
are equal. To distinguish them, use M= instead.

# VECTOR-ORIENTATION (VECTOR)

Whether the vector is considered as a row
vector (:ROW) or a column vector (:COLUMN) for matrix operations.
This has no effect on storage since the values are stored
contiguously, or with a stride for vector views.

# VECVIEW-P (VECTOR)

Is VECTOR a VECVIEW?

# SLOT-ACCESSOR

# Public

# COL-OFFSET (OBJECT)

If we are not specialize, then we need to consider that we no
longer need to think about anything but 0.

# COL-STRIDE (OBJECT)

Stride in the column direction

# DATA (MATRIX)

The Return the underlying data of the matrix.

# SETFDATA (NEW-VALUE OBJECT)

Set the Return the underlying data of the matrix.

# NCOLS (MATRIX)

The Number of columns in the matrix.

# NROWS (MATRIX)

The Number of rows in the matrix.

# OFFSET (MATRIX)

The Offset of the first element of MATRIX.

# PARENT (MATRIX)

The For a MATVIEW matrix, returns the parent matrix to
which this matrix view relates.

# ROW-OFFSET (OBJECT)

If we are not specialize, then we need to consider that we no
longer need to think about anything but 0.

# ROW-STRIDE (OBJECT)

Stride in the row direction

# Private

# Undocumented

# FACTORIZATION-TYPE (OBJECT)

# RESULTS (OBJECT)

# STRIDE (OBJECT)

# VARIABLE

# Public

# *DEFAULT-ELEMENT-TYPE*

Possible values:
'double-float 'single-float 'complex-single-float
but this list is probably incomplete.

# *DEFAULT-IMPLEMENTATION*

One of :LISP-ARRAY (use FFA package) or :FOREIGN-ARRAY (uses FNV
package).

# *IMPLEMENTATIONS*

Table of available implementations.

# *SUPPORTED-DATATYPES*

Association list mapping each supported datatype to its BLAS/LAPACK
letter.

# Private

# *LA-DEFAULT-VALUE-TABLE*

Table of default element types.

# *TYPE-TABLE*

Table with information about lisp-matrix types, which are used in
the class names of typed matrices and correspond to their element
type.

# Undocumented

# *FNV-TYPE-TABLE*

# CLASS

# Public

# FA-SIMPLE-MATRIX-DOUBLE

Dense matrix holding elements of type DOUBLE-FLOAT, implemented as a foreign array.

# FA-SIMPLE-VECTOR-DOUBLE

Dense vector holding elements of type DOUBLE-FLOAT, implemented as a foreign array.

# LA-SIMPLE-MATRIX-COMPLEX-DOUBLE

Dense matrix holding elements of type (COMPLEX DOUBLE-FLOAT), implemented as a lisp array.

# LA-SIMPLE-MATRIX-COMPLEX-SINGLE

Dense matrix holding elements of type (COMPLEX SINGLE-FLOAT), implemented as a lisp array.

# LA-SIMPLE-MATRIX-DOUBLE

Dense matrix holding elements of type DOUBLE-FLOAT, implemented as a lisp array.

# LA-SIMPLE-MATRIX-FIXNUM

Dense matrix holding elements of type FIXNUM, implemented as a lisp array.

# LA-SIMPLE-MATRIX-INTEGER

Dense matrix holding elements of type INTEGER, implemented as a lisp array.

# LA-SIMPLE-MATRIX-SINGLE

Dense matrix holding elements of type SINGLE-FLOAT, implemented as a lisp array.

# LA-SIMPLE-VECTOR-COMPLEX-DOUBLE

Dense vector holding elements of type (COMPLEX DOUBLE-FLOAT), implemented as a lisp array.

# LA-SIMPLE-VECTOR-COMPLEX-SINGLE

Dense vector holding elements of type (COMPLEX SINGLE-FLOAT), implemented as a lisp array.

# LA-SIMPLE-VECTOR-DOUBLE

Dense vector holding elements of type DOUBLE-FLOAT, implemented as a lisp array.

# LA-SIMPLE-VECTOR-INTEGER

Dense vector holding elements of type INTEGER, implemented as a lisp array.

# LA-SIMPLE-VECTOR-SINGLE

Dense vector holding elements of type SINGLE-FLOAT, implemented as a lisp array.

# LA-SLICE-VECVIEW-COMPLEX-DOUBLE

Slice view of a LA-SIMPLE-VECTOR-COMPLEX-DOUBLE vector.

# LA-SLICE-VECVIEW-COMPLEX-SINGLE

Slice view of a LA-SIMPLE-VECTOR-COMPLEX-SINGLE vector.

# LA-SLICE-VECVIEW-DOUBLE

Slice view of a LA-SIMPLE-VECTOR-DOUBLE vector.

# LA-SLICE-VECVIEW-INTEGER

Slice view of a LA-SIMPLE-VECTOR-INTEGER vector.

# LA-SLICE-VECVIEW-SINGLE

Slice view of a LA-SIMPLE-VECTOR-SINGLE vector.

# MATRIX-LIKE

Abstract base class for 2-D matrices and matrix
views. We assume for now that matrices are stored in column
order (Fortran style), for BLAS and LAPACK compatibility.
There is NO DATA in the base class! (storage only comes with
derived classes). Matrix-like data only has nrows/ncols as
essential data -- derived classes will have additional slots.

# STRIDED-MATVIEW

A STRIDED-MATVIEW views a window of the matrix with
a particular stride in each direction (the stride can be different
in each direction).

# VECTOR-LIKE

Abstract base class for 1-D vectors and vector
views.

# WINDOW-MATVIEW

A WINDOW-MATVIEW views a block of elements in the
underlying matrix that is conceptually 2-D contiguous. If the
underlying matrix is column-oriented, the elements in each column of
a WINDOW-MATVIEW are stored contiguously, and horizontally adjacent
elements are separated by a constant stride ("LDA" in BLAS
terms). (vice-verse for row-oriented).
Tony adds: the basic idea is to offset row and column; we don't make
the size any smaller, i.e. by adding max row/column, or #
rows/cols.

# Undocumented

# DOUBLE-FLOAT

# FLOAT (NUMBER &OPTIONAL (OTHER NIL OTHERP))

# SINGLE-FLOAT

# Private

# FA-MATRIX-COMPLEX-DOUBLE

Base class for dense matrices holding elements of type (COMPLEX DOUBLE-FLOAT) for the implementation FOREIGN-ARRAY.

# FA-MATRIX-COMPLEX-SINGLE

Base class for dense matrices holding elements of type (COMPLEX SINGLE-FLOAT) for the implementation FOREIGN-ARRAY.

# FA-MATRIX-DOUBLE

Base class for dense matrices holding elements of type DOUBLE-FLOAT for the implementation FOREIGN-ARRAY.

# FA-MATRIX-SINGLE

Base class for dense matrices holding elements of type SINGLE-FLOAT for the implementation FOREIGN-ARRAY.

# FA-SIMPLE-MATRIX-COMPLEX-DOUBLE

Dense matrix holding elements of type (COMPLEX DOUBLE-FLOAT), implemented as a foreign array.

# FA-SIMPLE-MATRIX-COMPLEX-SINGLE

Dense matrix holding elements of type (COMPLEX SINGLE-FLOAT), implemented as a foreign array.

# FA-SIMPLE-MATRIX-SINGLE

Dense matrix holding elements of type SINGLE-FLOAT, implemented as a foreign array.

# FA-SIMPLE-VECTOR-COMPLEX-DOUBLE

Dense vector holding elements of type (COMPLEX DOUBLE-FLOAT), implemented as a foreign array.

# FA-SIMPLE-VECTOR-COMPLEX-SINGLE

Dense vector holding elements of type (COMPLEX SINGLE-FLOAT), implemented as a foreign array.

# FA-SIMPLE-VECTOR-SINGLE

Dense vector holding elements of type SINGLE-FLOAT, implemented as a foreign array.

# FA-SLICE-VECVIEW-COMPLEX-DOUBLE

Slice view of a FA-SIMPLE-VECTOR-COMPLEX-DOUBLE vector.

# FA-SLICE-VECVIEW-COMPLEX-SINGLE

Slice view of a FA-SIMPLE-VECTOR-COMPLEX-SINGLE vector.

# FA-SLICE-VECVIEW-DOUBLE

Slice view of a FA-SIMPLE-VECTOR-DOUBLE vector.

# FA-SLICE-VECVIEW-SINGLE

Slice view of a FA-SIMPLE-VECTOR-SINGLE vector.

# FA-STRIDED-MATVIEW-COMPLEX-DOUBLE

Strided view of a FA-SIMPLE-MATRIX-COMPLEX-DOUBLE matrix.

# FA-STRIDED-MATVIEW-COMPLEX-SINGLE

Strided view of a FA-SIMPLE-MATRIX-COMPLEX-SINGLE matrix.

# FA-STRIDED-MATVIEW-DOUBLE

Strided view of a FA-SIMPLE-MATRIX-DOUBLE matrix.

# FA-STRIDED-MATVIEW-SINGLE

Strided view of a FA-SIMPLE-MATRIX-SINGLE matrix.

# FA-TRANSPOSE-MATVIEW-COMPLEX-DOUBLE

Transposed view of a FA-SIMPLE-MATRIX-COMPLEX-DOUBLE matrix.

# FA-TRANSPOSE-MATVIEW-COMPLEX-SINGLE

Transposed view of a FA-SIMPLE-MATRIX-COMPLEX-SINGLE matrix.

# FA-TRANSPOSE-MATVIEW-DOUBLE

Transposed view of a FA-SIMPLE-MATRIX-DOUBLE matrix.

# FA-TRANSPOSE-MATVIEW-SINGLE

Transposed view of a FA-SIMPLE-MATRIX-SINGLE matrix.

# FA-TRANSPOSE-VECVIEW-COMPLEX-DOUBLE

Transposed view of a FA-SIMPLE-VECTOR-COMPLEX-DOUBLE vector.

# FA-TRANSPOSE-VECVIEW-COMPLEX-SINGLE

Transposed view of a FA-SIMPLE-VECTOR-COMPLEX-SINGLE vector.

# FA-TRANSPOSE-VECVIEW-DOUBLE

Transposed view of a FA-SIMPLE-VECTOR-DOUBLE vector.

# FA-TRANSPOSE-VECVIEW-SINGLE

Transposed view of a FA-SIMPLE-VECTOR-SINGLE vector.

# FA-VECTOR-COMPLEX-DOUBLE

Base class for dense vectors holding elements of type (COMPLEX DOUBLE-FLOAT) for the implementation FOREIGN-ARRAY.

# FA-VECTOR-COMPLEX-SINGLE

Base class for dense vectors holding elements of type (COMPLEX SINGLE-FLOAT) for the implementation FOREIGN-ARRAY.

# FA-VECTOR-DOUBLE

Base class for dense vectors holding elements of type DOUBLE-FLOAT for the implementation FOREIGN-ARRAY.

# FA-VECTOR-SINGLE

Base class for dense vectors holding elements of type SINGLE-FLOAT for the implementation FOREIGN-ARRAY.

# FA-WINDOW-MATVIEW-COMPLEX-DOUBLE

Windowed view of a FA-SIMPLE-MATRIX-COMPLEX-DOUBLE matrix.

# FA-WINDOW-MATVIEW-COMPLEX-SINGLE

Windowed view of a FA-SIMPLE-MATRIX-COMPLEX-SINGLE matrix.

# FA-WINDOW-MATVIEW-DOUBLE

Windowed view of a FA-SIMPLE-MATRIX-DOUBLE matrix.

# FA-WINDOW-MATVIEW-SINGLE

Windowed view of a FA-SIMPLE-MATRIX-SINGLE matrix.

# LA-MATRIX-COMPLEX-DOUBLE

Base class for dense matrices holding elements of type (COMPLEX DOUBLE-FLOAT) for the implementation LISP-ARRAY.

# LA-MATRIX-COMPLEX-SINGLE

Base class for dense matrices holding elements of type (COMPLEX SINGLE-FLOAT) for the implementation LISP-ARRAY.

# LA-MATRIX-DOUBLE

Base class for dense matrices holding elements of type DOUBLE-FLOAT for the implementation LISP-ARRAY.

# LA-MATRIX-FIXNUM

Base class for dense matrices holding elements of type FIXNUM for the implementation LISP-ARRAY.

# LA-MATRIX-INTEGER

Base class for dense matrices holding elements of type INTEGER for the implementation LISP-ARRAY.

# LA-MATRIX-SINGLE

Base class for dense matrices holding elements of type SINGLE-FLOAT for the implementation LISP-ARRAY.

# LA-MATRIX-T

Base class for dense matrices holding elements of type T for the implementation LISP-ARRAY.

# LA-SIMPLE-MATRIX-T

Dense matrix holding elements of type T, implemented as a lisp array.

# LA-SIMPLE-VECTOR-FIXNUM

Dense vector holding elements of type FIXNUM, implemented as a lisp array.

# LA-SIMPLE-VECTOR-T

Dense vector holding elements of type T, implemented as a lisp array.

# LA-SLICE-VECVIEW-FIXNUM

Slice view of a LA-SIMPLE-VECTOR-FIXNUM vector.

# LA-SLICE-VECVIEW-T

Slice view of a LA-SIMPLE-VECTOR-T vector.

# LA-STRIDED-MATVIEW-COMPLEX-DOUBLE

Strided view of a LA-SIMPLE-MATRIX-COMPLEX-DOUBLE matrix.

# LA-STRIDED-MATVIEW-COMPLEX-SINGLE

Strided view of a LA-SIMPLE-MATRIX-COMPLEX-SINGLE matrix.

# LA-STRIDED-MATVIEW-DOUBLE

Strided view of a LA-SIMPLE-MATRIX-DOUBLE matrix.

# LA-STRIDED-MATVIEW-FIXNUM

Strided view of a LA-SIMPLE-MATRIX-FIXNUM matrix.

# LA-STRIDED-MATVIEW-INTEGER

Strided view of a LA-SIMPLE-MATRIX-INTEGER matrix.

# LA-STRIDED-MATVIEW-SINGLE

Strided view of a LA-SIMPLE-MATRIX-SINGLE matrix.

# LA-STRIDED-MATVIEW-T

Strided view of a LA-SIMPLE-MATRIX-T matrix.

# LA-TRANSPOSE-MATVIEW-COMPLEX-DOUBLE

Transposed view of a LA-SIMPLE-MATRIX-COMPLEX-DOUBLE matrix.

# LA-TRANSPOSE-MATVIEW-COMPLEX-SINGLE

Transposed view of a LA-SIMPLE-MATRIX-COMPLEX-SINGLE matrix.

# LA-TRANSPOSE-MATVIEW-DOUBLE

Transposed view of a LA-SIMPLE-MATRIX-DOUBLE matrix.

# LA-TRANSPOSE-MATVIEW-FIXNUM

Transposed view of a LA-SIMPLE-MATRIX-FIXNUM matrix.

# LA-TRANSPOSE-MATVIEW-INTEGER

Transposed view of a LA-SIMPLE-MATRIX-INTEGER matrix.

# LA-TRANSPOSE-MATVIEW-SINGLE

Transposed view of a LA-SIMPLE-MATRIX-SINGLE matrix.

# LA-TRANSPOSE-MATVIEW-T

Transposed view of a LA-SIMPLE-MATRIX-T matrix.

# LA-TRANSPOSE-VECVIEW-COMPLEX-DOUBLE

Transposed view of a LA-SIMPLE-VECTOR-COMPLEX-DOUBLE vector.

# LA-TRANSPOSE-VECVIEW-COMPLEX-SINGLE

Transposed view of a LA-SIMPLE-VECTOR-COMPLEX-SINGLE vector.

# LA-TRANSPOSE-VECVIEW-DOUBLE

Transposed view of a LA-SIMPLE-VECTOR-DOUBLE vector.

# LA-TRANSPOSE-VECVIEW-FIXNUM

Transposed view of a LA-SIMPLE-VECTOR-FIXNUM vector.

# LA-TRANSPOSE-VECVIEW-INTEGER

Transposed view of a LA-SIMPLE-VECTOR-INTEGER vector.

# LA-TRANSPOSE-VECVIEW-SINGLE

Transposed view of a LA-SIMPLE-VECTOR-SINGLE vector.

# LA-TRANSPOSE-VECVIEW-T

Transposed view of a LA-SIMPLE-VECTOR-T vector.

# LA-VECTOR-COMPLEX-DOUBLE

Base class for dense vectors holding elements of type (COMPLEX DOUBLE-FLOAT) for the implementation LISP-ARRAY.

# LA-VECTOR-COMPLEX-SINGLE

Base class for dense vectors holding elements of type (COMPLEX SINGLE-FLOAT) for the implementation LISP-ARRAY.

# LA-VECTOR-DOUBLE

Base class for dense vectors holding elements of type DOUBLE-FLOAT for the implementation LISP-ARRAY.

# LA-VECTOR-FIXNUM

Base class for dense vectors holding elements of type FIXNUM for the implementation LISP-ARRAY.

# LA-VECTOR-INTEGER

Base class for dense vectors holding elements of type INTEGER for the implementation LISP-ARRAY.

# LA-VECTOR-SINGLE

Base class for dense vectors holding elements of type SINGLE-FLOAT for the implementation LISP-ARRAY.

# LA-VECTOR-T

Base class for dense vectors holding elements of type T for the implementation LISP-ARRAY.

# LA-WINDOW-MATVIEW-COMPLEX-DOUBLE

Windowed view of a LA-SIMPLE-MATRIX-COMPLEX-DOUBLE matrix.

# LA-WINDOW-MATVIEW-COMPLEX-SINGLE

Windowed view of a LA-SIMPLE-MATRIX-COMPLEX-SINGLE matrix.

# LA-WINDOW-MATVIEW-DOUBLE

Windowed view of a LA-SIMPLE-MATRIX-DOUBLE matrix.

# LA-WINDOW-MATVIEW-FIXNUM

Windowed view of a LA-SIMPLE-MATRIX-FIXNUM matrix.

# LA-WINDOW-MATVIEW-INTEGER

Windowed view of a LA-SIMPLE-MATRIX-INTEGER matrix.

# LA-WINDOW-MATVIEW-SINGLE

Windowed view of a LA-SIMPLE-MATRIX-SINGLE matrix.

# LA-WINDOW-MATVIEW-T

Windowed view of a LA-SIMPLE-MATRIX-T matrix.

# MATRIX-COMPLEX-DOUBLE

Base class for matrices holding elements of type (COMPLEX DOUBLE-FLOAT).

# MATRIX-COMPLEX-SINGLE

Base class for matrices holding elements of type (COMPLEX SINGLE-FLOAT).

# MATRIX-DOUBLE

Base class for matrices holding elements of type DOUBLE-FLOAT.

# MATRIX-FIXNUM

Base class for matrices holding elements of type FIXNUM.

# MATRIX-INTEGER

Base class for matrices holding elements of type INTEGER.

# MATRIX-SINGLE

Base class for matrices holding elements of type SINGLE-FLOAT.

# MATRIX-T

Base class for matrices holding elements of type T.

# MATVIEW

An abstract class representing a "view" into a
matrix. That view may be treated as a (readable and writeable)
reference to the elements of the matrix.

# TRANSPOSE-MATVIEW

A TRANSPOSE-MATVIEW views the transpose of a
matrix. If you want a deep copy, call the appropriate COPY function
on the transpose view. The reason for this is to avoid expensive
operations whenever possible. Many BLAS and LAPACK routines have a
"TRANSA" argument (or similar) that lets you specify that the
operation should work with the transpose of the matrix. This means
that it usually isn't necessary to compute an explicit transpose, at
least for input arguments.

# VECTOR-COMPLEX-DOUBLE

Base class for vectors holding elements of type (COMPLEX DOUBLE-FLOAT).

# VECTOR-COMPLEX-SINGLE

Base class for vectors holding elements of type (COMPLEX SINGLE-FLOAT).

# VECTOR-DOUBLE

Base class for vectors holding elements of type DOUBLE-FLOAT.

# VECTOR-FIXNUM

Base class for vectors holding elements of type FIXNUM.

# VECTOR-INTEGER

Base class for vectors holding elements of type INTEGER.

# VECTOR-SINGLE

Base class for vectors holding elements of type SINGLE-FLOAT.

# VECTOR-T

Base class for vectors holding elements of type T.

# VECVIEW

An abstract class representing a "view" into a
vector. That view may be treated as a (readable and writeable)
reference to the elements of the vector.