linalgebra

package linalgebra

The linalgebra package contains classes, traits and objects for linear algebra, including vectors and matrices for real and complex numbers.

Linear Supertypes

AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

linalgebra
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Type Members

class BidMatrixC extends MatriC with Error with Serializable
The BidMatrixC class stores and operates on square (upper) bidiagonal matrices.
The BidMatrixC class stores and operates on square (upper) bidiagonal matrices. The elements are of type of Complex. A matrix is stored as two vectors: the diagonal vector and the sup-diagonal vector.
class BidMatrixD extends MatriD with Error with Serializable
The BidMatrixD class stores and operates on square (upper) bidiagonal matrices.
The BidMatrixD class stores and operates on square (upper) bidiagonal matrices. The elements are of type of Double. A matrix is stored as two vectors: the diagonal vector and the sup-diagonal vector.
class BidMatrixI extends MatriI with Error with Serializable
The BidMatrixI class stores and operates on square (upper) bidiagonal matrices.
The BidMatrixI class stores and operates on square (upper) bidiagonal matrices. The elements are of type of Int. A matrix is stored as two vectors: the diagonal vector and the sup-diagonal vector.
class BidMatrixL extends MatriL with Error with Serializable
The BidMatrixL class stores and operates on square (upper) bidiagonal matrices.
The BidMatrixL class stores and operates on square (upper) bidiagonal matrices. The elements are of type of Long. A matrix is stored as two vectors: the diagonal vector and the sup-diagonal vector.
class BidMatrixQ extends MatriQ with Error with Serializable
The BidMatrixQ class stores and operates on square (upper) bidiagonal matrices.
The BidMatrixQ class stores and operates on square (upper) bidiagonal matrices. The elements are of type of Rational. A matrix is stored as two vectors: the diagonal vector and the sup-diagonal vector.
class BidMatrixR extends MatriR with Error with Serializable
The BidMatrixR class stores and operates on square (upper) bidiagonal matrices.
The BidMatrixR class stores and operates on square (upper) bidiagonal matrices. The elements are of type of Real. A matrix is stored as two vectors: the diagonal vector and the sup-diagonal vector.
class Bidiagonal[MatT <: MatriD] extends Error
The Bidiagonal class is used to create a bidiagonal matrix from matrix 'a'.
The Bidiagonal class is used to create a bidiagonal matrix from matrix 'a'. It uses the Householder Bidiagonalization Algorithm to compute orthogonal matrices 'u' and 'v' such that
u.t * a * v = b a = u * b * v.t
where matrix 'b' is bidiagonal, i.e., it will only have non-zero elements on its main diagonal and its super-diagonal (the diagonal above the main).
u is an m-by-n matrix b is an n-by-n matrix (bidiagonal - FIX: use BidMatrixD) v is an n-by-n matrix
class Bidiagonal2 extends Error
The Bidiagonal2 class is used to creates a bidiagonal matrix for matrix 'a'.
The Bidiagonal2 class is used to creates a bidiagonal matrix for matrix 'a'. It uses the Householder Bidiagonalization Algorithm to compute orthogonal matrices 'u' and 'v' such that
u.t * a * v = b a = u * b * v.t
where matrix 'b' is bidiagonal, i.e, it will only have non-zero elements on its main diagonal and its super-diagonal (the diagonal above the main).
u is an m-by-n matrix b is an n-by-n matrix (bidiagonal - FIX: use BidMatrixD) v is an n-by-n matrix
trait Eigen extends AnyRef
The Eigen trait defines constants used by classes and objects in the group.
class Eigenvalue extends Eigen with Error
The Eigenvalue class is used to find the eigenvalues of an 'n' by 'n' matrix 'a' using an iterative technique that applies similarity transformations to convert 'a' into an upper triangular matrix, so that the eigenvalues appear along the diagonal.
The Eigenvalue class is used to find the eigenvalues of an 'n' by 'n' matrix 'a' using an iterative technique that applies similarity transformations to convert 'a' into an upper triangular matrix, so that the eigenvalues appear along the diagonal. To improve performance, the 'a' matrix is first reduced to Hessenburg form. During the iterative steps, a shifted 'QR' decomposition is performed. Caveats: (1) it will not handle eigenvalues that are complex numbers, (2) it uses a simple shifting strategy that may slow convergence.
class EigenvalueSym extends Eigen with Error
The EigenvalueSym class is used to find the eigenvalues of an 'n' by 'n' symmetric matrix 'a' using an iterative technique, the Symmetric 'QR' Algorithm.
The EigenvalueSym class is used to find the eigenvalues of an 'n' by 'n' symmetric matrix 'a' using an iterative technique, the Symmetric 'QR' Algorithm.

See also
Algorithm 8.3.3 in Matrix Computations. Caveats: (1) it will not handle eigenvalues that are complex numbers, (2) it uses a simple shifting strategy that may slow convergence.
class Eigenvector extends Eigen with Error
The Eigenvector class is used to find the eigenvectors of an 'n' by 'n' matrix 'a' by solving equations of the form
The Eigenvector class is used to find the eigenvectors of an 'n' by 'n' matrix 'a' by solving equations of the form
(a - eI)v = 0
where 'e' is the eigenvalue and 'v' is the eigenvector. Place the eigenvectors in a matrix column-wise.
class Fac_Cholesky[MatT <: MatriD] extends Factorization with Error
The Fac_Cholesky class provides methods to factor an 'n-by-n' symmetric, positive definite matrix 'a' into the product of two matrices:
The Fac_Cholesky class provides methods to factor an 'n-by-n' symmetric, positive definite matrix 'a' into the product of two matrices:
'l' - an 'n-by-n' left lower triangular matrix 'l.t' - an 'n-by-n' right upper triangular matrix - transpose of 'l'
such that 'a = l * l.t'.
class Fac_Inv[MatT <: MatriD] extends Factorization with Error
The Fac_Inv class provides methods to factor an 'n-by-n' identity matrix 'I' into the product of two matrices 'a' and 'a^-1'
The Fac_Inv class provides methods to factor an 'n-by-n' identity matrix 'I' into the product of two matrices 'a' and 'a^-1'
a * a^-1 = I
where 'a' is the given matrix and 'a^-1' is its inverse.
class Fac_LQ extends Factorization with Error
The Fac_LQ class provides methods to factor an 'm-by-n' matrix 'aa' into the product of two matrices, when m < n.
The Fac_LQ class provides methods to factor an 'm-by-n' matrix 'aa' into the product of two matrices, when m < n.
'l' - an 'm-by-m' left lower triangular matrix 'q' - an 'm-by-n' orthogonal matrix and
such that 'aa = l * q'. Note, orthogonal means that 'q.t * q = I'.
class Fac_LU[MatT <: MatriD] extends Factorization with Error
The Fac_LU class provides methods to factor an 'm-by-n' matrix into its lower and upper triangular products:
The Fac_LU class provides methods to factor an 'm-by-n' matrix into its lower and upper triangular products:
A = LU when partial pivoting is not needed PA = LU where P is the permutation matrix A = QLU where Q = P.inverse
where 'a' is the given matrix, 'l' is an 'm-by-n' lower triangular matrix, and 'u' is an 'n-by-n' upper triangular matrix. The permutation matrix is represented by the 'piv' vector. Once factored, can be used to solve a system of linear equations.
Solve for x in Ax = b: Ax = QLUx = b => LUx = Pb using steps (1) and (2) (1) Solve Ly = Pb using forward substitution for y (2) Solve Ux = y using backward substitution for x
abstract class Fac_QR[MatT <: MatriD] extends Factorization with Error
The Fac_QR abstarct class provides base methods to factor an 'm-by-n' matrix 'aa' into the product of two matrices:
The Fac_QR abstarct class provides base methods to factor an 'm-by-n' matrix 'aa' into the product of two matrices:
'q' - an 'm-by-n' orthogonal matrix and 'r' - an 'n-by-n' right upper triangular matrix
such that 'aa = q * r'. ------------------------------------------------------------------------------
class Fac_QR_H[MatT <: MatriD] extends Fac_QR[MatT]
The Fac_QR_H class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:
The Fac_QR_H class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:
'q' - an 'm-by-n' orthogonal matrix and 'r' - an 'n-by-n' right upper triangular matrix
such that 'a = q * r'. It uses uses Householder orthogonalization.

See also
www.stat.wisc.edu/~larget/math496/qr.html ------------------------------------------------------------------------------- This implementation improves upon Fac_QR_H2 by working with the transpose the original matrix and reorders operations to facilitate parallelism (see par directory). Caveat: for m < n use Fac_LQ. -------------------------------------------------------------------------------
QRDecomposition.java in Jama
5.1 and 5.2 in Matrix Computations
class Fac_QR_H2[MatT <: MatriD] extends Fac_QR[MatT]
The Fac_QR_H2 class provides methods to factor an 'm-by-n' matrix 'aa' into the product of two matrices:
The Fac_QR_H2 class provides methods to factor an 'm-by-n' matrix 'aa' into the product of two matrices:
'q' - an 'm-by-n' orthogonal matrix and 'r' - an 'n-by-n' right upper triangular matrix
such that 'a = q * r'. It uses Householder orthogonalization.

See also
math.stackexchange.com/questions/678843/householder-qr-factorization-for-m-by-n-matrix-both-m-n-and-mn ------------------------------------------------------------------------------ This implementation replaces matrix operations in Fac_QR_H3 with low-level operations for greater efficiency. Also, calculates Householder vectors differently. Caveat: for m < n use Fac_LQ. ------------------------------------------------------------------------------
www.stat.wisc.edu/~larget/math496/qr.html
QRDecomposition.java in Jama
5.1 and 5.2 in Matrix Computations
class Fac_QR_H3 extends Fac_QR[MatrixD]
The Fac_QR_H3 class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:
The Fac_QR_H3 class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:
'q' - an 'm-by-n' orthogonal matrix and 'r' - an 'n-by-n' right upper triangular matrix
such that 'a = q * r'. It uses Householder orthogonalization. Note, orthogonal means that 'q.t * q = I'.

