Packages

p

scalation

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
  1. Alphabetic
  2. By Inheritance
Inherited
  1. linalgebra
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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.

  7. 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


  8. 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


  9. trait Eigen extends AnyRef

    The Eigen trait defines constants used by classes and objects in the group.

  10. 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.

  11. 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.

  12. 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.

  13. 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'.

  14. 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.

  15. 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'.

  16. 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

  17. 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'. ------------------------------------------------------------------------------

  18. 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

    5.1 and 5.2 in Matrix Computations

    QRDecomposition.java in Jama

    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. -------------------------------------------------------------------------------

  19. 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

    5.1 and 5.2 in Matrix Computations

    QRDecomposition.java in Jama

    www.stat.wisc.edu/~larget/math496/qr.html

    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. ------------------------------------------------------------------------------

  20. 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

    5.1 and 5.2 in Matrix Computations

    QRDecomposition.java in Jama

    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 ------------------------------------------------------------------------------

  21. 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://www.stat.wisc.edu/~larget/math496/qr.html

    http://en.wikipedia.org/wiki/Gram–Schmidt_process (stabilized Gram–Schmidt orthonormalization)

  22. 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

    5.1 and 5.2 in Matrix Computations

    QRDecomposition.java in Jama

    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. -------------------------------------------------------------------------------

  23. trait Factorization extends AnyRef

    The Factorization trait is the template for classes implementing various forms of matrix factorization.

  24. type FunctionM2M = (MatrixD) ⇒ MatrixD
  25. type FunctionM_2M = (MatriD) ⇒ MatriD
  26. 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

  27. type FunctionV2V = (VectorD) ⇒ VectorD
  28. type FunctionV_2S = (VectoD) ⇒ Double
  29. type FunctionV_2V = (VectoD) ⇒ VectoD
  30. 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.

  31. 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.

  32. 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

  33. 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

  34. 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

  35. 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

  36. 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

  37. 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

  38. 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

  39. 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

  40. 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

  41. 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

  42. 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

  43. 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

  44. 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

  45. 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

  46. class MatrixS extends MatriS with Error with Serializable

    The MatrixS class stores and operates on Numeric Matrices of type StrNum.

    The MatrixS class stores and operates on Numeric Matrices of type StrNum. 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

  47. trait Pivoting extends AnyRef

    The Pivoting trait is used when row or column pivoting of a matrix is needed.

  48. 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.

  49. 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.

  50. 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.

  51. 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.

  52. 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.

  53. 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.

  54. class RleVectorC extends VectoC

    The RleVectorC class stores and operates on compressed Numeric Vectors of base type Complex.

  55. class RleVectorD extends VectoD

    The RleVectorD class stores and operates on compressed Numeric Vectors of base type Double.

  56. class RleVectorI extends VectoI

    The RleVectorI class stores and operates on compressed Numeric Vectors of base type Int.

  57. class RleVectorL extends VectoL

    The RleVectorL class stores and operates on compressed Numeric Vectors of base type Long.

  58. class RleVectorQ extends VectoQ

    The RleVectorQ class stores and operates on compressed Numeric Vectors of base type Rational.

  59. class RleVectorR extends VectoR

    The RleVectorR class stores and operates on compressed Numeric Vectors of base type Real.

  60. class RleVectorS extends VectoS

    The RleVectorS class stores and operates on compressed Numeric Vectors of base type StrNum.

  61. class RleVectorT extends VectoT

    The RleVectorT class stores and operates on compressed Numeric Vectors of base type TimeNum.

  62. 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

  63. 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. ------------------------------------------------------------------------------

  64. 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.

  65. 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

    "Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy,"

    J. Demmel and W. Kahan, LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. 11:5, pp. 873-912, Sept 1990)

    "Accurate singular values and differential qd algorithms," B. Parlett and V. Fernando,

    Technical Report CPAM-554, Mathematics Department, University of California at Berkeley, July 1992

    fortranwiki.org/fortran/show/svd

    LAPACK SUBROUTINE DBDSQR (UPLO, N, NCVT, NRU, NCC, D, E, VT, LDVT, U, LDU, C, LDC, WORK, INFO)

  66. 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 ------------------------------------------------------------------------------

  67. 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


  68. 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)


  69. 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

  70. 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.

  71. 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.

  72. 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.

  73. 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.

  74. 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.

  75. 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.

  76. 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.

  77. 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.

  78. 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.

  79. 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.

  80. 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.

  81. 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.

  82. 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.

  83. 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.

  84. 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.

  85. final class StatVec extends AnyVal

    The StatVec value class provides methods for computing statistics on data vectors.

    The StatVec value class provides methods for computing statistics on data vectors. Both maximum likelihood and unbiased estimators are supported. Unbiased should only be used on sample (not population) data. Ex: It can be used to support the Method of Independent Replications (MIR). For efficiency, StatVec is a value class that enriches the VectorD. The corresponding implicit conversion in the package object.

    See also

    stat.StatVector for more complete statistical functions

    stackoverflow.com/questions/14861862/how-do-you-enrich-value-classes-without-overhead -----------------------------------------------------------------------------

  86. 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.

  87. 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.

  88. 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.

  89. 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.

  90. 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.

  91. 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.

  92. 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.

  93. 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.

  94. 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.

  95. 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.

  96. 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.

  97. 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.

  98. 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.

  99. 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.

  100. trait Vec extends AnyRef

    The Vec trait establishes a common base type for all ScalaTion linalgebra vectors (e.g., VectorD, VectorI).

  101. 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.

  102. 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.

  103. 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.

  104. 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.

  105. 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.

  106. 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.

  107. 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.

  108. 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.

  109. 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.

  110. 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.

  111. 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.

  112. 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.

  113. 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.

  114. 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.

  115. 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.

  116. 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

  1. def complement(index: VectoI, n: Int): Array[Int]

    Return the complement of index array 'index', e.g., 'complement (Array (1, 3, 5), 6) = Array (0, 2, 4)'

    Return the complement of index array 'index', e.g., 'complement (Array (1, 3, 5), 6) = Array (0, 2, 4)'

    index

    the given index array

    n

    the number of elements given + complement

  2. def complement(index: Array[Int], n: Int): Array[Int]

    Return the complement of index array 'index', e.g., 'complement (Array (1, 3, 5), 6) = Array (0, 2, 4)'

    Return the complement of index array 'index', e.g., 'complement (Array (1, 3, 5), 6) = Array (0, 2, 4)'

    index

    the given index array

    n

    the number of elements given + complement

  3. 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

  4. implicit def vectorC2StatVec(x: VectorC): StatVec

    Implicit conversion from VectorD to StatVec, which supports more advanced statistical operations on vectors (e.g., covariance).

    Implicit conversion from VectorD to StatVec, which supports more advanced statistical operations on vectors (e.g., covariance). Other vector types require to conversion to VectorD via 'toDouble'. Caveat: won't work for vectors of string numbers (VectorS) since there not a meaningful conversion for general strings.

    x

    the vector to be enriched

  5. implicit def vectorD2StatVec(x: VectorD): StatVec
  6. implicit def vectorI2StatVec(x: VectorI): StatVec
  7. implicit def vectorL2StatVec(x: VectorL): StatVec
  8. implicit def vectorQ2StatVec(x: VectorQ): StatVec
  9. implicit def vectorR2StatVec(x: VectorR): StatVec
  10. implicit def vectorT2StatVec(x: VectorT): StatVec
  11. 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

  12. object BidMatrixC extends Error with Serializable

    The BidMatrixC object is the companion object for the BidMatrixC class.

  13. 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

  14. object BidMatrixD extends Error with Serializable

    The BidMatrixD object is the companion object for the BidMatrixD class.

  15. 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

  16. object BidMatrixI extends Error with Serializable

    The BidMatrixI object is the companion object for the BidMatrixI class.

  17. 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

  18. object BidMatrixL extends Error with Serializable

    The BidMatrixL object is the companion object for the BidMatrixL class.

  19. 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

  20. object BidMatrixQ extends Error with Serializable

    The BidMatrixQ object is the companion object for the BidMatrixQ class.

  21. 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

  22. object BidMatrixR extends Error with Serializable

    The BidMatrixR object is the companion object for the BidMatrixR class.

  23. 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

  24. 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

  25. 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

  26. 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

  27. object Converter

    The Converter object converts string number vectors to regular numeric vectors.

  28. 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

  29. 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

  30. object Eigen_2by2 extends Error

    The Eigen_2by2 object provides simple methods for computing eigenvalues and eigenvectors for 2-by-2 matrices.

  31. 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

  32. 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

  33. 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

  34. 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

  35. object Fac_LU extends Error

    The Fac_LU companion object provides functions related to LU Factorization.

  36. 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

  37. 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

  38. 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

  39. object Fac_QR
  40. 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.ee.ucla.edu/~vandenbe/103/lectures/qr.pdf

    www.math.usm.edu/lambers/mat610/sum10/lecture9.pdf FIX: the 'nullspaceV' function need to be fixed. > runMain scalation.linalgebra.Fac_QRTest

  41. 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

  42. 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.ee.ucla.edu/~vandenbe/103/lectures/qr.pdf

    www.math.usm.edu/lambers/mat610/sum10/lecture9.pdf FIX: the 'nullspaceV' function need to be fixed. > runMain scalation.linalgebra.Fac_QR_RRTest

  43. 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.

  44. 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

  45. object Householder

    The Householder object provides methods to compute Householder vectors and reflector matrices.

  46. 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

  47. 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.

  48. 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

  49. object MatrixCTest2 extends App

    The MatrixCTest2 object tests the equality and hashCode operations provided by MatrixC class.

    The MatrixCTest2 object tests the equality and hashCode operations provided by MatrixC class. > runMain scalation.linalgebra.MatrixCTest2

  50. 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.

  51. 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

  52. object MatrixDTest2 extends App

    The MatrixDTest2 object tests the equality and hashCode operations provided by MatrixD class.

    The MatrixDTest2 object tests the equality and hashCode operations provided by MatrixD class. > runMain scalation.linalgebra.MatrixDTest2

  53. 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.

  54. 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

  55. object MatrixITest2 extends App

    The MatrixITest2 object tests the equality and hashCode operations provided by MatrixI class.

    The MatrixITest2 object tests the equality and hashCode operations provided by MatrixI class. > runMain scalation.linalgebra.MatrixITest2

  56. 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).

  57. 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.

  58. 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

  59. object MatrixLTest2 extends App

    The MatrixLTest2 object tests the equality and hashCode operations provided by MatrixL class.

    The MatrixLTest2 object tests the equality and hashCode operations provided by MatrixL class. > runMain scalation.linalgebra.MatrixLTest2

  60. 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.

  61. 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

  62. object MatrixQTest2 extends App

    The MatrixQTest2 object tests the equality and hashCode operations provided by MatrixQ class.

    The MatrixQTest2 object tests the equality and hashCode operations provided by MatrixQ class. > runMain scalation.linalgebra.MatrixQTest2

  63. 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.

  64. 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

  65. object MatrixRTest2 extends App

    The MatrixRTest2 object tests the equality and hashCode operations provided by MatrixR class.

    The MatrixRTest2 object tests the equality and hashCode operations provided by MatrixR class. > runMain scalation.linalgebra.MatrixRTest2

  66. object MatrixS extends Error with Serializable

    The MatrixS companion object provides operations for MatrixS that don't require 'this' (like static methods in Java).

    The MatrixS companion object provides operations for MatrixS that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors.

  67. object MatrixSTest extends App

    The MatrixSTest object tests the operations provided by MatrixS class.

    The MatrixSTest object tests the operations provided by MatrixS class. > runMain scalation.linalgebra.MatrixSTest

  68. object MatrixSTest2 extends App

    The MatrixSTest2 object tests the equality and hashCode operations provided by MatrixS class.

    The MatrixSTest2 object tests the equality and hashCode operations provided by MatrixS class. > runMain scalation.linalgebra.MatrixSTest2

  69. 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

  70. 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.

  71. 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

  72. 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.

  73. 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

  74. 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.

  75. 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

  76. 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.

  77. 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

  78. 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.

  79. 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

  80. 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.

  81. 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

  82. object RleVectorC extends Serializable

    The RleVectorC object is the companion object for the RleVectorC class.

  83. 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

  84. object RleVectorD extends Serializable

    The RleVectorD object is the companion object for the RleVectorD class.

  85. 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

  86. object RleVectorI extends Serializable

    The RleVectorI object is the companion object for the RleVectorI class.

  87. 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

  88. object RleVectorL extends Serializable

    The RleVectorL object is the companion object for the RleVectorL class.

  89. 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

  90. object RleVectorQ extends Serializable

    The RleVectorQ object is the companion object for the RleVectorQ class.

  91. 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

  92. object RleVectorR extends Serializable

    The RleVectorR object is the companion object for the RleVectorR class.

  93. 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

  94. object RleVectorS extends Serializable

    The RleVectorS object is the companion object for the RleVectorS class.

  95. 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

  96. object RleVectorT extends Serializable

    The RleVectorT object is the companion object for the RleVectorT class.

  97. 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

  98. 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 cs2 + sn2 = 1 [ -sn cs ] [ g ] [ 0 ]

  99. object RotationTest extends App

    The RotationTest object is used to test the Rotation object, > runMain scalation.linalgebra.RotationTest

  100. 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

  101. 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

  102. 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

  103. 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

  104. 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

  105. 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

  106. 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

  107. 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

  108. 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/

  109. 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)

  110. object SVD4

    The SVD4 companion object.

  111. 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

  112. 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

  113. 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

    www.mathstat.uottawa.ca/~phofstra/MAT2342/SVDproblems.pdf

    mysite.science.uottawa.ca/phofstra/MAT2342/SVDproblems.pdf > runMain scalation.linalgebra.SVD4Test3

  114. 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

  115. 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

  116. 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

  117. 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

  118. object SVDImputed

    The SVDImputed companion object is used to perform imputation.

  119. 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

  120. 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

  121. 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

  122. 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

  123. 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

  124. 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

  125. 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

  126. 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

  127. 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

  128. 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

  129. object SVD_2by2Test extends App

    The SVD_2by2Test is used to test the SVD_2by2 class.

  130. 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.

  131. 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

  132. 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

  133. 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

  134. 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

  135. 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

  136. 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

  137. 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

  138. 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

  139. object SparseMatrixC extends Serializable

    The SparseMatrixC object is the companion object for the SparseMatrixC class.

  140. 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

  141. object SparseMatrixD extends Serializable

    The SparseMatrixD object is the companion object for the SparseMatrixD class.

  142. 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

  143. object SparseMatrixI extends Serializable

    The SparseMatrixI object is the companion object for the SparseMatrixI class.

  144. 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

  145. object SparseMatrixL extends Serializable

    The SparseMatrixL object is the companion object for the SparseMatrixL class.

  146. 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

  147. object SparseMatrixQ extends Serializable

    The SparseMatrixQ object is the companion object for the SparseMatrixQ class.

  148. 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

  149. object SparseMatrixR extends Serializable

    The SparseMatrixR object is the companion object for the SparseMatrixR class.

  150. 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

  151. object SparseVectorC extends Serializable

    The SparseVectorC object is the companion object for the SparseVectorC class.

  152. 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

  153. 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

  154. object SparseVectorD extends Serializable

    The SparseVectorD object is the companion object for the SparseVectorD class.

  155. 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

  156. 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

  157. object SparseVectorI extends Serializable

    The SparseVectorI object is the companion object for the SparseVectorI class.

  158. 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

  159. 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

  160. object SparseVectorL extends Serializable

    The SparseVectorL object is the companion object for the SparseVectorL class.

  161. 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

  162. 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

  163. object SparseVectorQ extends Serializable

    The SparseVectorQ object is the companion object for the SparseVectorQ class.

  164. 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

  165. 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

  166. object SparseVectorR extends Serializable

    The SparseVectorR object is the companion object for the SparseVectorR class.

  167. 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

  168. 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

  169. object SparseVectorS extends Serializable

    The SparseVectorS object is the companion object for the SparseVectorS class.

  170. 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

  171. 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

  172. object SparseVectorT extends Serializable

    The SparseVectorT object is the companion object for the SparseVectorT class.

  173. 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

  174. 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

  175. object StatVecTest extends App

    The StatVecTest object is used to test the StatVec class.

    The StatVecTest object is used to test the StatVec class. > runMain scalation.linalgebra.StatVecTest

  176. object SymTriMatrixC extends Error with Serializable

    The SymTriMatrixC object is the companion object for the SymTriMatrixC class.

  177. 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

  178. object SymTriMatrixD extends Error with Serializable

    The SymTriMatrixD object is the companion object for the SymTriMatrixD class.

  179. 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

  180. object SymTriMatrixI extends Error with Serializable

    The SymTriMatrixI object is the companion object for the SymTriMatrixI class.

  181. 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

  182. object SymTriMatrixL extends Error with Serializable

    The SymTriMatrixL object is the companion object for the SymTriMatrixL class.

  183. 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

  184. object SymTriMatrixQ extends Error with Serializable

    The SymTriMatrixQ object is the companion object for the SymTriMatrixQ class.

  185. 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

  186. object SymTriMatrixR extends Error with Serializable

    The SymTriMatrixR object is the companion object for the SymTriMatrixR class.

  187. 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

  188. 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

    Algorithm 8.3.2 in Matrix Computations.

    http://people.inf.ethz.ch/arbenz/ewp/Lnotes/chapter3.pdf (Algorithm 3.6)

  189. 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

  190. object Vec_Elem

    The Vec_Elem object provides comparison operators for Vec elements.

  191. object VectorC extends Serializable

    The VectorC object is the companion object for the VectorC class.

  192. 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

  193. object VectorD extends Serializable

    The VectorD object is the companion object for the VectorD class.

  194. 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

  195. object VectorI extends Serializable

    The VectorI object is the companion object for the VectorI class.

  196. 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

  197. object VectorL extends Serializable

    The VectorL object is the companion object for the VectorL class.

  198. 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

  199. object VectorQ extends Serializable

    The VectorQ object is the companion object for the VectorQ class.

  200. 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

  201. object VectorR extends Serializable

    The VectorR object is the companion object for the VectorR class.

  202. 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

  203. object VectorS extends Serializable

    The VectorS object is the companion object for the VectorS class.

  204. 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

  205. object VectorT extends Serializable

    The VectorT object is the companion object for the VectorT class.

  206. 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

Inherited from AnyRef

Inherited from Any

Ungrouped