Common Lisp Package: LISP-MATRIX

README:

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)

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

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)

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

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)

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.

Undocumented

DIAGONAL-VECVIEW

FA-MATRIX

FA-VECTOR

FACTORIZED-MATRIX-RESULTS

LA-MATRIX

LA-VECTOR

SLICE-VECVIEW

TRANSPOSE-VECVIEW

TYPE-INFO