See also
www.stat.wisc.edu/~larget/math496/qr.html ------------------------------------------------------------------------------ This implementation is the easiest to understandard, but the least efficient. Caveat: for m < n use Fac_LQ. FIX: change 'aa: MatrixD' to 'aa: MatriD', requires 'times_ip_pre' in trait ------------------------------------------------------------------------------
QRDecomposition.java in Jama
5.1 and 5.2 in Matrix Computations
class Fac_QR_MGS extends Fac_QR[MatrixD]
The Fac_QR_MGS class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:
The Fac_QR_MGS class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:
'q' - an 'm-by-n' orthogonal matrix and 'r' - an 'n-by-n' right upper triangular matrix
such that 'a = q * r'. It uses Modified Gram-Schmidt (MGS) orthogonalization. Note, orthogonal means that 'q.t * q = I'.

See also
http://en.wikipedia.org/wiki/Gram–Schmidt_process (stabilized Gram–Schmidt orthonormalization)
http://www.stat.wisc.edu/~larget/math496/qr.html
class Fac_QR_RR[MatT <: MatriD] extends Fac_QR_H[MatT] with Pivoting
The Fac_QR_RR class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:
The Fac_QR_RR class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:
'q' - an 'm-by-n' orthogonal matrix and 'r' - an 'n-by-n' right upper triangular matrix
such that 'a = q * r'. It uses uses Householder orthogonalization.

See also
www.stat.wisc.edu/~larget/math496/qr.html ------------------------------------------------------------------------------- This implementation extends Fac_QR_H and adds column pivoting for greater robustness and resonably accurate rank determination (Rank Revealing QR). Caveat: for m < n use Fac_LQ. -------------------------------------------------------------------------------
QRDecomposition.java in Jama
5.1 and 5.2 in Matrix Computations
trait Factorization extends AnyRef
The Factorization trait is the template for classes implementing various forms of matrix factorization.
type FunctionM2M = (MatrixD) ⇒ MatrixD
type FunctionM_2M = (MatriD) ⇒ MatriD
type FunctionV2S = (VectorD) ⇒ Double
The type definitions for functions involving base types from linalgebra (f: T => T), where T is a vector or matrix.
The type definitions for functions involving base types from linalgebra (f: T => T), where T is a vector or matrix.

See also
also scalation.math
type FunctionV2V = (VectorD) ⇒ VectorD
type FunctionV_2S = (VectoD) ⇒ Double
type FunctionV_2V = (VectoD) ⇒ VectoD
class Hessenburg extends Eigen with Error
The Hessenburg class is used to reduce, via similarity transformations, an 'n' by 'n' matrix 'a' to Hessenburg form 'h', where all elements two below the main diagonal are zero (or close to zero).
The Hessenburg class is used to reduce, via similarity transformations, an 'n' by 'n' matrix 'a' to Hessenburg form 'h', where all elements two below the main diagonal are zero (or close to zero). Note, similarity transformations do not changes the eigenvalues.
class HouseholderT extends Eigen with Error
The HouseholderT class performs a Householder Tridiagonalization on a symmetric matrix.
The HouseholderT class performs a Householder Tridiagonalization on a symmetric matrix.

See also
Algorithm 8.3.1 in Matrix Computations.
trait MatriC extends Error
The MatriC trait specifies the operations to be defined by the concrete classes implementing Complex matrices, i.e., MatrixC - dense matrix BidMatrixC - bidiagonal matrix - useful for computing Singular Values RleMatrixC - compressed matrix - Run Length Encoding (RLE) SparseMatrixC - sparse matrix - majority of elements should be zero SymTriMatrixC - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixC - parallel dense matrix par.SparseMatrixC - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'.
The MatriC trait specifies the operations to be defined by the concrete classes implementing Complex matrices, i.e., MatrixC - dense matrix BidMatrixC - bidiagonal matrix - useful for computing Singular Values RleMatrixC - compressed matrix - Run Length Encoding (RLE) SparseMatrixC - sparse matrix - majority of elements should be zero SymTriMatrixC - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixC - parallel dense matrix par.SparseMatrixC - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'. ------------------------------------------------------------------------------ row-wise column-wise Prepend: vector +: matrix vector +^{: matrix (right associative)
Append: matrix :+ vector matrix :}+ vector Concatenate: matrix ++ matrix matrix ++^ matrix
trait MatriD extends Error
The MatriD trait specifies the operations to be defined by the concrete classes implementing Double matrices, i.e., MatrixD - dense matrix BidMatrixD - bidiagonal matrix - useful for computing Singular Values RleMatrixD - compressed matrix - Run Length Encoding (RLE) SparseMatrixD - sparse matrix - majority of elements should be zero SymTriMatrixD - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixD - parallel dense matrix par.SparseMatrixD - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'.
The MatriD trait specifies the operations to be defined by the concrete classes implementing Double matrices, i.e., MatrixD - dense matrix BidMatrixD - bidiagonal matrix - useful for computing Singular Values RleMatrixD - compressed matrix - Run Length Encoding (RLE) SparseMatrixD - sparse matrix - majority of elements should be zero SymTriMatrixD - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixD - parallel dense matrix par.SparseMatrixD - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'. ------------------------------------------------------------------------------ row-wise column-wise Prepend: vector +: matrix vector +^{: matrix (right associative)
Append: matrix :+ vector matrix :}+ vector Concatenate: matrix ++ matrix matrix ++^ matrix
trait MatriI extends Error
The MatriI trait specifies the operations to be defined by the concrete classes implementing Int matrices, i.e., MatrixI - dense matrix BidMatrixI - bidiagonal matrix - useful for computing Singular Values RleMatrixI - compressed matrix - Run Length Encoding (RLE) SparseMatrixI - sparse matrix - majority of elements should be zero SymTriMatrixI - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixI - parallel dense matrix par.SparseMatrixI - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'.
The MatriI trait specifies the operations to be defined by the concrete classes implementing Int matrices, i.e., MatrixI - dense matrix BidMatrixI - bidiagonal matrix - useful for computing Singular Values RleMatrixI - compressed matrix - Run Length Encoding (RLE) SparseMatrixI - sparse matrix - majority of elements should be zero SymTriMatrixI - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixI - parallel dense matrix par.SparseMatrixI - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'. ------------------------------------------------------------------------------ row-wise column-wise Prepend: vector +: matrix vector +^{: matrix (right associative)
Append: matrix :+ vector matrix :}+ vector Concatenate: matrix ++ matrix matrix ++^ matrix
trait MatriL extends Error
The MatriL trait specifies the operations to be defined by the concrete classes implementing Long matrices, i.e., MatrixL - dense matrix BidMatrixL - bidiagonal matrix - useful for computing Singular Values RleMatrixL - compressed matrix - Run Length Encoding (RLE) SparseMatrixL - sparse matrix - majority of elements should be zero SymTriMatrixL - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixL - parallel dense matrix par.SparseMatrixL - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'.
The MatriL trait specifies the operations to be defined by the concrete classes implementing Long matrices, i.e., MatrixL - dense matrix BidMatrixL - bidiagonal matrix - useful for computing Singular Values RleMatrixL - compressed matrix - Run Length Encoding (RLE) SparseMatrixL - sparse matrix - majority of elements should be zero SymTriMatrixL - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixL - parallel dense matrix par.SparseMatrixL - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'. ------------------------------------------------------------------------------ row-wise column-wise Prepend: vector +: matrix vector +^{: matrix (right associative)
Append: matrix :+ vector matrix :}+ vector Concatenate: matrix ++ matrix matrix ++^ matrix
trait MatriQ extends Error
The MatriQ trait specifies the operations to be defined by the concrete classes implementing Rational matrices, i.e., MatrixQ - dense matrix BidMatrixQ - bidiagonal matrix - useful for computing Singular Values RleMatrixQ - compressed matrix - Run Length Encoding (RLE) SparseMatrixQ - sparse matrix - majority of elements should be zero SymTriMatrixQ - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixQ - parallel dense matrix par.SparseMatrixQ - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'.
The MatriQ trait specifies the operations to be defined by the concrete classes implementing Rational matrices, i.e., MatrixQ - dense matrix BidMatrixQ - bidiagonal matrix - useful for computing Singular Values RleMatrixQ - compressed matrix - Run Length Encoding (RLE) SparseMatrixQ - sparse matrix - majority of elements should be zero SymTriMatrixQ - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixQ - parallel dense matrix par.SparseMatrixQ - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'. ------------------------------------------------------------------------------ row-wise column-wise Prepend: vector +: matrix vector +^{: matrix (right associative)
Append: matrix :+ vector matrix :}+ vector Concatenate: matrix ++ matrix matrix ++^ matrix
trait MatriR extends Error
The MatriR trait specifies the operations to be defined by the concrete classes implementing Real matrices, i.e., MatrixR - dense matrix BidMatrixR - bidiagonal matrix - useful for computing Singular Values RleMatrixR - compressed matrix - Run Length Encoding (RLE) SparseMatrixR - sparse matrix - majority of elements should be zero SymTriMatrixR - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixR - parallel dense matrix par.SparseMatrixR - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'.
The MatriR trait specifies the operations to be defined by the concrete classes implementing Real matrices, i.e., MatrixR - dense matrix BidMatrixR - bidiagonal matrix - useful for computing Singular Values RleMatrixR - compressed matrix - Run Length Encoding (RLE) SparseMatrixR - sparse matrix - majority of elements should be zero SymTriMatrixR - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixR - parallel dense matrix par.SparseMatrixR - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'. ------------------------------------------------------------------------------ row-wise column-wise Prepend: vector +: matrix vector +^{: matrix (right associative)
Append: matrix :+ vector matrix :}+ vector Concatenate: matrix ++ matrix matrix ++^ matrix
trait MatriS extends Error
The MatriS trait specifies the operations to be defined by the concrete classes implementing StrNum matrices, i.e., MatrixS - dense matrix BidMatrixS - bidiagonal matrix - useful for computing Singular Values RleMatrixS - compressed matrix - Run Length Encoding (RLE) SparseMatrixS - sparse matrix - majority of elements should be zero SymTriMatrixS - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixS - parallel dense matrix par.SparseMatrixS - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'.
The MatriS trait specifies the operations to be defined by the concrete classes implementing StrNum matrices, i.e., MatrixS - dense matrix BidMatrixS - bidiagonal matrix - useful for computing Singular Values RleMatrixS - compressed matrix - Run Length Encoding (RLE) SparseMatrixS - sparse matrix - majority of elements should be zero SymTriMatrixS - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixS - parallel dense matrix par.SparseMatrixS - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'. ------------------------------------------------------------------------------ row-wise column-wise Prepend: vector +: matrix vector +^{: matrix (right associative)
Append: matrix :+ vector matrix :}+ vector Concatenate: matrix ++ matrix matrix ++^ matrix
trait MatriT extends Error
The MatriT trait specifies the operations to be defined by the concrete classes implementing TimeNum matrices, i.e., MatrixT - dense matrix BidMatrixT - bidiagonal matrix - useful for computing Singular Values RleMatrixT - compressed matrix - Run Length Encoding (RLE) SparseMatrixT - sparse matrix - majority of elements should be zero SymTriMatrixT - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixT - parallel dense matrix par.SparseMatrixT - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'.
The MatriT trait specifies the operations to be defined by the concrete classes implementing TimeNum matrices, i.e., MatrixT - dense matrix BidMatrixT - bidiagonal matrix - useful for computing Singular Values RleMatrixT - compressed matrix - Run Length Encoding (RLE) SparseMatrixT - sparse matrix - majority of elements should be zero SymTriMatrixT - symmetric triangular matrix - useful for computing Eigenvalues par.MatrixT - parallel dense matrix par.SparseMatrixT - parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'. ------------------------------------------------------------------------------ row-wise column-wise Prepend: vector +: matrix vector +^{: matrix (right associative)
Append: matrix :+ vector matrix :}+ vector Concatenate: matrix ++ matrix matrix ++^ matrix
class MatrixC extends MatriC with Error with Serializable
The MatrixC class stores and operates on Numeric Matrices of type Complex.
The MatrixC class stores and operates on Numeric Matrices of type Complex. This class follows the gen.MatrixN framework and is provided for efficiency. Caveat: Only works for rectangular matrices. For matrix-like structures based on jagged arrays, where the second dimension varies,

See also
scalation.linalgebra.gen.HMatrix2
class MatrixD extends MatriD with Error with Serializable
The MatrixD class stores and operates on Numeric Matrices of type Double.
The MatrixD class stores and operates on Numeric Matrices of type Double. This class follows the gen.MatrixN framework and is provided for efficiency. Caveat: Only works for rectangular matrices. For matrix-like structures based on jagged arrays, where the second dimension varies,

See also
scalation.linalgebra.gen.HMatrix2
class MatrixI extends MatriI with Error with Serializable
The MatrixI class stores and operates on Numeric Matrices of type Int.
The MatrixI class stores and operates on Numeric Matrices of type Int. This class follows the gen.MatrixN framework and is provided for efficiency. Caveat: Only works for rectangular matrices. For matrix-like structures based on jagged arrays, where the second dimension varies,

See also
scalation.linalgebra.gen.HMatrix2
class MatrixL extends MatriL with Error with Serializable
The MatrixL class stores and operates on Numeric Matrices of type Long.
The MatrixL class stores and operates on Numeric Matrices of type Long. This class follows the gen.MatrixN framework and is provided for efficiency. Caveat: Only works for rectangular matrices. For matrix-like structures based on jagged arrays, where the second dimension varies,

See also
scalation.linalgebra.gen.HMatrix2
class MatrixQ extends MatriQ with Error with Serializable
The MatrixQ class stores and operates on Numeric Matrices of type Rational.
The MatrixQ class stores and operates on Numeric Matrices of type Rational. This class follows the gen.MatrixN framework and is provided for efficiency. Caveat: Only works for rectangular matrices. For matrix-like structures based on jagged arrays, where the second dimension varies,

See also
scalation.linalgebra.gen.HMatrix2
class MatrixR extends MatriR with Error with Serializable
The MatrixR class stores and operates on Numeric Matrices of type Real.
The MatrixR class stores and operates on Numeric Matrices of type Real. This class follows the gen.MatrixN framework and is provided for efficiency. Caveat: Only works for rectangular matrices. For matrix-like structures based on jagged arrays, where the second dimension varies,

See also
scalation.linalgebra.gen.HMatrix2
trait Pivoting extends AnyRef
The Pivoting trait is used when row or column pivoting of a matrix is needed.
class RleMatrixC extends MatriC with Error with Serializable
The RleMatrixC class stores and operates on Numeric Matrices of type Complex.
The RleMatrixC class stores and operates on Numeric Matrices of type Complex. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of RleVectorC's.
class RleMatrixD extends MatriD with Error with Serializable
The RleMatrixD class stores and operates on Numeric Matrices of type Double.
The RleMatrixD class stores and operates on Numeric Matrices of type Double. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of RleVectorD's.
class RleMatrixI extends MatriI with Error with Serializable
The RleMatrixI class stores and operates on Numeric Matrices of type Int.
The RleMatrixI class stores and operates on Numeric Matrices of type Int. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of RleVectorI's.
class RleMatrixL extends MatriL with Error with Serializable
The RleMatrixL class stores and operates on Numeric Matrices of type Long.
The RleMatrixL class stores and operates on Numeric Matrices of type Long. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of RleVectorL's.
class RleMatrixQ extends MatriQ with Error with Serializable
The RleMatrixQ class stores and operates on Numeric Matrices of type Rational.
The RleMatrixQ class stores and operates on Numeric Matrices of type Rational. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of RleVectorQ's.
class RleMatrixR extends MatriR with Error with Serializable
The RleMatrixR class stores and operates on Numeric Matrices of type Real.
The RleMatrixR class stores and operates on Numeric Matrices of type Real. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of RleVectorR's.
class RleVectorC extends VectoC
The RleVectorC class stores and operates on compressed Numeric Vectors of base type Complex.
class RleVectorD extends VectoD
The RleVectorD class stores and operates on compressed Numeric Vectors of base type Double.
class RleVectorI extends VectoI
The RleVectorI class stores and operates on compressed Numeric Vectors of base type Int.
class RleVectorL extends VectoL
The RleVectorL class stores and operates on compressed Numeric Vectors of base type Long.
class RleVectorQ extends VectoQ
The RleVectorQ class stores and operates on compressed Numeric Vectors of base type Rational.
class RleVectorR extends VectoR
The RleVectorR class stores and operates on compressed Numeric Vectors of base type Real.
class RleVectorS extends VectoS
The RleVectorS class stores and operates on compressed Numeric Vectors of base type StrNum.
class RleVectorT extends VectoT
The RleVectorT class stores and operates on compressed Numeric Vectors of base type TimeNum.
case class Rotation(cs: Double, sn: Double, r: Double) extends Product with Serializable
The Rotation class is a data structure for holding the results of rotating by angle a.
The Rotation class is a data structure for holding the results of rotating by angle a.
cs
the cos (a)
sn
the sin (a)
r
the nonzero element of the rotated vector
class SVD[MatT <: MatriD] extends SVDecomp with Error
The SVD class is used to compute the Singular Value Decomposition 'SVD' of matrix 'a' using the Golub-Kahan-Reinsch Algorithm.
The SVD class is used to compute the Singular Value Decomposition 'SVD' of matrix 'a' using the Golub-Kahan-Reinsch Algorithm. Factor/decompose matrix 'a' into the product of three matrices:
a = u * q * v.t where u is an m-by-n matrix of orthogonal eigenvectors of 'a * a.t' (LEFT SINGULAR VECTORS) q is an n-by-n diagonal matrix of square roots of eigenvalues of 'a.t * a' & 'a * a.t' (SINGULAR VALUES) v is an n-by-n matrix of orthogonal eigenvectors of 'a.t * a' (RIGHT SINGULAR VECTORS)
The SVD algorithm implemented is based on plane rotations. It involves transforming the input matrix to its Bidiagonal form using the Householder transformation procedure. The Bidiagonal matrix is then used to obtain singular values using the QR algorithm. ------------------------------------------------------------------------------
class SVD2 extends SVDecomp
The SVD2 class performs Single Value Decomposition 'SVD' using the Eigen class.
The SVD2 class performs Single Value Decomposition 'SVD' using the Eigen class. For a direct, more robust algorithm that is less sensitive to round-off errors,

See also
the SVD class.
class SVD3 extends SVDecomp
The SVD3 class is used to solve Singular Value Decomposition for bidiagonal matrices.
The SVD3 class is used to solve Singular Value Decomposition for bidiagonal matrices.
It computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition 'SVD' of a real n-by-n (upper) bidiagonal matrix B using the implicit zero-shift 'QR' algorithm. The 'SVD' of B has the form
B = Q * S * P.t
where S is the diagonal matrix of singular values, Q is an orthogonal matrix of left singular vectors, and P is an orthogonal matrix of right singular vectors. If left singular vectors are requested, this subroutine actually returns U*Q instead of Q, and, if right singular vectors are requested, this subroutine returns P.t * VT instead of P.T, for given real input matrices U and VT. When U and VT are the orthogonal matrices that reduce a general matrix A to bidiagonal form: A = U*B*VT, as computed by DGEBRD, then
A = (U*Q) * S * (P.t*VT)
is the 'SVD' of the general matrix A. A positive tolerance 'TOL' gives relative accuracy; for absolute accuracy negate it.

See also
LAPACK SUBROUTINE DBDSQR (UPLO, N, NCVT, NRU, NCC, D, E, VT, LDVT, U, LDU, C, LDC, WORK, INFO)
fortranwiki.org/fortran/show/svd
Technical Report CPAM-554, Mathematics Department, University of California at Berkeley, July 1992
"Accurate singular values and differential qd algorithms," B. Parlett and V. Fernando,
J. Demmel and W. Kahan, LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. 11:5, pp. 873-912, Sept 1990)
"Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy,"
class SVD4 extends SVDecomp with Error
The SVD4 class is used to compute the Singular Value Decomposition 'SVD' of matrix 'aa' using the Golub-Kahan-Reinsch Algorithm.
The SVD4 class is used to compute the Singular Value Decomposition 'SVD' of matrix 'aa' using the Golub-Kahan-Reinsch Algorithm. Factor/decompose matrix 'aa' into the product of three matrices:
aa = uu * a * vv.t
where 'uu' is a matrix of orthogonal eigenvectors of 'aa * aa.t' (LEFT SINGULAR VECTORS) 'vv' is a matrix of orthogonal eigenvectors of 'aa.t * aa' (RIGHT SINGULAR VECTORS) and 'a' is a diagonal matrix of square roots of eigenvalues of 'aa.t * aa' & 'aa * aa.t' (SINGULAR VALUES). FIX: need to reorder so singular values are in decreasing order. FIX: make the singular values positive ------------------------------------------------------------------------------
class SVDImputed extends SVDecomp
The SVDImputed class is used to predict the missing values of an input matrix by employing the concept of column mean imputation and then applying Singular Value Decomposition to factor the matrix.
The SVDImputed class is used to predict the missing values of an input matrix by employing the concept of column mean imputation and then applying Singular Value Decomposition to factor the matrix. Once the factors are obtained the missing value in the matrix is obtained as the dot product of 'p' and 'q', where
p = u * sqrt(s) left orthogonal matrix * Singular Values Vector q = sqrt(s) * v.t singular values vector * transpose of right orthogonal matrix predict (i, j) = p dot q
class SVDReg extends Error
The SVDReg class works on the principle of Gradient Descent for minimizing the error generated and L2 regularization, while predicting the missing value in the matrix.
The SVDReg class works on the principle of Gradient Descent for minimizing the error generated and L2 regularization, while predicting the missing value in the matrix. This is obtained by the dot product of 'u(i)' and 'v(j)' vectors: Dimensionality is reduced from 'n' features to 'k' factors.
predict (i, j) = u(i) dot v(j)
class SVD_2by2 extends SVDecomp
The SVD_2by2 is used to solve Singular Value Decomposition for bidiagonal 2-by-2 matrices.
The SVD_2by2 is used to solve Singular Value Decomposition for bidiagonal 2-by-2 matrices.
[ f g ] [ 0 h ]

See also
fortranwiki.org/fortran/show/svd
trait SVDecomp extends Factorization
The SVDDecomp trait specifies the major methods for Singular Value Decomposition implementations: ------------------------------------------------------------------------------ SVD - Golub-Kahan-Reinsch Algorithm translated from Algol code SVD2 - Compute 'a.t * a', 'a * a.t' and use Eigenvalue and Eigenvector SVD3 - Implicit Zero-Shift 'QR' Algorithm SVD4 - Golub-Kahan-Reinsch Algorithm coded from psuedo-code in Matrix Computations The last three are still under development.
class SparseMatrixC extends MatriC with Error with Serializable
The SparseMatrixC class stores and operates on Matrices of Complexs.
The SparseMatrixC class stores and operates on Matrices of Complexs. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of sorted-linked-maps, which record all the non-zero values for each particular row, along with their j-index as (j, v) pairs.
class SparseMatrixD extends MatriD with Error with Serializable
The SparseMatrixD class stores and operates on Matrices of Doubles.
The SparseMatrixD class stores and operates on Matrices of Doubles. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of sorted-linked-maps, which record all the non-zero values for each particular row, along with their j-index as (j, v) pairs.
class SparseMatrixI extends MatriI with Error with Serializable
The SparseMatrixI class stores and operates on Matrices of Ints.
The SparseMatrixI class stores and operates on Matrices of Ints. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of sorted-linked-maps, which record all the non-zero values for each particular row, along with their j-index as (j, v) pairs.
class SparseMatrixL extends MatriL with Error with Serializable
The SparseMatrixL class stores and operates on Matrices of Longs.
The SparseMatrixL class stores and operates on Matrices of Longs. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of sorted-linked-maps, which record all the non-zero values for each particular row, along with their j-index as (j, v) pairs.
class SparseMatrixQ extends MatriQ with Error with Serializable
The SparseMatrixQ class stores and operates on Matrices of Rationals.
The SparseMatrixQ class stores and operates on Matrices of Rationals. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of sorted-linked-maps, which record all the non-zero values for each particular row, along with their j-index as (j, v) pairs.
class SparseMatrixR extends MatriR with Error with Serializable
The SparseMatrixR class stores and operates on Matrices of Reals.
The SparseMatrixR class stores and operates on Matrices of Reals. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of sorted-linked-maps, which record all the non-zero values for each particular row, along with their j-index as (j, v) pairs.
class SparseVectorC extends VectoC
The SparseVectorC class stores and operates on Numeric Vectors of base type Complex.
The SparseVectorC class stores and operates on Numeric Vectors of base type Complex. It follows the framework of gen.VectorN [T] and is provided for performance.
class SparseVectorD extends VectoD
The SparseVectorD class stores and operates on Numeric Vectors of base type Double.
The SparseVectorD class stores and operates on Numeric Vectors of base type Double. It follows the framework of gen.VectorN [T] and is provided for performance.
class SparseVectorI extends VectoI
The SparseVectorI class stores and operates on Numeric Vectors of base type Int.
The SparseVectorI class stores and operates on Numeric Vectors of base type Int. It follows the framework of gen.VectorN [T] and is provided for performance.
class SparseVectorL extends VectoL
The SparseVectorL class stores and operates on Numeric Vectors of base type Long.
The SparseVectorL class stores and operates on Numeric Vectors of base type Long. It follows the framework of gen.VectorN [T] and is provided for performance.
class SparseVectorQ extends VectoQ
The SparseVectorQ class stores and operates on Numeric Vectors of base type Rational.
The SparseVectorQ class stores and operates on Numeric Vectors of base type Rational. It follows the framework of gen.VectorN [T] and is provided for performance.
class SparseVectorR extends VectoR
The SparseVectorR class stores and operates on Numeric Vectors of base type Real.
The SparseVectorR class stores and operates on Numeric Vectors of base type Real. It follows the framework of gen.VectorN [T] and is provided for performance.
class SparseVectorS extends VectoS
The SparseVectorS class stores and operates on Numeric Vectors of base type StrNum.
The SparseVectorS class stores and operates on Numeric Vectors of base type StrNum. It follows the framework of gen.VectorN [T] and is provided for performance.
class SparseVectorT extends VectoT
The SparseVectorT class stores and operates on Numeric Vectors of base type TimeNum.
The SparseVectorT class stores and operates on Numeric Vectors of base type TimeNum. It follows the framework of gen.VectorN [T] and is provided for performance.
class SymTriMatrixC extends MatriC with Error with Serializable
The SymTriMatrixC class stores and operates on symmetric tridiagonal matrices.
The SymTriMatrixC class stores and operates on symmetric tridiagonal matrices. The elements are of type of Complex. A matrix is stored as two vectors: the diagonal vector and the sub-diagonal vector.
class SymTriMatrixD extends MatriD with Error with Serializable
The SymTriMatrixD class stores and operates on symmetric tridiagonal matrices.
The SymTriMatrixD class stores and operates on symmetric tridiagonal matrices. The elements are of type of Double. A matrix is stored as two vectors: the diagonal vector and the sub-diagonal vector.
class SymTriMatrixI extends MatriI with Error with Serializable
The SymTriMatrixI class stores and operates on symmetric tridiagonal matrices.
The SymTriMatrixI class stores and operates on symmetric tridiagonal matrices. The elements are of type of Int. A matrix is stored as two vectors: the diagonal vector and the sub-diagonal vector.
class SymTriMatrixL extends MatriL with Error with Serializable
The SymTriMatrixL class stores and operates on symmetric tridiagonal matrices.
The SymTriMatrixL class stores and operates on symmetric tridiagonal matrices. The elements are of type of Long. A matrix is stored as two vectors: the diagonal vector and the sub-diagonal vector.
class SymTriMatrixQ extends MatriQ with Error with Serializable
The SymTriMatrixQ class stores and operates on symmetric tridiagonal matrices.
The SymTriMatrixQ class stores and operates on symmetric tridiagonal matrices. The elements are of type of Rational. A matrix is stored as two vectors: the diagonal vector and the sub-diagonal vector.
class SymTriMatrixR extends MatriR with Error with Serializable
The SymTriMatrixR class stores and operates on symmetric tridiagonal matrices.
The SymTriMatrixR class stores and operates on symmetric tridiagonal matrices. The elements are of type of Real. A matrix is stored as two vectors: the diagonal vector and the sub-diagonal vector.
class TripletC extends AnyRef
The TripletC class holds a run length encoded triplet, e.g., (_1, 2, 3) Triplets are used for storing compressed vectors and matrices.
class TripletD extends AnyRef
The TripletD class holds a run length encoded triplet, e.g., (1.0, 2, 3) Triplets are used for storing compressed vectors and matrices.
class TripletI extends AnyRef
The TripletI class holds a run length encoded triplet, e.g., (1, 2, 3) Triplets are used for storing compressed vectors and matrices.
class TripletL extends AnyRef
The TripletL class holds a run length encoded triplet, e.g., (1l, 2, 3) Triplets are used for storing compressed vectors and matrices.
class TripletQ extends AnyRef
The TripletQ class holds a run length encoded triplet, e.g., (_1, 2, 3) Triplets are used for storing compressed vectors and matrices.
class TripletR extends AnyRef
The TripletR class holds a run length encoded triplet, e.g., (_1, 2, 3) Triplets are used for storing compressed vectors and matrices.
class TripletS extends AnyRef
The TripletS class holds a run length encoded triplet, e.g., (_1, 2, 3) Triplets are used for storing compressed vectors and matrices.
class TripletT extends AnyRef
The TripletT class holds a run length encoded triplet, e.g., (_1, 2, 3) Triplets are used for storing compressed vectors and matrices.
trait Vec extends AnyRef
The Vec trait establishes a common base type for all ScalaTion linalgebra vectors (e.g., VectorD, VectorI).
trait VectoC extends Traversable[Complex] with PartiallyOrdered[VectoC] with Vec with Error with Serializable
The VectoC class stores and operates on Numeric Vectors of base type Complex.
The VectoC class stores and operates on Numeric Vectors of base type Complex. It follows the framework of gen.VectorN [T] and is provided for performance.
trait VectoD extends Traversable[Double] with PartiallyOrdered[VectoD] with Vec with Error with Serializable
The VectoD class stores and operates on Numeric Vectors of base type Double.
The VectoD class stores and operates on Numeric Vectors of base type Double. It follows the framework of gen.VectorN [T] and is provided for performance.
trait VectoI extends Traversable[Int] with PartiallyOrdered[VectoI] with Vec with Error with Serializable
The VectoI class stores and operates on Numeric Vectors of base type Int.
The VectoI class stores and operates on Numeric Vectors of base type Int. It follows the framework of gen.VectorN [T] and is provided for performance.
trait VectoL extends Traversable[Long] with PartiallyOrdered[VectoL] with Vec with Error with Serializable
The VectoL class stores and operates on Numeric Vectors of base type Long.
The VectoL class stores and operates on Numeric Vectors of base type Long. It follows the framework of gen.VectorN [T] and is provided for performance.
trait VectoQ extends Traversable[Rational] with PartiallyOrdered[VectoQ] with Vec with Error with Serializable
The VectoQ class stores and operates on Numeric Vectors of base type Rational.
The VectoQ class stores and operates on Numeric Vectors of base type Rational. It follows the framework of gen.VectorN [T] and is provided for performance.
trait VectoR extends Traversable[Real] with PartiallyOrdered[VectoR] with Vec with Error with Serializable
The VectoR class stores and operates on Numeric Vectors of base type Real.
The VectoR class stores and operates on Numeric Vectors of base type Real. It follows the framework of gen.VectorN [T] and is provided for performance.
trait VectoS extends Traversable[StrNum] with PartiallyOrdered[VectoS] with Vec with Error with Serializable
The VectoS class stores and operates on Numeric Vectors of base type StrNum.
The VectoS class stores and operates on Numeric Vectors of base type StrNum. It follows the framework of gen.VectorN [T] and is provided for performance.
trait VectoT extends Traversable[TimeNum] with PartiallyOrdered[VectoT] with Vec with Error with Serializable
The VectoT class stores and operates on Numeric Vectors of base type TimeNum.
The VectoT class stores and operates on Numeric Vectors of base type TimeNum. It follows the framework of gen.VectorN [T] and is provided for performance.
class VectorC extends VectoC
The VectorC class stores and operates on Numeric Vectors of base type Complex.
The VectorC class stores and operates on Numeric Vectors of base type Complex. It follows the framework of gen.VectorN [T] and is provided for performance.
class VectorD extends VectoD
The VectorD class stores and operates on Numeric Vectors of base type Double.
The VectorD class stores and operates on Numeric Vectors of base type Double. It follows the framework of gen.VectorN [T] and is provided for performance.
class VectorI extends VectoI
The VectorI class stores and operates on Numeric Vectors of base type Int.
The VectorI class stores and operates on Numeric Vectors of base type Int. It follows the framework of gen.VectorN [T] and is provided for performance.
class VectorL extends VectoL
The VectorL class stores and operates on Numeric Vectors of base type Long.
The VectorL class stores and operates on Numeric Vectors of base type Long. It follows the framework of gen.VectorN [T] and is provided for performance.
class VectorQ extends VectoQ
The VectorQ class stores and operates on Numeric Vectors of base type Rational.
The VectorQ class stores and operates on Numeric Vectors of base type Rational. It follows the framework of gen.VectorN [T] and is provided for performance.
class VectorR extends VectoR
The VectorR class stores and operates on Numeric Vectors of base type Real.
The VectorR class stores and operates on Numeric Vectors of base type Real. It follows the framework of gen.VectorN [T] and is provided for performance.
class VectorS extends VectoS
The VectorS class stores and operates on Numeric Vectors of base type StrNum.
The VectorS class stores and operates on Numeric Vectors of base type StrNum. It follows the framework of gen.VectorN [T] and is provided for performance.
class VectorT extends VectoT
The VectorT class stores and operates on Numeric Vectors of base type TimeNum.
The VectorT class stores and operates on Numeric Vectors of base type TimeNum. It follows the framework of gen.VectorN [T] and is provided for performance.

Value Members

def matrixize(f: FunctionV_2V): FunctionM_2M
Matrixize a scalar function (S2S) to create a matrix function (M_2M).
Matrixize a scalar function (S2S) to create a matrix function (M_2M).
f
the scalar function to matrixize
def vectorize(f: FunctionS2S): FunctionV_2V
Vectorize a scalar function (S2S) to create a vector function (V_2V).
Vectorize a scalar function (S2S) to create a vector function (V_2V).
f
the scalar function to vectorize
object BidMatrixC extends Error with Serializable
The BidMatrixC object is the companion object for the BidMatrixC class.
object BidMatrixCTest extends App
The BidMatrixCTest object is used to test the BidMatrixC class.
The BidMatrixCTest object is used to test the BidMatrixC class. > runMain scalation.linalgebra.BidMatrixCTest
object BidMatrixD extends Error with Serializable
The BidMatrixD object is the companion object for the BidMatrixD class.
object BidMatrixDTest extends App
The BidMatrixDTest object is used to test the BidMatrixD class.
The BidMatrixDTest object is used to test the BidMatrixD class. > runMain scalation.linalgebra.BidMatrixDTest
object BidMatrixI extends Error with Serializable
The BidMatrixI object is the companion object for the BidMatrixI class.
object BidMatrixITest extends App
The BidMatrixITest object is used to test the BidMatrixI class.
The BidMatrixITest object is used to test the BidMatrixI class. > runMain scalation.linalgebra.BidMatrixITest
object BidMatrixL extends Error with Serializable
The BidMatrixL object is the companion object for the BidMatrixL class.
object BidMatrixLTest extends App
The BidMatrixLTest object is used to test the BidMatrixL class.
The BidMatrixLTest object is used to test the BidMatrixL class. > runMain scalation.linalgebra.BidMatrixLTest
object BidMatrixQ extends Error with Serializable
The BidMatrixQ object is the companion object for the BidMatrixQ class.
object BidMatrixQTest extends App
The BidMatrixQTest object is used to test the BidMatrixQ class.
The BidMatrixQTest object is used to test the BidMatrixQ class. > runMain scalation.linalgebra.BidMatrixQTest
object BidMatrixR extends Error with Serializable
The BidMatrixR object is the companion object for the BidMatrixR class.
object BidMatrixRTest extends App
The BidMatrixRTest object is used to test the BidMatrixR class.
The BidMatrixRTest object is used to test the BidMatrixR class. > runMain scalation.linalgebra.BidMatrixRTest
object Bidiagonal2Test extends App
The Bidiagonal2Test object is used to test the Bidiagonal2 class.
The Bidiagonal2Test object is used to test the Bidiagonal2 class. bidiagonalization answer = [ (21.8, -.613), (12.8, 2.24, 0.) ]

See also
books.google.com/books?isbn=0801854148 (p. 252) > runMain scalation.linalgebra.Bidiagonal2Test
object Bidiagonal2Test2 extends App
The Bidiagonal2Test2 object is used to test the Bidiagonal2 class.
The Bidiagonal2Test2 object is used to test the Bidiagonal2 class. bidiagonalization answer = [ (21.8, -.613), (12.8, 2.24, 0.) ] This version produces an 'm-by-m u' matrix.

See also
books.google.com/books?isbn=0801854148 (p. 252) > runMain scalation.linalgebra.Bidiagonal2Test2
object BidiagonalTest extends App
The BidiagonalTest object is used to test the Bidiagonal class.
The BidiagonalTest object is used to test the Bidiagonal class. bidiagonalization answer = [ (21.8, -.613), (12.8, 2.24, 0.) ]

See also
books.google.com/books?isbn=0801854148 (p. 252) > runMain scalation.linalgebra.BidiagonalTest
object Converter
The Converter object converts string number vectors to regular numeric vectors.
object ConverterTest extends App
The ConverterTest object is used to test the Converter class.
The ConverterTest object is used to test the Converter class. > runMain scalation.linalgebra.ConverterTest
object EigenTest extends App
The EigenTest object is used to test the all the classes used in computing Eigenvalues and Eigenvectors for the non-symmetric/general case.
The EigenTest object is used to test the all the classes used in computing Eigenvalues and Eigenvectors for the non-symmetric/general case. > runMain scalation.linalgebra.EigenTest
object Eigen_2by2 extends Error
The Eigen_2by2 object provides simple methods for computing eigenvalues and eigenvectors for 2-by-2 matrices.
object Eigen_2by2Test extends App
The Eigen_2by2Test is used to test the Eigen_2by2 object.
The Eigen_2by2Test is used to test the Eigen_2by2 object. > runMain scalation.linalgebra.Eigen_2by2Test
object Fac_CholeskyTest extends App
The Fac_CholeskyTest object is used to test the Fac_Cholesky class.
The Fac_CholeskyTest object is used to test the Fac_Cholesky class.

See also
ece.uwaterloo.ca/~dwharder/NumericalAnalysis/04LinearAlgebra/cholesky > runMain scalation.linalgebra.Fac_CholeskyTest
object Fac_InvTest extends App
The Fac_InvTest object is used to test the Fac_Inv class.
The Fac_InvTest object is used to test the Fac_Inv class. > runMain scalation.linalgebra.Fac_InvTest
object Fac_LQTest extends App
The Fac_LQTest object is used to test the Fac_LQ class.
The Fac_LQTest object is used to test the Fac_LQ class. > runMain scalation.linalgebra.Fac_LQTest
object Fac_LU extends Error
The Fac_LU companion object provides functions related to LU Factorization.
object Fac_LUTest extends App
The Fac_LUTest object is used to test the Fac_LU class.
The Fac_LUTest object is used to test the Fac_LU class. Test a Square Matrix. > runMain scalation.linalgebra.Fac_LUTest
object Fac_LUTest2 extends App
The Fac_LUTest2 object is used to test the Fac_LU class.
The Fac_LUTest2 object is used to test the Fac_LU class. Test a Rectangular Matrix. > runMain scalation.linalgebra.Fac_LUTest2
object Fac_LUTest3 extends App
The Fac_LUTest3 object is used to test the Fac_LU class.
The Fac_LUTest3 object is used to test the Fac_LU class. > runMain scalation.linalgebra.Fac_LUTest3
object Fac_QR
object Fac_QRTest extends App
The Fac_QRTest object is used to test the Fac_QR classes.
The Fac_QRTest object is used to test the Fac_QR classes.

See also
www.math.usm.edu/lambers/mat610/sum10/lecture9.pdf FIX: the 'nullspaceV' function need to be fixed. > runMain scalation.linalgebra.Fac_QRTest
www.ee.ucla.edu/~vandenbe/103/lectures/qr.pdf
object Fac_QRTest2 extends App
The Fac_QRTest2 object is used to test the correctness of the 'solve' method in the Fac_QR classes.
The Fac_QRTest2 object is used to test the correctness of the 'solve' method in the Fac_QR classes. > runMain scalation.linalgebra.Fac_QRTest2
object Fac_QR_RRTest extends App
The Fac_QR_RRTest object is used to test the Fac_QR_RR classes.
The Fac_QR_RRTest object is used to test the Fac_QR_RR classes.

See also
www.math.usm.edu/lambers/mat610/sum10/lecture9.pdf FIX: the 'nullspaceV' function need to be fixed. > runMain scalation.linalgebra.Fac_QR_RRTest
www.ee.ucla.edu/~vandenbe/103/lectures/qr.pdf
object Givens
The Givens objects has methods for determining values 'c = cos(theta)' and 's = sin(theta)' for Givens rotation matrices as well as methods for applying Givens rotations.
object GivensTest extends App
The GivensTest object tests the Givens object by using two rotations to turn matrix 'a' into an upper triangular matrix, clearing positions (1, 0) and (2, 1).
The GivensTest object tests the Givens object by using two rotations to turn matrix 'a' into an upper triangular matrix, clearing positions (1, 0) and (2, 1). A third rotation clears position (0, 1) but also puts a non-zero value at (1, 0).

See also
http://en.wikipedia.org/wiki/Givens_rotation > runMain scalation.linalgebra.GivensTest
object Householder
The Householder object provides methods to compute Householder vectors and reflector matrices.
object HouseholderTest extends App
The HouseholderTest object is used to test Householder object.
The HouseholderTest object is used to test Householder object.

See also
www.math.siu.edu/matlab/tutorial4.pdf > runMain scalation.linalgebra.HouseholderTest
object MatrixC extends Error with Serializable
The MatrixC companion object provides operations for MatrixC that don't require 'this' (like static methods in Java).
The MatrixC companion object provides operations for MatrixC that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors.
object MatrixCTest extends App
The MatrixCTest object tests the operations provided by MatrixC class.
The MatrixCTest object tests the operations provided by MatrixC class. > runMain scalation.linalgebra.MatrixCTest
object MatrixD extends Error with Serializable
The MatrixD companion object provides operations for MatrixD that don't require 'this' (like static methods in Java).
The MatrixD companion object provides operations for MatrixD that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors.
object MatrixDTest extends App
The MatrixDTest object tests the operations provided by MatrixD class.
The MatrixDTest object tests the operations provided by MatrixD class. > runMain scalation.linalgebra.MatrixDTest
object MatrixI extends Error with Serializable
The MatrixI companion object provides operations for MatrixI that don't require 'this' (like static methods in Java).
The MatrixI companion object provides operations for MatrixI that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors.
object MatrixITest extends App
The MatrixITest object tests the operations provided by MatrixI class.
The MatrixITest object tests the operations provided by MatrixI class. > runMain scalation.linalgebra.MatrixITest
object MatrixKind extends Enumeration
The MatrixKind object defines an enumeration for the kinds of matrices supported in ScalaTion.
The MatrixKind object defines an enumeration for the kinds of matrices supported in ScalaTion. Combined with the base type (e.g., D for Double), a particular type of matrix is defined (e.g., SparseMatrixD).
object MatrixL extends Error with Serializable
The MatrixL companion object provides operations for MatrixL that don't require 'this' (like static methods in Java).
The MatrixL companion object provides operations for MatrixL that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors.
object MatrixLTest extends App
The MatrixLTest object tests the operations provided by MatrixL class.
The MatrixLTest object tests the operations provided by MatrixL class. > runMain scalation.linalgebra.MatrixLTest
object MatrixQ extends Error with Serializable
The MatrixQ companion object provides operations for MatrixQ that don't require 'this' (like static methods in Java).
The MatrixQ companion object provides operations for MatrixQ that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors.
object MatrixQTest extends App
The MatrixQTest object tests the operations provided by MatrixQ class.
The MatrixQTest object tests the operations provided by MatrixQ class. > runMain scalation.linalgebra.MatrixQTest
object MatrixR extends Error with Serializable
The MatrixR companion object provides operations for MatrixR that don't require 'this' (like static methods in Java).
The MatrixR companion object provides operations for MatrixR that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors.
object MatrixRTest extends App
The MatrixRTest object tests the operations provided by MatrixR class.
The MatrixRTest object tests the operations provided by MatrixR class. > runMain scalation.linalgebra.MatrixRTest
object PivotingTest extends App with Pivoting
The PivotingTest is used to test the Pivoting trait.
The PivotingTest is used to test the Pivoting trait. > runMain scalation.linalgebra.PivotingTest
object RleMatrixC extends Serializable
The RleMatrixC companion object provides operations for RleMatrixC that don't require 'this' (like static methods in Java).
The RleMatrixC companion object provides operations for RleMatrixC that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from sequences or vectors.
object RleMatrixCTest extends App
The RleMatrixCTest object tests the operations provided by MatrixC class.
The RleMatrixCTest object tests the operations provided by MatrixC class. > runMain scalation.linalgebra.RleMatrixCTest
object RleMatrixD extends Serializable
The RleMatrixD companion object provides operations for RleMatrixD that don't require 'this' (like static methods in Java).
The RleMatrixD companion object provides operations for RleMatrixD that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from sequences or vectors.
object RleMatrixDTest extends App
The RleMatrixDTest object tests the operations provided by MatrixD class.
The RleMatrixDTest object tests the operations provided by MatrixD class. > runMain scalation.linalgebra.RleMatrixDTest
object RleMatrixI extends Serializable
The RleMatrixI companion object provides operations for RleMatrixI that don't require 'this' (like static methods in Java).
The RleMatrixI companion object provides operations for RleMatrixI that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from sequences or vectors.
object RleMatrixITest extends App
The RleMatrixITest object tests the operations provided by MatrixI class.
The RleMatrixITest object tests the operations provided by MatrixI class. > runMain scalation.linalgebra.RleMatrixITest
object RleMatrixL extends Serializable
The RleMatrixL companion object provides operations for RleMatrixL that don't require 'this' (like static methods in Java).
The RleMatrixL companion object provides operations for RleMatrixL that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from sequences or vectors.
object RleMatrixLTest extends App
The RleMatrixLTest object tests the operations provided by MatrixL class.
The RleMatrixLTest object tests the operations provided by MatrixL class. > runMain scalation.linalgebra.RleMatrixLTest
object RleMatrixQ extends Serializable
The RleMatrixQ companion object provides operations for RleMatrixQ that don't require 'this' (like static methods in Java).
The RleMatrixQ companion object provides operations for RleMatrixQ that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from sequences or vectors.
object RleMatrixQTest extends App
The RleMatrixQTest object tests the operations provided by MatrixQ class.
The RleMatrixQTest object tests the operations provided by MatrixQ class. > runMain scalation.linalgebra.RleMatrixQTest
object RleMatrixR extends Serializable
The RleMatrixR companion object provides operations for RleMatrixR that don't require 'this' (like static methods in Java).
The RleMatrixR companion object provides operations for RleMatrixR that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from sequences or vectors.
object RleMatrixRTest extends App
The RleMatrixRTest object tests the operations provided by MatrixR class.
The RleMatrixRTest object tests the operations provided by MatrixR class. > runMain scalation.linalgebra.RleMatrixRTest
object RleVectorC extends Serializable
The RleVectorC object is the companion object for the RleVectorC class.
object RleVectorCTest extends App
The RleVectorCTest object tests the operations provided by RleVectorC.
The RleVectorCTest object tests the operations provided by RleVectorC. > runMain scalation.linalgebra.RleVectorCTest
object RleVectorD extends Serializable
The RleVectorD object is the companion object for the RleVectorD class.
object RleVectorDTest extends App
The RleVectorDTest object tests the operations provided by RleVectorD.
The RleVectorDTest object tests the operations provided by RleVectorD. > runMain scalation.linalgebra.RleVectorDTest
object RleVectorI extends Serializable
The RleVectorI object is the companion object for the RleVectorI class.
object RleVectorITest extends App
The RleVectorITest object tests the operations provided by RleVectorI.
The RleVectorITest object tests the operations provided by RleVectorI. > runMain scalation.linalgebra.RleVectorITest
object RleVectorL extends Serializable
The RleVectorL object is the companion object for the RleVectorL class.
object RleVectorLTest extends App
The RleVectorLTest object tests the operations provided by RleVectorL.
The RleVectorLTest object tests the operations provided by RleVectorL. > runMain scalation.linalgebra.RleVectorLTest
object RleVectorQ extends Serializable
The RleVectorQ object is the companion object for the RleVectorQ class.
object RleVectorQTest extends App
The RleVectorQTest object tests the operations provided by RleVectorQ.
The RleVectorQTest object tests the operations provided by RleVectorQ. > runMain scalation.linalgebra.RleVectorQTest
object RleVectorR extends Serializable
The RleVectorR object is the companion object for the RleVectorR class.
object RleVectorRTest extends App
The RleVectorRTest object tests the operations provided by RleVectorR.
The RleVectorRTest object tests the operations provided by RleVectorR. > runMain scalation.linalgebra.RleVectorRTest
object RleVectorS extends Serializable
The RleVectorS object is the companion object for the RleVectorS class.
object RleVectorSTest extends App
The RleVectorSTest object tests the operations provided by RleVectorS.
The RleVectorSTest object tests the operations provided by RleVectorS. > runMain scalation.linalgebra.RleVectorSTest
object RleVectorT extends Serializable
The RleVectorT object is the companion object for the RleVectorT class.
object RleVectorTTest extends App
The RleVectorTTest object tests the operations provided by RleVectorT.
The RleVectorTTest object tests the operations provided by RleVectorT. > runMain scalation.linalgebra.RleVectorTTest
object Rotation extends Serializable
The Rotation object provides methods for rotating in a plane.
The Rotation object provides methods for rotating in a plane.
[ cs sn ] . [ f ] = [ r ] where cs^{2 + sn}2 = 1 [ -sn cs ] [ g ] [ 0 ]
object RotationTest extends App
The RotationTest object is used to test the Rotation object, > runMain scalation.linalgebra.RotationTest
object SVD2Test extends App
The SVD2Test object is used to test the SVD2 class.
The SVD2Test object is used to test the SVD2 class.

See also
www.ling.ohio-state.edu/~kbaker/pubs/Singular_Value_Decomposition_Tutorial.pdf > runMain scalation.linalgebra.SVD2Test
object SVD2Test2 extends App
The SVD2Test2 object is used to test the SVD2 class.
The SVD2Test2 object is used to test the SVD2 class.

See also
www.ling.ohio-state.edu/~kbaker/pubs/Singular_Value_Decomposition_Tutorial.pdf > runMain scalation.linalgebra.SVD2Test2
object SVD2Test3 extends App
The SVD2Test3 object is used to test the SVD2 class.
The SVD2Test3 object is used to test the SVD2 class. > runMain scalation.linalgebra.SVD2Test3
object SVD2Test4 extends App
The SVD2Test4 object is used to test the SVD2 class.
The SVD2Test4 object is used to test the SVD2 class. > runMain scalation.linalgebra.SVD2Test4
object SVD2Test5 extends App
The SVD2Test5 object is used to test the SVD2 class.
The SVD2Test5 object is used to test the SVD2 class. > runMain scalation.linalgebra.SVD2Test5
object SVD2Test6 extends App
The SVD2Test6 object is used to test the SVD2 class.
The SVD2Test6 object is used to test the SVD2 class. > runMain scalation.linalgebra.SVD2Test6
object SVD2Test7 extends App
The SVD2Test7 object is used to test the SVD2 class.
The SVD2Test7 object is used to test the SVD2 class. > runMain scalation.linalgebra.SVD2Test7
object SVD2Test8 extends App
The SVD2Test8 object is used to test the SVD2 class.
The SVD2Test8 object is used to test the SVD2 class. > runMain scalation.linalgebra.SVD2Test8
object SVD3Test extends App
The SVD3Test is used to test the SVD3 class.
The SVD3Test is used to test the SVD3 class. Answer: singular values = (2.28825, 0.87403)

See also
http://comnuan.com/cmnn01004/
object SVD3Test2 extends App
The SVD3Test2 is used to test the SVD3 class.
The SVD3Test2 is used to test the SVD3 class. Answer: singular values = (3.82983, 1.91368, 0.81866)
object SVD4
The SVD4 companion object.
object SVD4Test extends App
The SVD4Test object is used to test the SVD4 class starting with a matrix that is already in bidiagonal form and gives eigenvalues of 28, 18 for the first step.
The SVD4Test object is used to test the SVD4 class starting with a matrix that is already in bidiagonal form and gives eigenvalues of 28, 18 for the first step.

See also
ocw.mit.edu/ans7870/18/18.06/javademo/SVD/ > runMain scalation.linalgebra.SVD4Test
object SVD4Test2 extends App
The SVD4Test2 is used to test the SVD4 class.
The SVD4Test2 is used to test the SVD4 class. Answer: singular values = (3.82983, 1.91368, 0.81866) > runMain scalation.linalgebra.SVD4Test2
object SVD4Test3 extends App
The SVD4Test3 object is used to test the SVD4 class starting with general (i.e., not bidiagonalized) matrices.
The SVD4Test3 object is used to test the SVD4 class starting with general (i.e., not bidiagonalized) matrices. All probelems for which m >= n from the following Webspage are tried.

See also
mysite.science.uottawa.ca/phofstra/MAT2342/SVDproblems.pdf > runMain scalation.linalgebra.SVD4Test3
www.mathstat.uottawa.ca/~phofstra/MAT2342/SVDproblems.pdf
object SVD4Test4 extends App
The SVD4Test4 object is used to test the SVD4 class starting with a general matrix.
The SVD4Test4 object is used to test the SVD4 class starting with a general matrix. > runMain scalation.linalgebra.SVD4Test4
object SVD4Test5 extends App
The SVD4Test5 is used to test the SVD4 class on a problem where the matrix is not a square matrix.
The SVD4Test5 is used to test the SVD4 class on a problem where the matrix is not a square matrix. > runMain scalation.linalgebra.SVD4Test5
object SVD4Test6 extends App
The SVD4Test5 is used to test the SVD4 class on a larger test problem.
The SVD4Test5 is used to test the SVD4 class on a larger test problem.

See also
www.maths.manchester.ac.uk/~peterf/MATH48062/math48062%20Calculating%20and%20using%20the%20svd%20of%20a%20matrix.pdf FIX: this example does not work, in the sense that is does not converge to 'TOL'. > runMain scalation.linalgebra.SVD4Test6
object SVD4Test7 extends App
The SVD4Test6 object is used to test the SVD4 companion object's computation of trailing submatrices.
The SVD4Test6 object is used to test the SVD4 companion object's computation of trailing submatrices. > runMain scalation.linalgebra.SVD4Test7
object SVDImputed
The SVDImputed companion object is used to perform imputation.
object SVDImputedTest extends App
The SVDImputedTest object is used to test the SVDImputed method.
The SVDImputedTest object is used to test the SVDImputed method. > runMain scalation.linalgebra.SVDImputedTest
object SVDRegTest extends App
The SVDRegTest object is used to test the SVDReg method.
The SVDRegTest object is used to test the SVDReg method.

See also
analytics.recommender.ModelBasedRecommender for further testing > runMain scalation.linalgebra.SVDRegTest
object SVDTest extends App
The SVDTest is used to test the SVD class.
The SVDTest is used to test the SVD class. > runMain scalation.linalgebra.SVDTest
object SVDTest2 extends App
The SVDTest2 object is used to test the SVD class.
The SVDTest2 object is used to test the SVD class.

See also
www.ling.ohio-state.edu/~kbaker/pubs/Singular_Value_Decomposition_Tutorial.pdf > runMain scalation.linalgebra.SVDTest2
object SVDTest3 extends App
The SVDTest3 object is used to test the SVD class.
The SVDTest3 object is used to test the SVD class. > runMain scalation.linalgebra.SVDTest3
object SVDTest4 extends App
The SVDTest4 object is used to test the SVD class.
The SVDTest4 object is used to test the SVD class. > runMain scalation.linalgebra.SVDTest4
object SVDTest5 extends App
The SVDTest5 object is used to test the SVD class.
The SVDTest5 object is used to test the SVD class. > runMain scalation.linalgebra.SVDTest5
object SVDTest6 extends App
The SVDTest6 object is used to test the SVD class.
The SVDTest6 object is used to test the SVD class. > runMain scalation.linalgebra.SVDTest6
object SVDTest7 extends App
The SVDTest7 object is used to test the SVD class.
The SVDTest7 object is used to test the SVD class. This test case currently fails as ScalaTion does not consider 9.18964e-09 to be approximately zero. > runMain scalation.linalgebra.SVDTest7
object SVDTest8 extends App
The SVDTest8 object is used to test the SVD class.
The SVDTest8 object is used to test the SVD class. > runMain scalation.linalgebra.SVDTest7
object SVD_2by2Test extends App
The SVD_2by2Test is used to test the SVD_2by2 class.
object SVDecomp extends SVDecomp
The SVDecomp object provides several test matrices as well as methods for making full representations, reducing dimensionality, determining rank and testing SVD factorizations.
object SVDecompTest extends App
The SVDecompTest object tests the equality of the SVD and SVD2 classes.
The SVDecompTest object tests the equality of the SVD and SVD2 classes. > runMain scalation.linalgebra.SVDecompTest
object SVDecompTest2 extends App
The SVDecompTest2 object tests the equality of the SVD and SVD2 classes.
The SVDecompTest2 object tests the equality of the SVD and SVD2 classes. > runMain scalation.linalgebra.SVDecompTest2
object SVDecompTest3 extends App
The SVDecompTest3 object tests the equality of the SVD and SVD2 classes.
The SVDecompTest3 object tests the equality of the SVD and SVD2 classes. > runMain scalation.linalgebra.SVDecompTest3
object SVDecompTest4 extends App
The SVDecompTest4 object tests the equality of the SVD and SVD2 classes.
The SVDecompTest4 object tests the equality of the SVD and SVD2 classes. > runMain scalation.linalgebra.SVDecompTest4
object SVDecompTest5 extends App
The SVDecompTest5 object tests the equality of the SVD and SVD2 classes.
The SVDecompTest5 object tests the equality of the SVD and SVD2 classes. > runMain scalation.linalgebra.SVDecompTest5
object SVDecompTest6 extends App
The SVDecompTest6 object tests the equality of the SVD and SVD2 classes.
The SVDecompTest6 object tests the equality of the SVD and SVD2 classes. > runMain scalation.linalgebra.SVDecompTest6
object SVDecompTest7 extends App
The SVDecompTest7 object tests the equality of the SVD and SVD2 classes.
The SVDecompTest7 object tests the equality of the SVD and SVD2 classes. > runMain scalation.linalgebra.SVDecompTest7
object SVDecompTest8 extends App
The SVDecompTest8 object tests the equality of the SVD and SVD2 classes.
The SVDecompTest8 object tests the equality of the SVD and SVD2 classes. > runMain scalation.linalgebra.SVDecompTest8
object SparseMatrixC extends Serializable
The SparseMatrixC object is the companion object for the SparseMatrixC class.
object SparseMatrixCTest extends App
The SparseMatrixCTest object is used to test the SparseMatrixC class.
The SparseMatrixCTest object is used to test the SparseMatrixC class. > runMain scalation.linalgebra.SparseMatrixCTest
object SparseMatrixD extends Serializable
The SparseMatrixD object is the companion object for the SparseMatrixD class.
object SparseMatrixDTest extends App
The SparseMatrixDTest object is used to test the SparseMatrixD class.
The SparseMatrixDTest object is used to test the SparseMatrixD class. > runMain scalation.linalgebra.SparseMatrixDTest
object SparseMatrixI extends Serializable
The SparseMatrixI object is the companion object for the SparseMatrixI class.
object SparseMatrixITest extends App
The SparseMatrixITest object is used to test the SparseMatrixI class.
The SparseMatrixITest object is used to test the SparseMatrixI class. > runMain scalation.linalgebra.SparseMatrixITest
object SparseMatrixL extends Serializable
The SparseMatrixL object is the companion object for the SparseMatrixL class.
object SparseMatrixLTest extends App
The SparseMatrixLTest object is used to test the SparseMatrixL class.
The SparseMatrixLTest object is used to test the SparseMatrixL class. > runMain scalation.linalgebra.SparseMatrixLTest
object SparseMatrixQ extends Serializable
The SparseMatrixQ object is the companion object for the SparseMatrixQ class.
object SparseMatrixQTest extends App
The SparseMatrixQTest object is used to test the SparseMatrixQ class.
The SparseMatrixQTest object is used to test the SparseMatrixQ class. > runMain scalation.linalgebra.SparseMatrixQTest
object SparseMatrixR extends Serializable
The SparseMatrixR object is the companion object for the SparseMatrixR class.
object SparseMatrixRTest extends App
The SparseMatrixRTest object is used to test the SparseMatrixR class.
The SparseMatrixRTest object is used to test the SparseMatrixR class. > runMain scalation.linalgebra.SparseMatrixRTest
object SparseVectorC extends Serializable
The SparseVectorC object is the companion object for the SparseVectorC class.
object SparseVectorCTest extends App
The SparseVectorDTest object tests the operations provided by SparseVectorC.
The SparseVectorDTest object tests the operations provided by SparseVectorC. > runMain scalation.linalgebra.SparseVectorDTest
object SparseVectorCTest2 extends App
The SparseVectorDTest2 object tests the dot product operation provided by SparseVectorC.
The SparseVectorDTest2 object tests the dot product operation provided by SparseVectorC. > runMain scalation.linalgebra.SparseVectorDTest2
object SparseVectorD extends Serializable
The SparseVectorD object is the companion object for the SparseVectorD class.
object SparseVectorDTest extends App
The SparseVectorDTest object tests the operations provided by SparseVectorD.
The SparseVectorDTest object tests the operations provided by SparseVectorD. > runMain scalation.linalgebra.SparseVectorDTest
object SparseVectorDTest2 extends App
The SparseVectorDTest2 object tests the dot product operation provided by SparseVectorD.
The SparseVectorDTest2 object tests the dot product operation provided by SparseVectorD. > runMain scalation.linalgebra.SparseVectorDTest2
object SparseVectorI extends Serializable
The SparseVectorI object is the companion object for the SparseVectorI class.
object SparseVectorITest extends App
The SparseVectorDTest object tests the operations provided by SparseVectorI.
The SparseVectorDTest object tests the operations provided by SparseVectorI. > runMain scalation.linalgebra.SparseVectorDTest
object SparseVectorITest2 extends App
The SparseVectorDTest2 object tests the dot product operation provided by SparseVectorI.
The SparseVectorDTest2 object tests the dot product operation provided by SparseVectorI. > runMain scalation.linalgebra.SparseVectorDTest2
object SparseVectorL extends Serializable
The SparseVectorL object is the companion object for the SparseVectorL class.
object SparseVectorLTest extends App
The SparseVectorDTest object tests the operations provided by SparseVectorL.
The SparseVectorDTest object tests the operations provided by SparseVectorL. > runMain scalation.linalgebra.SparseVectorDTest
object SparseVectorLTest2 extends App
The SparseVectorDTest2 object tests the dot product operation provided by SparseVectorL.
The SparseVectorDTest2 object tests the dot product operation provided by SparseVectorL. > runMain scalation.linalgebra.SparseVectorDTest2
object SparseVectorQ extends Serializable
The SparseVectorQ object is the companion object for the SparseVectorQ class.
object SparseVectorQTest extends App
The SparseVectorDTest object tests the operations provided by SparseVectorQ.
The SparseVectorDTest object tests the operations provided by SparseVectorQ. > runMain scalation.linalgebra.SparseVectorDTest
object SparseVectorQTest2 extends App
The SparseVectorDTest2 object tests the dot product operation provided by SparseVectorQ.
The SparseVectorDTest2 object tests the dot product operation provided by SparseVectorQ. > runMain scalation.linalgebra.SparseVectorDTest2
object SparseVectorR extends Serializable
The SparseVectorR object is the companion object for the SparseVectorR class.
object SparseVectorRTest extends App
The SparseVectorDTest object tests the operations provided by SparseVectorR.
The SparseVectorDTest object tests the operations provided by SparseVectorR. > runMain scalation.linalgebra.SparseVectorDTest
object SparseVectorRTest2 extends App
The SparseVectorDTest2 object tests the dot product operation provided by SparseVectorR.
The SparseVectorDTest2 object tests the dot product operation provided by SparseVectorR. > runMain scalation.linalgebra.SparseVectorDTest2
object SparseVectorS extends Serializable
The SparseVectorS object is the companion object for the SparseVectorS class.
object SparseVectorSTest extends App
The SparseVectorDTest object tests the operations provided by SparseVectorS.
The SparseVectorDTest object tests the operations provided by SparseVectorS. > runMain scalation.linalgebra.SparseVectorDTest
object SparseVectorSTest2 extends App
The SparseVectorDTest2 object tests the dot product operation provided by SparseVectorS.
The SparseVectorDTest2 object tests the dot product operation provided by SparseVectorS. > runMain scalation.linalgebra.SparseVectorDTest2
object SparseVectorT extends Serializable
The SparseVectorT object is the companion object for the SparseVectorT class.
object SparseVectorTTest extends App
The SparseVectorDTest object tests the operations provided by SparseVectorT.
The SparseVectorDTest object tests the operations provided by SparseVectorT. > runMain scalation.linalgebra.SparseVectorDTest
object SparseVectorTTest2 extends App
The SparseVectorDTest2 object tests the dot product operation provided by SparseVectorT.
The SparseVectorDTest2 object tests the dot product operation provided by SparseVectorT. > runMain scalation.linalgebra.SparseVectorDTest2
object SymTriMatrixC extends Error with Serializable
The SymTriMatrixC object is the companion object for the SymTriMatrixC class.
object SymTriMatrixCTest extends App
The SymTriMatrixCTest object is used to test the SymTriMatrixC class.
The SymTriMatrixCTest object is used to test the SymTriMatrixC class. > runMain scalation.linalgebra.SymTriMatrixCTest
object SymTriMatrixD extends Error with Serializable
The SymTriMatrixD object is the companion object for the SymTriMatrixD class.
object SymTriMatrixDTest extends App
The SymTriMatrixDTest object is used to test the SymTriMatrixD class.
The SymTriMatrixDTest object is used to test the SymTriMatrixD class. > runMain scalation.linalgebra.SymTriMatrixDTest
object SymTriMatrixI extends Error with Serializable
The SymTriMatrixI object is the companion object for the SymTriMatrixI class.
object SymTriMatrixITest extends App
The SymTriMatrixITest object is used to test the SymTriMatrixI class.
The SymTriMatrixITest object is used to test the SymTriMatrixI class. > runMain scalation.linalgebra.SymTriMatrixITest
object SymTriMatrixL extends Error with Serializable
The SymTriMatrixL object is the companion object for the SymTriMatrixL class.
object SymTriMatrixLTest extends App
The SymTriMatrixLTest object is used to test the SymTriMatrixL class.
The SymTriMatrixLTest object is used to test the SymTriMatrixL class. > runMain scalation.linalgebra.SymTriMatrixLTest
object SymTriMatrixQ extends Error with Serializable
The SymTriMatrixQ object is the companion object for the SymTriMatrixQ class.
object SymTriMatrixQTest extends App
The SymTriMatrixQTest object is used to test the SymTriMatrixQ class.
The SymTriMatrixQTest object is used to test the SymTriMatrixQ class. > runMain scalation.linalgebra.SymTriMatrixQTest
object SymTriMatrixR extends Error with Serializable
The SymTriMatrixR object is the companion object for the SymTriMatrixR class.
object SymTriMatrixRTest extends App
The SymTriMatrixRTest object is used to test the SymTriMatrixR class.
The SymTriMatrixRTest object is used to test the SymTriMatrixR class. > runMain scalation.linalgebra.SymTriMatrixRTest
object SymmetricQRstep extends Eigen with Error
The SymmetricQRstep object performs a symmetric 'QR' step with a Wilkinson shift.
The SymmetricQRstep object performs a symmetric 'QR' step with a Wilkinson shift.

See also
http://people.inf.ethz.ch/arbenz/ewp/Lnotes/chapter3.pdf (Algorithm 3.6)
Algorithm 8.3.2 in Matrix Computations.
object Vec
The Vec object provides a minimal set of functions that apply across all types of ScalaTion linalgebra vectors.
The Vec object provides a minimal set of functions that apply across all types of ScalaTion linalgebra vectors.

See also
scalation.columnar_db.Relation
object Vec_Elem
The Vec_Elem object provides comparison operators for Vec elements.
object VectorC extends Serializable
The VectorC object is the companion object for the VectorC class.
object VectorCTest extends App
The VectorCTest object tests the operations provided by VectorC.
The VectorCTest object tests the operations provided by VectorC. > runMain scalation.linalgebra.VectorCTest
object VectorD extends Serializable
The VectorD object is the companion object for the VectorD class.
object VectorDTest extends App
The VectorDTest object tests the operations provided by VectorD.
The VectorDTest object tests the operations provided by VectorD. > runMain scalation.linalgebra.VectorDTest
object VectorI extends Serializable
The VectorI object is the companion object for the VectorI class.
object VectorITest extends App
The VectorITest object tests the operations provided by VectorI.
The VectorITest object tests the operations provided by VectorI. > runMain scalation.linalgebra.VectorITest
object VectorL extends Serializable
The VectorL object is the companion object for the VectorL class.
object VectorLTest extends App
The VectorLTest object tests the operations provided by VectorL.
The VectorLTest object tests the operations provided by VectorL. > runMain scalation.linalgebra.VectorLTest
object VectorQ extends Serializable
The VectorQ object is the companion object for the VectorQ class.
object VectorQTest extends App
The VectorQTest object tests the operations provided by VectorQ.
The VectorQTest object tests the operations provided by VectorQ. > runMain scalation.linalgebra.VectorQTest
object VectorR extends Serializable
The VectorR object is the companion object for the VectorR class.
object VectorRTest extends App
The VectorRTest object tests the operations provided by VectorR.
The VectorRTest object tests the operations provided by VectorR. > runMain scalation.linalgebra.VectorRTest
object VectorS extends Serializable
The VectorS object is the companion object for the VectorS class.
object VectorSTest extends App
The VectorSTest object tests the operations provided by VectorS.
The VectorSTest object tests the operations provided by VectorS. > runMain scalation.linalgebra.VectorSTest
object VectorT extends Serializable
The VectorT object is the companion object for the VectorT class.
object VectorTTest extends App
The VectorTTest object tests the operations provided by VectorT.
The VectorTTest object tests the operations provided by VectorT. > runMain scalation.linalgebra.VectorTTest

Packages

linalgebra

package linalgebra

Type Members

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

linalgebra 

package linalgebra

Type Members

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

linalgebra