package linalgebra
The linalgebra
package contains classes, traits and objects for
linear algebra, including vectors and matrices for real and complex numbers.
- Alphabetic
- By Inheritance
- linalgebra
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
class
BidMatrixC
extends MatriC with Error with Serializable
The
BidMatrixC
class stores and operates on square (upper) bidiagonal matrices.The
BidMatrixC
class stores and operates on square (upper) bidiagonal matrices. The elements are of type ofComplex
. A matrix is stored as two vectors: the diagonal vector and the sup-diagonal vector. -
class
BidMatrixD
extends MatriD with Error with Serializable
The
BidMatrixD
class stores and operates on square (upper) bidiagonal matrices.The
BidMatrixD
class stores and operates on square (upper) bidiagonal matrices. The elements are of type ofDouble
. A matrix is stored as two vectors: the diagonal vector and the sup-diagonal vector. -
class
BidMatrixI
extends MatriI with Error with Serializable
The
BidMatrixI
class stores and operates on square (upper) bidiagonal matrices.The
BidMatrixI
class stores and operates on square (upper) bidiagonal matrices. The elements are of type ofInt
. A matrix is stored as two vectors: the diagonal vector and the sup-diagonal vector. -
class
BidMatrixL
extends MatriL with Error with Serializable
The
BidMatrixL
class stores and operates on square (upper) bidiagonal matrices.The
BidMatrixL
class stores and operates on square (upper) bidiagonal matrices. The elements are of type ofLong
. A matrix is stored as two vectors: the diagonal vector and the sup-diagonal vector. -
class
BidMatrixQ
extends MatriQ with Error with Serializable
The
BidMatrixQ
class stores and operates on square (upper) bidiagonal matrices.The
BidMatrixQ
class stores and operates on square (upper) bidiagonal matrices. The elements are of type ofRational
. A matrix is stored as two vectors: the diagonal vector and the sup-diagonal vector. -
class
BidMatrixR
extends MatriR with Error with Serializable
The
BidMatrixR
class stores and operates on square (upper) bidiagonal matrices.The
BidMatrixR
class stores and operates on square (upper) bidiagonal matrices. The elements are of type ofReal
. A matrix is stored as two vectors: the diagonal vector and the sup-diagonal vector. -
class
Bidiagonal
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 thatu.t * a * v = b a = u * b * v.t
where matrix 'b' is bidiagonal, i.e., it will only have non-zero elements on its main diagonal and its super-diagonal (the diagonal above the main).
u is an m-by-n matrix b is an n-by-n matrix (bidiagonal - FIX: use
BidMatrixD
) v is an n-by-n matrix -
class
Bidiagonal2
extends Error
The
Bidiagonal2
class is used to creates a bidiagonal matrix for matrix 'a'.The
Bidiagonal2
class is used to creates a bidiagonal matrix for matrix 'a'. It uses the Householder Bidiagonalization Algorithm to compute orthogonal matrices 'u' and 'v' such thatu.t * a * v = b a = u * b * v.t
where matrix 'b' is bidiagonal, i.e, it will only have non-zero elements on its main diagonal and its super-diagonal (the diagonal above the main).
u is an m-by-n matrix b is an n-by-n matrix (bidiagonal - FIX: use
BidMatrixD
) v is an n-by-n matrix -
trait
Eigen
extends AnyRef
The
Eigen
trait defines constants used by classes and objects in the group. -
class
Eigenvalue
extends Eigen with Error
The
Eigenvalue
class is used to find the eigenvalues of an 'n' by 'n' matrix 'a' using an iterative technique that applies similarity transformations to convert 'a' into an upper triangular matrix, so that the eigenvalues appear along the diagonal.The
Eigenvalue
class is used to find the eigenvalues of an 'n' by 'n' matrix 'a' using an iterative technique that applies similarity transformations to convert 'a' into an upper triangular matrix, so that the eigenvalues appear along the diagonal. To improve performance, the 'a' matrix is first reduced to Hessenburg form. During the iterative steps, a shifted 'QR' decomposition is performed. Caveats: (1) it will not handle eigenvalues that are complex numbers, (2) it uses a simple shifting strategy that may slow convergence. -
class
EigenvalueSym
extends Eigen with Error
The
EigenvalueSym
class is used to find the eigenvalues of an 'n' by 'n' symmetric matrix 'a' using an iterative technique, the Symmetric 'QR' Algorithm.The
EigenvalueSym
class is used to find the eigenvalues of an 'n' by 'n' symmetric matrix 'a' using an iterative technique, the Symmetric 'QR' Algorithm.- See also
Algorithm 8.3.3 in Matrix Computations. Caveats: (1) it will not handle eigenvalues that are complex numbers, (2) it uses a simple shifting strategy that may slow convergence.
-
class
Eigenvector
extends Eigen with Error
The
Eigenvector
class is used to find the eigenvectors of an 'n' by 'n' matrix 'a' by solving equations of the formThe
Eigenvector
class is used to find the eigenvectors of an 'n' by 'n' matrix 'a' by solving equations of the form(a - eI)v = 0
where 'e' is the eigenvalue and 'v' is the eigenvector. Place the eigenvectors in a matrix column-wise.
-
class
Fac_Cholesky
[MatT <: MatriD] extends Factorization with Error
The
Fac_Cholesky
class provides methods to factor an 'n-by-n' symmetric, positive definite matrix 'a' into the product of two matrices:The
Fac_Cholesky
class provides methods to factor an 'n-by-n' symmetric, positive definite matrix 'a' into the product of two matrices:'l' - an 'n-by-n' left lower triangular matrix 'l.t' - an 'n-by-n' right upper triangular matrix - transpose of 'l'
such that 'a = l * l.t'.
-
class
Fac_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'.
-
abstract
class
Fac_QR
[MatT <: MatriD] extends Factorization with Error
The
Fac_QR
abstarct class provides base methods to factor an 'm-by-n' matrix 'aa' into the product of two matrices:The
Fac_QR
abstarct class provides base methods to factor an 'm-by-n' matrix 'aa' into the product of two matrices:'q' - an 'm-by-n' orthogonal matrix and 'r' - an 'n-by-n' right upper triangular matrix
such that 'aa = q * r'. ------------------------------------------------------------------------------
-
class
Fac_QR_H
[MatT <: MatriD] extends Fac_QR[MatT]
The
Fac_QR_H
class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:The
Fac_QR_H
class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:'q' - an 'm-by-n' orthogonal matrix and 'r' - an 'n-by-n' right upper triangular matrix
such that 'a = q * r'. It uses uses Householder orthogonalization.
- See also
www.stat.wisc.edu/~larget/math496/qr.html ------------------------------------------------------------------------------- This implementation improves upon
Fac_QR_H2
by working with the transpose the original matrix and reorders operations to facilitate parallelism (see par directory). Caveat: for m < n useFac_LQ
. -------------------------------------------------------------------------------QRDecomposition.java in Jama
5.1 and 5.2 in Matrix Computations
-
class
Fac_QR_H2
[MatT <: MatriD] extends Fac_QR[MatT]
The
Fac_QR_H2
class provides methods to factor an 'm-by-n' matrix 'aa' into the product of two matrices:The
Fac_QR_H2
class provides methods to factor an 'm-by-n' matrix 'aa' into the product of two matrices:'q' - an 'm-by-n' orthogonal matrix and 'r' - an 'n-by-n' right upper triangular matrix
such that 'a = q * r'. It uses Householder orthogonalization.
- See also
math.stackexchange.com/questions/678843/householder-qr-factorization-for-m-by-n-matrix-both-m-n-and-mn ------------------------------------------------------------------------------ This implementation replaces matrix operations in
Fac_QR_H3
with low-level operations for greater efficiency. Also, calculates Householder vectors differently. Caveat: for m < n useFac_LQ
. ------------------------------------------------------------------------------www.stat.wisc.edu/~larget/math496/qr.html
QRDecomposition.java in Jama
5.1 and 5.2 in Matrix Computations
-
class
Fac_QR_H3
extends Fac_QR[MatrixD]
The
Fac_QR_H3
class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:The
Fac_QR_H3
class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:'q' - an 'm-by-n' orthogonal matrix and 'r' - an 'n-by-n' right upper triangular matrix
such that 'a = q * r'. It uses Householder orthogonalization. Note, orthogonal means that 'q.t * q = I'.
- See also
www.stat.wisc.edu/~larget/math496/qr.html ------------------------------------------------------------------------------ This implementation is the easiest to understandard, but the least efficient. Caveat: for m < n use
Fac_LQ
. FIX: change 'aa: MatrixD' to 'aa: MatriD', requires 'times_ip_pre' in trait ------------------------------------------------------------------------------QRDecomposition.java in Jama
5.1 and 5.2 in Matrix Computations
-
class
Fac_QR_MGS
extends Fac_QR[MatrixD]
The
Fac_QR_MGS
class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:The
Fac_QR_MGS
class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:'q' - an 'm-by-n' orthogonal matrix and 'r' - an 'n-by-n' right upper triangular matrix
such that 'a = q * r'. It uses Modified Gram-Schmidt (MGS) orthogonalization. Note, orthogonal means that 'q.t * q = I'.
- See also
http://en.wikipedia.org/wiki/Gram–Schmidt_process (stabilized Gram–Schmidt orthonormalization)
http://www.stat.wisc.edu/~larget/math496/qr.html
-
class
Fac_QR_RR
[MatT <: MatriD] extends Fac_QR_H[MatT] with Pivoting
The
Fac_QR_RR
class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:The
Fac_QR_RR
class provides methods to factor an 'm-by-n' matrix 'a' into the product of two matrices:'q' - an 'm-by-n' orthogonal matrix and 'r' - an 'n-by-n' right upper triangular matrix
such that 'a = q * r'. It uses uses Householder orthogonalization.
- See also
www.stat.wisc.edu/~larget/math496/qr.html ------------------------------------------------------------------------------- This implementation extends
Fac_QR_H
and adds column pivoting for greater robustness and resonably accurate rank determination (Rank Revealing QR). Caveat: for m < n useFac_LQ
. -------------------------------------------------------------------------------QRDecomposition.java in Jama
5.1 and 5.2 in Matrix Computations
-
trait
Factorization
extends AnyRef
The
Factorization
trait is the template for classes implementing various forms of matrix factorization. -
class
Hessenburg
extends Eigen with Error
The
Hessenburg
class is used to reduce, via similarity transformations, an 'n' by 'n' matrix 'a' to Hessenburg form 'h', where all elements two below the main diagonal are zero (or close to zero).The
Hessenburg
class is used to reduce, via similarity transformations, an 'n' by 'n' matrix 'a' to Hessenburg form 'h', where all elements two below the main diagonal are zero (or close to zero). Note, similarity transformations do not changes the eigenvalues. -
class
HouseholderT
extends Eigen with Error
The
HouseholderT
class performs a Householder Tridiagonalization on a symmetric matrix.The
HouseholderT
class performs a Householder Tridiagonalization on a symmetric matrix.- See also
Algorithm 8.3.1 in Matrix Computations.
-
trait
MatriC
extends Error
The
MatriC
trait specifies the operations to be defined by the concrete classes implementingComplex
matrices, i.e.,MatrixC
- dense matrixBidMatrixC
- bidiagonal matrix - useful for computing Singular ValuesSparseMatrixC
- sparse matrix - majority of elements should be zeroSymTriMatrixC
- symmetric triangular matrix - useful for computing Eigenvaluespar.MatrixC
- parallel dense matrixpar.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 implementingComplex
matrices, i.e.,MatrixC
- dense matrixBidMatrixC
- bidiagonal matrix - useful for computing Singular ValuesSparseMatrixC
- sparse matrix - majority of elements should be zeroSymTriMatrixC
- symmetric triangular matrix - useful for computing Eigenvaluespar.MatrixC
- parallel dense matrixpar.SparseMatrixC
- parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'. ------------------------------------------------------------------------------ row-wise column-wise Prepend: vector +: matrix vector +: matrix (right associative) Append: matrix :+ vector matrix :+ vector Concatenate: matrix ++ matrix matrix ++^ matrix -
trait
MatriD
extends Error
The
MatriD
trait specifies the operations to be defined by the concrete classes implementingDouble
matrices, i.e.,MatrixD
- dense matrixBidMatrixD
- bidiagonal matrix - useful for computing Singular ValuesSparseMatrixD
- sparse matrix - majority of elements should be zeroSymTriMatrixD
- symmetric triangular matrix - useful for computing Eigenvaluespar.MatrixD
- parallel dense matrixpar.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 implementingDouble
matrices, i.e.,MatrixD
- dense matrixBidMatrixD
- bidiagonal matrix - useful for computing Singular ValuesSparseMatrixD
- sparse matrix - majority of elements should be zeroSymTriMatrixD
- symmetric triangular matrix - useful for computing Eigenvaluespar.MatrixD
- parallel dense matrixpar.SparseMatrixD
- parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'. ------------------------------------------------------------------------------ row-wise column-wise Prepend: vector +: matrix vector +: matrix (right associative) Append: matrix :+ vector matrix :+ vector Concatenate: matrix ++ matrix matrix ++^ matrix -
trait
MatriI
extends Error
The
MatriI
trait specifies the operations to be defined by the concrete classes implementingInt
matrices, i.e.,MatrixI
- dense matrixBidMatrixI
- bidiagonal matrix - useful for computing Singular ValuesSparseMatrixI
- sparse matrix - majority of elements should be zeroSymTriMatrixI
- symmetric triangular matrix - useful for computing Eigenvaluespar.MatrixI
- parallel dense matrixpar.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 implementingInt
matrices, i.e.,MatrixI
- dense matrixBidMatrixI
- bidiagonal matrix - useful for computing Singular ValuesSparseMatrixI
- sparse matrix - majority of elements should be zeroSymTriMatrixI
- symmetric triangular matrix - useful for computing Eigenvaluespar.MatrixI
- parallel dense matrixpar.SparseMatrixI
- parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'. ------------------------------------------------------------------------------ row-wise column-wise Prepend: vector +: matrix vector +: matrix (right associative) Append: matrix :+ vector matrix :+ vector Concatenate: matrix ++ matrix matrix ++^ matrix -
trait
MatriL
extends Error
The
MatriL
trait specifies the operations to be defined by the concrete classes implementingLong
matrices, i.e.,MatrixL
- dense matrixBidMatrixL
- bidiagonal matrix - useful for computing Singular ValuesSparseMatrixL
- sparse matrix - majority of elements should be zeroSymTriMatrixL
- symmetric triangular matrix - useful for computing Eigenvaluespar.MatrixL
- parallel dense matrixpar.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 implementingLong
matrices, i.e.,MatrixL
- dense matrixBidMatrixL
- bidiagonal matrix - useful for computing Singular ValuesSparseMatrixL
- sparse matrix - majority of elements should be zeroSymTriMatrixL
- symmetric triangular matrix - useful for computing Eigenvaluespar.MatrixL
- parallel dense matrixpar.SparseMatrixL
- parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'. ------------------------------------------------------------------------------ row-wise column-wise Prepend: vector +: matrix vector +: matrix (right associative) Append: matrix :+ vector matrix :+ vector Concatenate: matrix ++ matrix matrix ++^ matrix -
trait
MatriQ
extends Error
The
MatriQ
trait specifies the operations to be defined by the concrete classes implementingRational
matrices, i.e.,MatrixQ
- dense matrixBidMatrixQ
- bidiagonal matrix - useful for computing Singular ValuesSparseMatrixQ
- sparse matrix - majority of elements should be zeroSymTriMatrixQ
- symmetric triangular matrix - useful for computing Eigenvaluespar.MatrixQ
- parallel dense matrixpar.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 implementingRational
matrices, i.e.,MatrixQ
- dense matrixBidMatrixQ
- bidiagonal matrix - useful for computing Singular ValuesSparseMatrixQ
- sparse matrix - majority of elements should be zeroSymTriMatrixQ
- symmetric triangular matrix - useful for computing Eigenvaluespar.MatrixQ
- parallel dense matrixpar.SparseMatrixQ
- parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'. ------------------------------------------------------------------------------ row-wise column-wise Prepend: vector +: matrix vector +: matrix (right associative) Append: matrix :+ vector matrix :+ vector Concatenate: matrix ++ matrix matrix ++^ matrix -
trait
MatriR
extends Error
The
MatriR
trait specifies the operations to be defined by the concrete classes implementingReal
matrices, i.e.,MatrixR
- dense matrixBidMatrixR
- bidiagonal matrix - useful for computing Singular ValuesSparseMatrixR
- sparse matrix - majority of elements should be zeroSymTriMatrixR
- symmetric triangular matrix - useful for computing Eigenvaluespar.MatrixR
- parallel dense matrixpar.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 implementingReal
matrices, i.e.,MatrixR
- dense matrixBidMatrixR
- bidiagonal matrix - useful for computing Singular ValuesSparseMatrixR
- sparse matrix - majority of elements should be zeroSymTriMatrixR
- symmetric triangular matrix - useful for computing Eigenvaluespar.MatrixR
- parallel dense matrixpar.SparseMatrixR
- parallel sparse matrix Some of the classes provide a few custom methods, e.g., methods beginning with "times" or ending with 'npp'. ------------------------------------------------------------------------------ row-wise column-wise Prepend: vector +: matrix vector +: matrix (right associative) Append: matrix :+ vector matrix :+ vector Concatenate: matrix ++ matrix matrix ++^ matrix -
trait
MatriS
extends Error
The
MatriS
trait specifies the operations to be defined by the concrete classes implementingStrNum
matrices, i.e.,MatrixS
- dense matrixBidMatrixS
- bidiagonal matrix - useful for computing Singular ValuesSparseMatrixS
- sparse matrix - majority of elements should be zeroSymTriMatrixS
- symmetric triangular matrix - useful for computing Eigenvaluespar.MatrixS
- parallel dense matrixpar.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 implementingStrNum
matrices, i.e.,MatrixS
- dense matrixBidMatrixS
- bidiagonal matrix - useful for computing Singular ValuesSparseMatrixS
- sparse matrix - majority of elements should be zeroSymTriMatrixS
- symmetric triangular matrix - useful for computing Eigenvaluespar.MatrixS
- parallel dense matrixpar.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 -
class
MatrixC
extends MatriC with Error with Serializable
The
MatrixC
class stores and operates on Numeric Matrices of typeComplex
.The
MatrixC
class stores and operates on Numeric Matrices of typeComplex
. This class follows thegen.MatrixN
framework and is provided for efficiency. Caveat: Only works for rectangular matrices. For matrix-like structures based on jagged arrays, where the second dimension varies,- See also
scalation.linalgebra.gen.HMatrix2
-
class
MatrixD
extends MatriD with Error with Serializable
The
MatrixD
class stores and operates on Numeric Matrices of typeDouble
.The
MatrixD
class stores and operates on Numeric Matrices of typeDouble
. This class follows thegen.MatrixN
framework and is provided for efficiency. Caveat: Only works for rectangular matrices. For matrix-like structures based on jagged arrays, where the second dimension varies,- See also
scalation.linalgebra.gen.HMatrix2
-
class
MatrixI
extends MatriI with Error with Serializable
The
MatrixI
class stores and operates on Numeric Matrices of typeInt
.The
MatrixI
class stores and operates on Numeric Matrices of typeInt
. This class follows thegen.MatrixN
framework and is provided for efficiency. Caveat: Only works for rectangular matrices. For matrix-like structures based on jagged arrays, where the second dimension varies,- See also
scalation.linalgebra.gen.HMatrix2
-
class
MatrixL
extends MatriL with Error with Serializable
The
MatrixL
class stores and operates on Numeric Matrices of typeLong
.The
MatrixL
class stores and operates on Numeric Matrices of typeLong
. This class follows thegen.MatrixN
framework and is provided for efficiency. Caveat: Only works for rectangular matrices. For matrix-like structures based on jagged arrays, where the second dimension varies,- See also
scalation.linalgebra.gen.HMatrix2
-
class
MatrixQ
extends MatriQ with Error with Serializable
The
MatrixQ
class stores and operates on Numeric Matrices of typeRational
.The
MatrixQ
class stores and operates on Numeric Matrices of typeRational
. This class follows thegen.MatrixN
framework and is provided for efficiency. Caveat: Only works for rectangular matrices. For matrix-like structures based on jagged arrays, where the second dimension varies,- See also
scalation.linalgebra.gen.HMatrix2
-
class
MatrixR
extends MatriR with Error with Serializable
The
MatrixR
class stores and operates on Numeric Matrices of typeReal
.The
MatrixR
class stores and operates on Numeric Matrices of typeReal
. This class follows thegen.MatrixN
framework and is provided for efficiency. Caveat: Only works for rectangular matrices. For matrix-like structures based on jagged arrays, where the second dimension varies,- See also
scalation.linalgebra.gen.HMatrix2
-
trait
Pivoting
extends AnyRef
The
Pivoting
trait is used when row or column pivoting of a matrix is needed. -
class
RleMatrixC
extends MatriC with Error with Serializable
The
RleMatrixC
class stores and operates on Numeric Matrices of typeComplex
.The
RleMatrixC
class stores and operates on Numeric Matrices of typeComplex
. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of RleVectorC's. -
class
RleMatrixD
extends MatriD with Error with Serializable
The
RleMatrixD
class stores and operates on Numeric Matrices of typeDouble
.The
RleMatrixD
class stores and operates on Numeric Matrices of typeDouble
. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of RleVectorD's. -
class
RleMatrixI
extends MatriI with Error with Serializable
The
RleMatrixI
class stores and operates on Numeric Matrices of typeInt
.The
RleMatrixI
class stores and operates on Numeric Matrices of typeInt
. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of RleVectorI's. -
class
RleMatrixL
extends MatriL with Error with Serializable
The
RleMatrixL
class stores and operates on Numeric Matrices of typeLong
.The
RleMatrixL
class stores and operates on Numeric Matrices of typeLong
. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of RleVectorL's. -
class
RleMatrixQ
extends MatriQ with Error with Serializable
The
RleMatrixQ
class stores and operates on Numeric Matrices of typeRational
.The
RleMatrixQ
class stores and operates on Numeric Matrices of typeRational
. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of RleVectorQ's. -
class
RleMatrixR
extends MatriR with Error with Serializable
The
RleMatrixR
class stores and operates on Numeric Matrices of typeReal
.The
RleMatrixR
class stores and operates on Numeric Matrices of typeReal
. Rather than storing the matrix as a 2 dimensional array, it is stored as an array of RleVectorR's. -
class
RleVectorC
extends VectoC
The
RleVectorC
class stores and operates on compressed Numeric Vectors of base typeComplex
. -
class
RleVectorD
extends VectoD
The
RleVectorD
class stores and operates on compressed Numeric Vectors of base typeDouble
. -
class
RleVectorI
extends VectoI
The
RleVectorI
class stores and operates on compressed Numeric Vectors of base typeInt
. -
class
RleVectorL
extends VectoL
The
RleVectorL
class stores and operates on compressed Numeric Vectors of base typeLong
. -
class
RleVectorQ
extends VectoQ
The
RleVectorQ
class stores and operates on compressed Numeric Vectors of base typeRational
. -
class
RleVectorR
extends VectoR
The
RleVectorR
class stores and operates on compressed Numeric Vectors of base typeReal
. -
class
RleVectorS
extends VectoS
The
RleVectorS
class stores and operates on compressed Numeric Vectors of base typeStrNum
. -
case class
Rotation
(cs: Double, sn: Double, r: Double) extends Product with Serializable
The
Rotation
class is a data structure for holding the results of rotating by angle a.The
Rotation
class is a data structure for holding the results of rotating by angle a.- cs
the cos (a)
- sn
the sin (a)
- r
the nonzero element of the rotated vector
-
class
SVD
extends SVDecomp with Error
The
SVD
class is used to compute the Singular Value Decomposition 'SVD' of matrix 'a' using the Golub-Kahan-Reinsch Algorithm.The
SVD
class is used to compute the Singular Value Decomposition 'SVD' of matrix 'a' using the Golub-Kahan-Reinsch Algorithm. Factor/decompose matrix 'a' into the product of three matrices:a = u * q * v.t where u is an m-by-n matrix of orthogonal eigenvectors of 'a * a.t' (LEFT SINGULAR VECTORS) q is an n-by-n diagonal matrix of square roots of eigenvalues of 'a.t * a' & 'a * a.t' (SINGULAR VALUES) v is an n-by-n matrix of orthogonal eigenvectors of 'a.t * a' (RIGHT SINGULAR VECTORS)
The SVD algorithm implemented is based on plane rotations. It involves transforming the input matrix to its Bidiagonal form using the Householder transformation procedure. The Bidiagonal matrix is then used to obtain singular values using the QR algorithm. ------------------------------------------------------------------------------
-
class
SVD2
extends SVDecomp
The
SVD2
class performs Single Value Decomposition 'SVD' using theEigen
class.The
SVD2
class performs Single Value Decomposition 'SVD' using theEigen
class. For a direct, more robust algorithm that is less sensitive to round-off errors,- See also
the
SVD
class.
-
class
SVD3
extends SVDecomp
The
SVD3
class is used to solve Singular Value Decomposition for bidiagonal matrices.The
SVD3
class is used to solve Singular Value Decomposition for bidiagonal matrices.It computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition 'SVD' of a real n-by-n (upper) bidiagonal matrix B using the implicit zero-shift 'QR' algorithm. The 'SVD' of B has the form
B = Q * S * P.t
where S is the diagonal matrix of singular values, Q is an orthogonal matrix of left singular vectors, and P is an orthogonal matrix of right singular vectors. If left singular vectors are requested, this subroutine actually returns U*Q instead of Q, and, if right singular vectors are requested, this subroutine returns P.t * VT instead of P.T, for given real input matrices U and VT. When U and VT are the orthogonal matrices that reduce a general matrix A to bidiagonal form: A = U*B*VT, as computed by DGEBRD, then
A = (U*Q) * S * (P.t*VT)
is the 'SVD' of the general matrix A. A positive tolerance 'TOL' gives relative accuracy; for absolute accuracy negate it.
- See also
LAPACK SUBROUTINE DBDSQR (UPLO, N, NCVT, NRU, NCC, D, E, VT, LDVT, U, LDU, C, LDC, WORK, INFO)
fortranwiki.org/fortran/show/svd
Technical Report CPAM-554, Mathematics Department, University of California at Berkeley, July 1992
"Accurate singular values and differential qd algorithms," B. Parlett and V. Fernando,
J. Demmel and W. Kahan, LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. 11:5, pp. 873-912, Sept 1990)
"Computing Small Singular Values of Bidiagonal Matrices With Guaranteed High Relative Accuracy,"
-
class
SVD4
extends SVDecomp with Error
The
SVD4
class is used to compute the Singular Value Decomposition 'SVD' of matrix 'aa' using the Golub-Kahan-Reinsch Algorithm.The
SVD4
class is used to compute the Singular Value Decomposition 'SVD' of matrix 'aa' using the Golub-Kahan-Reinsch Algorithm. Factor/decompose matrix 'aa' into the product of three matrices:aa = uu * a * vv.t
where 'uu' is a matrix of orthogonal eigenvectors of 'aa * aa.t' (LEFT SINGULAR VECTORS) 'vv' is a matrix of orthogonal eigenvectors of 'aa.t * aa' (RIGHT SINGULAR VECTORS) and 'a' is a diagonal matrix of square roots of eigenvalues of 'aa.t * aa' & 'aa * aa.t' (SINGULAR VALUES). FIX: need to reorder so singular values are in decreasing order. FIX: make the singular values positive ------------------------------------------------------------------------------
-
class
SVD_2by2
extends SVDecomp
The
SVD_2by2
is used to solve Singular Value Decomposition for bidiagonal 2-by-2 matrices.The
SVD_2by2
is used to solve Singular Value Decomposition for bidiagonal 2-by-2 matrices.[ f g ] [ 0 h ]
- See also
fortranwiki.org/fortran/show/svd
-
trait
SVDecomp
extends AnyRef
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 useEigenvalue
andEigenvector
SVD3 - Implicit Zero-Shift 'QR' Algorithm SVD4 - Golub-Kahan-Reinsch Algorithm coded from psuedo-code in Matrix Computations The last three are still under development. -
class
SparseMatrixC
extends MatriC with Error with Serializable
The
SparseMatrixC
class stores and operates on Matrices ofComplex
s.The
SparseMatrixC
class stores and operates on Matrices ofComplex
s. 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. Note: '_npp' versions of methods are not appropriate for sparse matrices (i.e., always use partial pivoting). -
class
SparseMatrixD
extends MatriD with Error with Serializable
The
SparseMatrixD
class stores and operates on Matrices ofDouble
s.The
SparseMatrixD
class stores and operates on Matrices ofDouble
s. 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. Note: '_npp' versions of methods are not appropriate for sparse matrices (i.e., always use partial pivoting). -
class
SparseMatrixI
extends MatriI with Error with Serializable
The
SparseMatrixI
class stores and operates on Matrices ofInt
s.The
SparseMatrixI
class stores and operates on Matrices ofInt
s. 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. Note: '_npp' versions of methods are not appropriate for sparse matrices (i.e., always use partial pivoting). -
class
SparseMatrixL
extends MatriL with Error with Serializable
The
SparseMatrixL
class stores and operates on Matrices ofLong
s.The
SparseMatrixL
class stores and operates on Matrices ofLong
s. 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. Note: '_npp' versions of methods are not appropriate for sparse matrices (i.e., always use partial pivoting). -
class
SparseMatrixQ
extends MatriQ with Error with Serializable
The
SparseMatrixQ
class stores and operates on Matrices ofRational
s.The
SparseMatrixQ
class stores and operates on Matrices ofRational
s. 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. Note: '_npp' versions of methods are not appropriate for sparse matrices (i.e., always use partial pivoting). -
class
SparseMatrixR
extends MatriR with Error with Serializable
The
SparseMatrixR
class stores and operates on Matrices ofReal
s.The
SparseMatrixR
class stores and operates on Matrices ofReal
s. 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. Note: '_npp' versions of methods are not appropriate for sparse matrices (i.e., always use partial pivoting). -
class
SparseVectorC
extends VectoC
The
SparseVectorC
class stores and operates on Numeric Vectors of base typeComplex
.The
SparseVectorC
class stores and operates on Numeric Vectors of base typeComplex
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
class
SparseVectorD
extends VectoD
The
SparseVectorD
class stores and operates on Numeric Vectors of base typeDouble
.The
SparseVectorD
class stores and operates on Numeric Vectors of base typeDouble
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
class
SparseVectorI
extends VectoI
The
SparseVectorI
class stores and operates on Numeric Vectors of base typeInt
.The
SparseVectorI
class stores and operates on Numeric Vectors of base typeInt
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
class
SparseVectorL
extends VectoL
The
SparseVectorL
class stores and operates on Numeric Vectors of base typeLong
.The
SparseVectorL
class stores and operates on Numeric Vectors of base typeLong
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
class
SparseVectorQ
extends VectoQ
The
SparseVectorQ
class stores and operates on Numeric Vectors of base typeRational
.The
SparseVectorQ
class stores and operates on Numeric Vectors of base typeRational
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
class
SparseVectorR
extends VectoR
The
SparseVectorR
class stores and operates on Numeric Vectors of base typeReal
.The
SparseVectorR
class stores and operates on Numeric Vectors of base typeReal
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
class
SparseVectorS
extends VectoS
The
SparseVectorS
class stores and operates on Numeric Vectors of base typeStrNum
.The
SparseVectorS
class stores and operates on Numeric Vectors of base typeStrNum
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
class
SymTriMatrixC
extends MatriC with Error with Serializable
The
SymTriMatrixC
class stores and operates on symmetric tridiagonal matrices.The
SymTriMatrixC
class stores and operates on symmetric tridiagonal matrices. The elements are of type ofComplex
. A matrix is stored as two vectors: the diagonal vector and the sub-diagonal vector. -
class
SymTriMatrixD
extends MatriD with Error with Serializable
The
SymTriMatrixD
class stores and operates on symmetric tridiagonal matrices.The
SymTriMatrixD
class stores and operates on symmetric tridiagonal matrices. The elements are of type ofDouble
. A matrix is stored as two vectors: the diagonal vector and the sub-diagonal vector. -
class
SymTriMatrixI
extends MatriI with Error with Serializable
The
SymTriMatrixI
class stores and operates on symmetric tridiagonal matrices.The
SymTriMatrixI
class stores and operates on symmetric tridiagonal matrices. The elements are of type ofInt
. A matrix is stored as two vectors: the diagonal vector and the sub-diagonal vector. -
class
SymTriMatrixL
extends MatriL with Error with Serializable
The
SymTriMatrixL
class stores and operates on symmetric tridiagonal matrices.The
SymTriMatrixL
class stores and operates on symmetric tridiagonal matrices. The elements are of type ofLong
. A matrix is stored as two vectors: the diagonal vector and the sub-diagonal vector. -
class
SymTriMatrixQ
extends MatriQ with Error with Serializable
The
SymTriMatrixQ
class stores and operates on symmetric tridiagonal matrices.The
SymTriMatrixQ
class stores and operates on symmetric tridiagonal matrices. The elements are of type ofRational
. A matrix is stored as two vectors: the diagonal vector and the sub-diagonal vector. -
class
SymTriMatrixR
extends MatriR with Error with Serializable
The
SymTriMatrixR
class stores and operates on symmetric tridiagonal matrices.The
SymTriMatrixR
class stores and operates on symmetric tridiagonal matrices. The elements are of type ofReal
. A matrix is stored as two vectors: the diagonal vector and the sub-diagonal vector. -
class
TripletC
extends AnyRef
The
TripletC
class holds a run length encoded triplet, e.g., (_1, 2, 3) Triplets are used for storing compressed vectors and matrices. -
class
TripletD
extends AnyRef
The
TripletD
class holds a run length encoded triplet, e.g., (1.0, 2, 3) Triplets are used for storing compressed vectors and matrices. -
class
TripletI
extends AnyRef
The
TripletI
class holds a run length encoded triplet, e.g., (1, 2, 3) Triplets are used for storing compressed vectors and matrices. -
class
TripletL
extends AnyRef
The
TripletL
class holds a run length encoded triplet, e.g., (1l, 2, 3) Triplets are used for storing compressed vectors and matrices. -
class
TripletQ
extends AnyRef
The
TripletQ
class holds a run length encoded triplet, e.g., (_1, 2, 3) Triplets are used for storing compressed vectors and matrices. -
class
TripletR
extends AnyRef
The
TripletR
class holds a run length encoded triplet, e.g., (_1, 2, 3) Triplets are used for storing compressed vectors and matrices. -
class
TripletS
extends AnyRef
The
TripletS
class holds a run length encoded triplet, e.g., (_1, 2, 3) Triplets are used for storing compressed vectors and matrices. -
trait
Vec
extends AnyRef
The
Vec
trait establishes a common base type for all vectors (e.g.,VectorD
). -
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 typeComplex
.The
VectoC
class stores and operates on Numeric Vectors of base typeComplex
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
trait
VectoD
extends Traversable[Double] with PartiallyOrdered[VectoD] with Vec with Error with Serializable
The
VectoD
class stores and operates on Numeric Vectors of base typeDouble
.The
VectoD
class stores and operates on Numeric Vectors of base typeDouble
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
trait
VectoI
extends Traversable[Int] with PartiallyOrdered[VectoI] with Vec with Error with Serializable
The
VectoI
class stores and operates on Numeric Vectors of base typeInt
.The
VectoI
class stores and operates on Numeric Vectors of base typeInt
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
trait
VectoL
extends Traversable[Long] with PartiallyOrdered[VectoL] with Vec with Error with Serializable
The
VectoL
class stores and operates on Numeric Vectors of base typeLong
.The
VectoL
class stores and operates on Numeric Vectors of base typeLong
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
trait
VectoQ
extends Traversable[Rational] with PartiallyOrdered[VectoQ] with Vec with Error with Serializable
The
VectoQ
class stores and operates on Numeric Vectors of base typeRational
.The
VectoQ
class stores and operates on Numeric Vectors of base typeRational
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
trait
VectoR
extends Traversable[Real] with PartiallyOrdered[VectoR] with Vec with Error with Serializable
The
VectoR
class stores and operates on Numeric Vectors of base typeReal
.The
VectoR
class stores and operates on Numeric Vectors of base typeReal
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
trait
VectoS
extends Traversable[StrNum] with PartiallyOrdered[VectoS] with Vec with Error with Serializable
The
VectoS
class stores and operates on Numeric Vectors of base typeStrNum
.The
VectoS
class stores and operates on Numeric Vectors of base typeStrNum
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
class
VectorC
extends VectoC
The
VectorC
class stores and operates on Numeric Vectors of base typeComplex
.The
VectorC
class stores and operates on Numeric Vectors of base typeComplex
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
class
VectorD
extends VectoD
The
VectorD
class stores and operates on Numeric Vectors of base typeDouble
.The
VectorD
class stores and operates on Numeric Vectors of base typeDouble
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
class
VectorI
extends VectoI
The
VectorI
class stores and operates on Numeric Vectors of base typeInt
.The
VectorI
class stores and operates on Numeric Vectors of base typeInt
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
class
VectorL
extends VectoL
The
VectorL
class stores and operates on Numeric Vectors of base typeLong
.The
VectorL
class stores and operates on Numeric Vectors of base typeLong
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
class
VectorQ
extends VectoQ
The
VectorQ
class stores and operates on Numeric Vectors of base typeRational
.The
VectorQ
class stores and operates on Numeric Vectors of base typeRational
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
class
VectorR
extends VectoR
The
VectorR
class stores and operates on Numeric Vectors of base typeReal
.The
VectorR
class stores and operates on Numeric Vectors of base typeReal
. It follows the framework ofgen.VectorN [T]
and is provided for performance. -
class
VectorS
extends VectoS
The
VectorS
class stores and operates on Numeric Vectors of base typeStrNum
.The
VectorS
class stores and operates on Numeric Vectors of base typeStrNum
. It follows the framework ofgen.VectorN [T]
and is provided for performance.
Value Members
-
object
BidMatrixC
extends Error with Serializable
The
BidMatrixC
object is the companion object for theBidMatrixC
class. -
object
BidMatrixCTest
extends App
The
BidMatrixCTest
object is used to test theBidMatrixC
class.The
BidMatrixCTest
object is used to test theBidMatrixC
class. > run-main scalation.linalgebra.BidMatrixCTest -
object
BidMatrixD
extends Error with Serializable
The
BidMatrixD
object is the companion object for theBidMatrixD
class. -
object
BidMatrixDTest
extends App
The
BidMatrixDTest
object is used to test theBidMatrixD
class.The
BidMatrixDTest
object is used to test theBidMatrixD
class. > run-main scalation.linalgebra.BidMatrixDTest -
object
BidMatrixI
extends Error with Serializable
The
BidMatrixI
object is the companion object for theBidMatrixI
class. -
object
BidMatrixITest
extends App
The
BidMatrixITest
object is used to test theBidMatrixI
class.The
BidMatrixITest
object is used to test theBidMatrixI
class. > run-main scalation.linalgebra.BidMatrixITest -
object
BidMatrixL
extends Error with Serializable
The
BidMatrixL
object is the companion object for theBidMatrixL
class. -
object
BidMatrixLTest
extends App
The
BidMatrixLTest
object is used to test theBidMatrixL
class.The
BidMatrixLTest
object is used to test theBidMatrixL
class. > run-main scalation.linalgebra.BidMatrixLTest -
object
BidMatrixQ
extends Error with Serializable
The
BidMatrixQ
object is the companion object for theBidMatrixQ
class. -
object
BidMatrixQTest
extends App
The
BidMatrixQTest
object is used to test theBidMatrixQ
class.The
BidMatrixQTest
object is used to test theBidMatrixQ
class. > run-main scalation.linalgebra.BidMatrixQTest -
object
BidMatrixR
extends Error with Serializable
The
BidMatrixR
object is the companion object for theBidMatrixR
class. -
object
BidMatrixRTest
extends App
The
BidMatrixRTest
object is used to test theBidMatrixR
class.The
BidMatrixRTest
object is used to test theBidMatrixR
class. > run-main scalation.linalgebra.BidMatrixRTest -
object
Bidiagonal2Test
extends App
The
Bidiagonal2Test
object is used to test theBidiagonal2
class.The
Bidiagonal2Test
object is used to test theBidiagonal2
class. bidiagonalization answer = [ (21.8, -.613), (12.8, 2.24, 0.) ]- See also
books.google.com/books?isbn=0801854148 (p. 252) > run-main scalation.linalgebra.Bidiagonal2Test
-
object
Bidiagonal2Test2
extends App
The
Bidiagonal2Test2
object is used to test theBidiagonal2
class.The
Bidiagonal2Test2
object is used to test theBidiagonal2
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) > run-main scalation.linalgebra.Bidiagonal2Test2
-
object
BidiagonalTest
extends App
The
BidiagonalTest
object is used to test theBidiagonal
class.The
BidiagonalTest
object is used to test theBidiagonal
class. bidiagonalization answer = [ (21.8, -.613), (12.8, 2.24, 0.) ]- See also
books.google.com/books?isbn=0801854148 (p. 252) > run-main scalation.linalgebra.BidiagonalTest
-
object
Converter
The
Converter
object converts string number vectors to regular numeric vectors. -
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. > run-main scalation.linalgebra.EigenTest -
object
Eigen_2by2
extends Error
The
Eigen_2by2
object provides simple methods for computing eigenvalues and eigenvectors for 2-by-2 matrices. -
object
Eigen_2by2Test
extends App
The
Eigen_2by2Test
is used to test theEigen_2by2
object.The
Eigen_2by2Test
is used to test theEigen_2by2
object. > run-main scalation.linalgebra.Eigen_2by2Test -
object
Fac_CholeskyTest
extends App
The
Fac_CholeskyTest
object is used to test theFac_Cholesky
class.The
Fac_CholeskyTest
object is used to test theFac_Cholesky
class.- See also
ece.uwaterloo.ca/~dwharder/NumericalAnalysis/04LinearAlgebra/cholesky > run-main scalation.linalgebra.Fac_CholeskyTest
-
object
Fac_LQTest
extends App
The
Fac_LQTest
object is used to test theFac_LQ
class.The
Fac_LQTest
object is used to test theFac_LQ
class. > run-main scalation.linalgebra.Fac_LQTest - object Fac_QR
-
object
Fac_QRTest
extends App
The
Fac_QRTest
object is used to test theFac_QR
classes.The
Fac_QRTest
object is used to test theFac_QR
classes.- See also
www.math.usm.edu/lambers/mat610/sum10/lecture9.pdf FIX: the 'nullspaceV' function need to be fixed. > run-main scalation.linalgebra.Fac_QRTest
www.ee.ucla.edu/~vandenbe/103/lectures/qr.pdf
-
object
Fac_QRTest2
extends App
The
Fac_QRTest2
object is used to test the correctness of the 'solve' method in theFac_QR
classes.The
Fac_QRTest2
object is used to test the correctness of the 'solve' method in theFac_QR
classes. > run-main scalation.linalgebra.Fac_QRTest2 -
object
Fac_QR_RRTest
extends App
The
Fac_QR_RRTest
object is used to test theFac_QR_RR
classes.The
Fac_QR_RRTest
object is used to test theFac_QR_RR
classes.- See also
www.math.usm.edu/lambers/mat610/sum10/lecture9.pdf FIX: the 'nullspaceV' function need to be fixed. > run-main scalation.linalgebra.Fac_QR_RRTest
www.ee.ucla.edu/~vandenbe/103/lectures/qr.pdf
-
object
Givens
The
Givens
objects has methods for determining values 'c = cos(theta)' and 's = sin(theta)' for Givens rotation matrices as well as methods for applying Givens rotations. -
object
GivensTest
extends App
The
GivensTest
object tests theGivens
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 theGivens
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 > run-main scalation.linalgebra.GivensTest
-
object
Householder
The
Householder
object provides methods to compute Householder vectors and reflector matrices. -
object
HouseholderTest
extends App
The
HouseholderTest
object is used to testHouseholder
object.The
HouseholderTest
object is used to testHouseholder
object.- See also
www.math.siu.edu/matlab/tutorial4.pdf > run-main scalation.linalgebra.HouseholderTest
-
object
MatrixC
extends Error with Serializable
The
MatrixC
companion object provides operations forMatrixC
that don't require 'this' (like static methods in Java).The
MatrixC
companion object provides operations forMatrixC
that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors. -
object
MatrixCTest
extends App with PackageInfo
The
MatrixCTest
object tests the operations provided byMatrixC
class.The
MatrixCTest
object tests the operations provided byMatrixC
class. > run-main scalation.linalgebra.MatrixCTest -
object
MatrixD
extends Error with Serializable
The
MatrixD
companion object provides operations forMatrixD
that don't require 'this' (like static methods in Java).The
MatrixD
companion object provides operations forMatrixD
that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors. -
object
MatrixDTest
extends App with PackageInfo
The
MatrixDTest
object tests the operations provided byMatrixD
class.The
MatrixDTest
object tests the operations provided byMatrixD
class. > run-main scalation.linalgebra.MatrixDTest -
object
MatrixI
extends Error with Serializable
The
MatrixI
companion object provides operations forMatrixI
that don't require 'this' (like static methods in Java).The
MatrixI
companion object provides operations forMatrixI
that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors. -
object
MatrixITest
extends App with PackageInfo
The
MatrixITest
object tests the operations provided byMatrixI
class.The
MatrixITest
object tests the operations provided byMatrixI
class. > run-main scalation.linalgebra.MatrixITest -
object
MatrixKind
extends Enumeration
The
MatrixKind
object defines an enumeration for the kinds of matrices supported in ScalaTion.The
MatrixKind
object defines an enumeration for the kinds of matrices supported in ScalaTion. Combined with the base type (e.g., D forDouble
), a particular type of matrix is defined (e.g.,SparseMatrixD
). -
object
MatrixL
extends Error with Serializable
The
MatrixL
companion object provides operations forMatrixL
that don't require 'this' (like static methods in Java).The
MatrixL
companion object provides operations forMatrixL
that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors. -
object
MatrixLTest
extends App with PackageInfo
The
MatrixLTest
object tests the operations provided byMatrixL
class.The
MatrixLTest
object tests the operations provided byMatrixL
class. > run-main scalation.linalgebra.MatrixLTest -
object
MatrixQ
extends Error with Serializable
The
MatrixQ
companion object provides operations forMatrixQ
that don't require 'this' (like static methods in Java).The
MatrixQ
companion object provides operations forMatrixQ
that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors. -
object
MatrixQTest
extends App with PackageInfo
The
MatrixQTest
object tests the operations provided byMatrixQ
class.The
MatrixQTest
object tests the operations provided byMatrixQ
class. > run-main scalation.linalgebra.MatrixQTest -
object
MatrixR
extends Error with Serializable
The
MatrixR
companion object provides operations forMatrixR
that don't require 'this' (like static methods in Java).The
MatrixR
companion object provides operations forMatrixR
that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from files or vectors. -
object
MatrixRTest
extends App with PackageInfo
The
MatrixRTest
object tests the operations provided byMatrixR
class.The
MatrixRTest
object tests the operations provided byMatrixR
class. > run-main scalation.linalgebra.MatrixRTest -
object
PivotingTest
extends App with Pivoting
The
PivotingTest
is used to test thePivoting
trait.The
PivotingTest
is used to test thePivoting
trait. > run-main scalation.linalgebra.PivotingTest -
object
RleMatrixC
extends Serializable
The
RleMatrixC
companion object provides operations forRleMatrixC
that don't require 'this' (like static methods in Java).The
RleMatrixC
companion object provides operations forRleMatrixC
that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from sequences or vectors. -
object
RleMatrixCTest
extends App with PackageInfo
The
RleMatrixCTest
object tests the operations provided byMatrixC
class.The
RleMatrixCTest
object tests the operations provided byMatrixC
class. > run-main scalation.linalgebra.RleMatrixCTest -
object
RleMatrixD
extends Serializable
The
RleMatrixD
companion object provides operations forRleMatrixD
that don't require 'this' (like static methods in Java).The
RleMatrixD
companion object provides operations forRleMatrixD
that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from sequences or vectors. -
object
RleMatrixDTest
extends App with PackageInfo
The
RleMatrixDTest
object tests the operations provided byMatrixD
class.The
RleMatrixDTest
object tests the operations provided byMatrixD
class. > run-main scalation.linalgebra.RleMatrixDTest -
object
RleMatrixI
extends Serializable
The
RleMatrixI
companion object provides operations forRleMatrixI
that don't require 'this' (like static methods in Java).The
RleMatrixI
companion object provides operations forRleMatrixI
that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from sequences or vectors. -
object
RleMatrixITest
extends App with PackageInfo
The
RleMatrixITest
object tests the operations provided byMatrixI
class.The
RleMatrixITest
object tests the operations provided byMatrixI
class. > run-main scalation.linalgebra.RleMatrixITest -
object
RleMatrixL
extends Serializable
The
RleMatrixL
companion object provides operations forRleMatrixL
that don't require 'this' (like static methods in Java).The
RleMatrixL
companion object provides operations forRleMatrixL
that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from sequences or vectors. -
object
RleMatrixLTest
extends App with PackageInfo
The
RleMatrixLTest
object tests the operations provided byMatrixL
class.The
RleMatrixLTest
object tests the operations provided byMatrixL
class. > run-main scalation.linalgebra.RleMatrixLTest -
object
RleMatrixQ
extends Serializable
The
RleMatrixQ
companion object provides operations forRleMatrixQ
that don't require 'this' (like static methods in Java).The
RleMatrixQ
companion object provides operations forRleMatrixQ
that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from sequences or vectors. -
object
RleMatrixQTest
extends App with PackageInfo
The
RleMatrixQTest
object tests the operations provided byMatrixQ
class.The
RleMatrixQTest
object tests the operations provided byMatrixQ
class. > run-main scalation.linalgebra.RleMatrixQTest -
object
RleMatrixR
extends Serializable
The
RleMatrixR
companion object provides operations forRleMatrixR
that don't require 'this' (like static methods in Java).The
RleMatrixR
companion object provides operations forRleMatrixR
that don't require 'this' (like static methods in Java). It provides factory methods for building matrices from sequences or vectors. -
object
RleMatrixRTest
extends App with PackageInfo
The
RleMatrixRTest
object tests the operations provided byMatrixR
class.The
RleMatrixRTest
object tests the operations provided byMatrixR
class. > run-main scalation.linalgebra.RleMatrixRTest -
object
RleVectorC
extends Serializable
The
RleVectorC
object is the companion object for theRleVectorC
class. -
object
RleVectorCTest
extends App
The
RleVectorCTest
object tests the operations provided byRleVectorC
.The
RleVectorCTest
object tests the operations provided byRleVectorC
. > run-main scalation.linalgebra.RleVectorCTest -
object
RleVectorD
extends Serializable
The
RleVectorD
object is the companion object for theRleVectorD
class. -
object
RleVectorDTest
extends App
The
RleVectorDTest
object tests the operations provided byRleVectorD
.The
RleVectorDTest
object tests the operations provided byRleVectorD
. > run-main scalation.linalgebra.RleVectorDTest -
object
RleVectorI
extends Serializable
The
RleVectorI
object is the companion object for theRleVectorI
class. -
object
RleVectorITest
extends App
The
RleVectorITest
object tests the operations provided byRleVectorI
.The
RleVectorITest
object tests the operations provided byRleVectorI
. > run-main scalation.linalgebra.RleVectorITest -
object
RleVectorL
extends Serializable
The
RleVectorL
object is the companion object for theRleVectorL
class. -
object
RleVectorLTest
extends App
The
RleVectorLTest
object tests the operations provided byRleVectorL
.The
RleVectorLTest
object tests the operations provided byRleVectorL
. > run-main scalation.linalgebra.RleVectorLTest -
object
RleVectorQ
extends Serializable
The
RleVectorQ
object is the companion object for theRleVectorQ
class. -
object
RleVectorQTest
extends App
The
RleVectorQTest
object tests the operations provided byRleVectorQ
.The
RleVectorQTest
object tests the operations provided byRleVectorQ
. > run-main scalation.linalgebra.RleVectorQTest -
object
RleVectorR
extends Serializable
The
RleVectorR
object is the companion object for theRleVectorR
class. -
object
RleVectorRTest
extends App
The
RleVectorRTest
object tests the operations provided byRleVectorR
.The
RleVectorRTest
object tests the operations provided byRleVectorR
. > run-main scalation.linalgebra.RleVectorRTest -
object
RleVectorS
extends Serializable
The
RleVectorS
object is the companion object for theRleVectorS
class. -
object
RleVectorSTest
extends App
The
RleVectorSTest
object tests the operations provided byRleVectorS
.The
RleVectorSTest
object tests the operations provided byRleVectorS
. > run-main scalation.linalgebra.RleVectorSTest -
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 ]
-
object
RotationTest
extends App
The
RotationTest
object is used to test theRotation
object, > run-main scalation.linalgebra.RotationTest -
object
SVD2Test
extends App
The
SVD2Test
object is used to test theSVD2
class.The
SVD2Test
object is used to test theSVD2
class.- See also
www.ling.ohio-state.edu/~kbaker/pubs/Singular_Value_Decomposition_Tutorial.pdf > run-main scalation.linalgebra.SVD2Test
-
object
SVD2Test2
extends App
The
SVD2Test2
object is used to test theSVD2
class.The
SVD2Test2
object is used to test theSVD2
class.- See also
www.ling.ohio-state.edu/~kbaker/pubs/Singular_Value_Decomposition_Tutorial.pdf > run-main scalation.linalgebra.SVD2Test2
-
object
SVD2Test3
extends App
The
SVD2Test3
object is used to test theSVD2
class.The
SVD2Test3
object is used to test theSVD2
class. > run-main scalation.linalgebra.SVD2Test3 -
object
SVD2Test4
extends App
The
SVD2Test4
object is used to test theSVD2
class.The
SVD2Test4
object is used to test theSVD2
class. > run-main scalation.linalgebra.SVD2Test4 -
object
SVD2Test5
extends App
The
SVD2Test5
object is used to test theSVD2
class.The
SVD2Test5
object is used to test theSVD2
class. > run-main scalation.linalgebra.SVD2Test5 -
object
SVD2Test6
extends App
The
SVD2Test6
object is used to test theSVD2
class.The
SVD2Test6
object is used to test theSVD2
class. > run-main scalation.linalgebra.SVD2Test6 -
object
SVD2Test7
extends App
The
SVD2Test7
object is used to test theSVD2
class.The
SVD2Test7
object is used to test theSVD2
class. > run-main scalation.linalgebra.SVD2Test7 -
object
SVD2Test8
extends App
The
SVD2Test8
object is used to test theSVD2
class.The
SVD2Test8
object is used to test theSVD2
class. > run-main scalation.linalgebra.SVD2Test8 -
object
SVD3Test
extends App
The
SVD3Test
is used to test theSVD3
class.The
SVD3Test
is used to test theSVD3
class. Answer: singular values = (2.28825, 0.87403)- See also
http://comnuan.com/cmnn01004/
-
object
SVD3Test2
extends App
The
SVD3Test2
is used to test theSVD3
class.The
SVD3Test2
is used to test theSVD3
class. Answer: singular values = (3.82983, 1.91368, 0.81866) -
object
SVD4
The
SVD4
companion object. -
object
SVD4Test
extends App
The
SVD4Test
object is used to test theSVD4
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 theSVD4
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/ > run-main scalation.linalgebra.SVD4Test
-
object
SVD4Test2
extends App
The
SVD4Test2
is used to test theSVD4
class.The
SVD4Test2
is used to test theSVD4
class. Answer: singular values = (3.82983, 1.91368, 0.81866) > run-main scalation.linalgebra.SVD4Test2 -
object
SVD4Test3
extends App
The
SVD4Test3
object is used to test theSVD4
class starting with general (i.e., not bidiagonalized) matrices.The
SVD4Test3
object is used to test theSVD4
class starting with general (i.e., not bidiagonalized) matrices. All probelems for which m >= n from the following Webspage are tried.- See also
mysite.science.uottawa.ca/phofstra/MAT2342/SVDproblems.pdf > run-main scalation.linalgebra.SVD4Test3
www.mathstat.uottawa.ca/~phofstra/MAT2342/SVDproblems.pdf
-
object
SVD4Test4
extends App
The
SVD4Test4
object is used to test theSVD4
class starting with a general matrix.The
SVD4Test4
object is used to test theSVD4
class starting with a general matrix. > run-main scalation.linalgebra.SVD4Test4 -
object
SVD4Test5
extends App
The
SVD4Test5
is used to test theSVD4
class on a problem where the matrix is not a square matrix.The
SVD4Test5
is used to test theSVD4
class on a problem where the matrix is not a square matrix. > run-main scalation.linalgebra.SVD4Test5 -
object
SVD4Test6
extends App
The
SVD4Test5
is used to test theSVD4
class on a larger test problem.The
SVD4Test5
is used to test theSVD4
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'. > run-main scalation.linalgebra.SVD4Test6
-
object
SVD4Test7
extends App
The
SVD4Test6
object is used to test theSVD4
companion object's computation of trailing submatrices.The
SVD4Test6
object is used to test theSVD4
companion object's computation of trailing submatrices. > run-main scalation.linalgebra.SVD4Test7 -
object
SVDTest
extends App
The
SVDTest
is used to test theSVD
class.The
SVDTest
is used to test theSVD
class. > run-main scalation.linalgebra.SVDTest -
object
SVDTest2
extends App
The
SVDTest2
object is used to test theSVD
class.The
SVDTest2
object is used to test theSVD
class.- See also
www.ling.ohio-state.edu/~kbaker/pubs/Singular_Value_Decomposition_Tutorial.pdf > run-main scalation.linalgebra.SVDTest2
-
object
SVDTest3
extends App
The
SVDTest3
object is used to test theSVD
class.The
SVDTest3
object is used to test theSVD
class. > run-main scalation.linalgebra.SVDTest3 -
object
SVDTest4
extends App
The
SVDTest4
object is used to test theSVD
class.The
SVDTest4
object is used to test theSVD
class. > run-main scalation.linalgebra.SVDTest4 -
object
SVDTest5
extends App
The
SVDTest5
object is used to test theSVD
class.The
SVDTest5
object is used to test theSVD
class. > run-main scalation.linalgebra.SVDTest5 -
object
SVDTest6
extends App
The
SVDTest6
object is used to test theSVD
class.The
SVDTest6
object is used to test theSVD
class. > run-main scalation.linalgebra.SVDTest6 -
object
SVDTest7
extends App
The
SVDTest7
object is used to test theSVD
class.The
SVDTest7
object is used to test theSVD
class. This test case currently fails as ScalaTion does not consider 9.18964e-09 to be approximately zero. > run-main scalation.linalgebra.SVDTest7 -
object
SVDTest8
extends App
The
SVDTest8
object is used to test theSVD
class.The
SVDTest8
object is used to test theSVD
class. > run-main scalation.linalgebra.SVDTest7 -
object
SVD_2by2Test
extends App
The
SVD_2by2Test
is used to test theSVD_2by2
class. -
object
SVDecomp
extends SVDecomp
The
SVDecomp
object provides several test matrices as well as methods for determining rank and test the SVD factorizations. -
object
SVDecompTest
extends App
The
SVDecompTest
object tests the equality of theSVD
andSVD2
classes.The
SVDecompTest
object tests the equality of theSVD
andSVD2
classes. > run-main scalation.linalgebra.SVDecompTest -
object
SVDecompTest2
extends App
The
SVDecompTest2
object tests the equality of theSVD
andSVD2
classes.The
SVDecompTest2
object tests the equality of theSVD
andSVD2
classes. > run-main scalation.linalgebra.SVDecompTest2 -
object
SVDecompTest3
extends App
The
SVDecompTest3
object tests the equality of theSVD
andSVD2
classes.The
SVDecompTest3
object tests the equality of theSVD
andSVD2
classes. > run-main scalation.linalgebra.SVDecompTest3 -
object
SVDecompTest4
extends App
The
SVDecompTest4
object tests the equality of theSVD
andSVD2
classes.The
SVDecompTest4
object tests the equality of theSVD
andSVD2
classes. > run-main scalation.linalgebra.SVDecompTest4 -
object
SVDecompTest5
extends App
The
SVDecompTest5
object tests the equality of theSVD
andSVD2
classes.The
SVDecompTest5
object tests the equality of theSVD
andSVD2
classes. > run-main scalation.linalgebra.SVDecompTest5 -
object
SVDecompTest6
extends App
The
SVDecompTest6
object tests the equality of theSVD
andSVD2
classes.The
SVDecompTest6
object tests the equality of theSVD
andSVD2
classes. > run-main scalation.linalgebra.SVDecompTest6 -
object
SVDecompTest7
extends App
The
SVDecompTest7
object tests the equality of theSVD
andSVD2
classes.The
SVDecompTest7
object tests the equality of theSVD
andSVD2
classes. > run-main scalation.linalgebra.SVDecompTest7 -
object
SVDecompTest8
extends App
The
SVDecompTest8
object tests the equality of theSVD
andSVD2
classes.The
SVDecompTest8
object tests the equality of theSVD
andSVD2
classes. > run-main scalation.linalgebra.SVDecompTest8 -
object
SparseMatrixC
extends Serializable
The
SparseMatrixC
object is the companion object for theSparseMatrixC
class. -
object
SparseMatrixCTest
extends App
The
SparseMatrixCTest
object is used to test theSparseMatrixC
class.The
SparseMatrixCTest
object is used to test theSparseMatrixC
class. > run-main scalation.linalgebra.SparseMatrixCTest -
object
SparseMatrixD
extends Serializable
The
SparseMatrixD
object is the companion object for theSparseMatrixD
class. -
object
SparseMatrixDTest
extends App
The
SparseMatrixDTest
object is used to test theSparseMatrixD
class.The
SparseMatrixDTest
object is used to test theSparseMatrixD
class. > run-main scalation.linalgebra.SparseMatrixDTest -
object
SparseMatrixI
extends Serializable
The
SparseMatrixI
object is the companion object for theSparseMatrixI
class. -
object
SparseMatrixITest
extends App
The
SparseMatrixITest
object is used to test theSparseMatrixI
class.The
SparseMatrixITest
object is used to test theSparseMatrixI
class. > run-main scalation.linalgebra.SparseMatrixITest -
object
SparseMatrixL
extends Serializable
The
SparseMatrixL
object is the companion object for theSparseMatrixL
class. -
object
SparseMatrixLTest
extends App
The
SparseMatrixLTest
object is used to test theSparseMatrixL
class.The
SparseMatrixLTest
object is used to test theSparseMatrixL
class. > run-main scalation.linalgebra.SparseMatrixLTest -
object
SparseMatrixQ
extends Serializable
The
SparseMatrixQ
object is the companion object for theSparseMatrixQ
class. -
object
SparseMatrixQTest
extends App
The
SparseMatrixQTest
object is used to test theSparseMatrixQ
class.The
SparseMatrixQTest
object is used to test theSparseMatrixQ
class. > run-main scalation.linalgebra.SparseMatrixQTest -
object
SparseMatrixR
extends Serializable
The
SparseMatrixR
object is the companion object for theSparseMatrixR
class. -
object
SparseMatrixRTest
extends App
The
SparseMatrixRTest
object is used to test theSparseMatrixR
class.The
SparseMatrixRTest
object is used to test theSparseMatrixR
class. > run-main scalation.linalgebra.SparseMatrixRTest -
object
SparseVectorC
extends Serializable
The
SparseVectorC
object is the companion object for theSparseVectorC
class. -
object
SparseVectorCTest
extends App
The
SparseVectorDTest
object tests the operations provided bySparseVectorC
.The
SparseVectorDTest
object tests the operations provided bySparseVectorC
. > run-main scalation.linalgebra.SparseVectorDTest -
object
SparseVectorCTest2
extends App
The
SparseVectorDTest2
object tests the dot product operation provided bySparseVectorC
.The
SparseVectorDTest2
object tests the dot product operation provided bySparseVectorC
. > run-main scalation.linalgebra.SparseVectorDTest2 -
object
SparseVectorD
extends Serializable
The
SparseVectorD
object is the companion object for theSparseVectorD
class. -
object
SparseVectorDTest
extends App
The
SparseVectorDTest
object tests the operations provided bySparseVectorD
.The
SparseVectorDTest
object tests the operations provided bySparseVectorD
. > run-main scalation.linalgebra.SparseVectorDTest -
object
SparseVectorDTest2
extends App
The
SparseVectorDTest2
object tests the dot product operation provided bySparseVectorD
.The
SparseVectorDTest2
object tests the dot product operation provided bySparseVectorD
. > run-main scalation.linalgebra.SparseVectorDTest2 -
object
SparseVectorI
extends Serializable
The
SparseVectorI
object is the companion object for theSparseVectorI
class. -
object
SparseVectorITest
extends App
The
SparseVectorDTest
object tests the operations provided bySparseVectorI
.The
SparseVectorDTest
object tests the operations provided bySparseVectorI
. > run-main scalation.linalgebra.SparseVectorDTest -
object
SparseVectorITest2
extends App
The
SparseVectorDTest2
object tests the dot product operation provided bySparseVectorI
.The
SparseVectorDTest2
object tests the dot product operation provided bySparseVectorI
. > run-main scalation.linalgebra.SparseVectorDTest2 -
object
SparseVectorL
extends Serializable
The
SparseVectorL
object is the companion object for theSparseVectorL
class. -
object
SparseVectorLTest
extends App
The
SparseVectorDTest
object tests the operations provided bySparseVectorL
.The
SparseVectorDTest
object tests the operations provided bySparseVectorL
. > run-main scalation.linalgebra.SparseVectorDTest -
object
SparseVectorLTest2
extends App
The
SparseVectorDTest2
object tests the dot product operation provided bySparseVectorL
.The
SparseVectorDTest2
object tests the dot product operation provided bySparseVectorL
. > run-main scalation.linalgebra.SparseVectorDTest2 -
object
SparseVectorQ
extends Serializable
The
SparseVectorQ
object is the companion object for theSparseVectorQ
class. -
object
SparseVectorQTest
extends App
The
SparseVectorDTest
object tests the operations provided bySparseVectorQ
.The
SparseVectorDTest
object tests the operations provided bySparseVectorQ
. > run-main scalation.linalgebra.SparseVectorDTest -
object
SparseVectorQTest2
extends App
The
SparseVectorDTest2
object tests the dot product operation provided bySparseVectorQ
.The
SparseVectorDTest2
object tests the dot product operation provided bySparseVectorQ
. > run-main scalation.linalgebra.SparseVectorDTest2 -
object
SparseVectorR
extends Serializable
The
SparseVectorR
object is the companion object for theSparseVectorR
class. -
object
SparseVectorRTest
extends App
The
SparseVectorDTest
object tests the operations provided bySparseVectorR
.The
SparseVectorDTest
object tests the operations provided bySparseVectorR
. > run-main scalation.linalgebra.SparseVectorDTest -
object
SparseVectorRTest2
extends App
The
SparseVectorDTest2
object tests the dot product operation provided bySparseVectorR
.The
SparseVectorDTest2
object tests the dot product operation provided bySparseVectorR
. > run-main scalation.linalgebra.SparseVectorDTest2 -
object
SparseVectorS
extends Serializable
The
SparseVectorS
object is the companion object for theSparseVectorS
class. -
object
SparseVectorSTest
extends App
The
SparseVectorDTest
object tests the operations provided bySparseVectorS
.The
SparseVectorDTest
object tests the operations provided bySparseVectorS
. > run-main scalation.linalgebra.SparseVectorDTest -
object
SparseVectorSTest2
extends App
The
SparseVectorDTest2
object tests the dot product operation provided bySparseVectorS
.The
SparseVectorDTest2
object tests the dot product operation provided bySparseVectorS
. > run-main scalation.linalgebra.SparseVectorDTest2 -
object
SymTriMatrixC
extends Error with Serializable
The
SymTriMatrixC
object is the companion object for theSymTriMatrixC
class. -
object
SymTriMatrixCTest
extends App
The
SymTriMatrixCTest
object is used to test theSymTriMatrixC
class.The
SymTriMatrixCTest
object is used to test theSymTriMatrixC
class. > run-main scalation.linalgebra.SymTriMatrixCTest -
object
SymTriMatrixD
extends Error with Serializable
The
SymTriMatrixD
object is the companion object for theSymTriMatrixD
class. -
object
SymTriMatrixDTest
extends App
The
SymTriMatrixDTest
object is used to test theSymTriMatrixD
class.The
SymTriMatrixDTest
object is used to test theSymTriMatrixD
class. > run-main scalation.linalgebra.SymTriMatrixDTest -
object
SymTriMatrixI
extends Error with Serializable
The
SymTriMatrixI
object is the companion object for theSymTriMatrixI
class. -
object
SymTriMatrixITest
extends App
The
SymTriMatrixITest
object is used to test theSymTriMatrixI
class.The
SymTriMatrixITest
object is used to test theSymTriMatrixI
class. > run-main scalation.linalgebra.SymTriMatrixITest -
object
SymTriMatrixL
extends Error with Serializable
The
SymTriMatrixL
object is the companion object for theSymTriMatrixL
class. -
object
SymTriMatrixLTest
extends App
The
SymTriMatrixLTest
object is used to test theSymTriMatrixL
class.The
SymTriMatrixLTest
object is used to test theSymTriMatrixL
class. > run-main scalation.linalgebra.SymTriMatrixLTest -
object
SymTriMatrixQ
extends Error with Serializable
The
SymTriMatrixQ
object is the companion object for theSymTriMatrixQ
class. -
object
SymTriMatrixQTest
extends App
The
SymTriMatrixQTest
object is used to test theSymTriMatrixQ
class.The
SymTriMatrixQTest
object is used to test theSymTriMatrixQ
class. > run-main scalation.linalgebra.SymTriMatrixQTest -
object
SymTriMatrixR
extends Error with Serializable
The
SymTriMatrixR
object is the companion object for theSymTriMatrixR
class. -
object
SymTriMatrixRTest
extends App
The
SymTriMatrixRTest
object is used to test theSymTriMatrixR
class.The
SymTriMatrixRTest
object is used to test theSymTriMatrixR
class. > run-main scalation.linalgebra.SymTriMatrixRTest -
object
SymmetricQRstep
extends Eigen with Error
The
SymmetricQRstep
object performs a symmetric 'QR' step with a Wilkinson shift.The
SymmetricQRstep
object performs a symmetric 'QR' step with a Wilkinson shift.- See also
http://people.inf.ethz.ch/arbenz/ewp/Lnotes/chapter3.pdf (Algorithm 3.6)
Algorithm 8.3.2 in Matrix Computations.
-
object
Vec
The
Vec
object provides a minimal set of functions that apply across all types of vectors.The
Vec
object provides a minimal set of functions that apply across all types of vectors.- See also
scalation.relalgebra.Relation
-
object
VectorC
extends Serializable
The
VectorC
object is the companion object for theVectorC
class. -
object
VectorCTest
extends App
The
VectorCTest
object tests the operations provided byVectorC
.The
VectorCTest
object tests the operations provided byVectorC
. > run-main scalation.linalgebra.VectorCTest -
object
VectorD
extends Serializable
The
VectorD
object is the companion object for theVectorD
class. -
object
VectorDTest
extends App
The
VectorDTest
object tests the operations provided byVectorD
.The
VectorDTest
object tests the operations provided byVectorD
. > run-main scalation.linalgebra.VectorDTest -
object
VectorI
extends Serializable
The
VectorI
object is the companion object for theVectorI
class. -
object
VectorITest
extends App
The
VectorITest
object tests the operations provided byVectorI
.The
VectorITest
object tests the operations provided byVectorI
. > run-main scalation.linalgebra.VectorITest -
object
VectorL
extends Serializable
The
VectorL
object is the companion object for theVectorL
class. -
object
VectorLTest
extends App
The
VectorLTest
object tests the operations provided byVectorL
.The
VectorLTest
object tests the operations provided byVectorL
. > run-main scalation.linalgebra.VectorLTest -
object
VectorQ
extends Serializable
The
VectorQ
object is the companion object for theVectorQ
class. -
object
VectorQTest
extends App
The
VectorQTest
object tests the operations provided byVectorQ
.The
VectorQTest
object tests the operations provided byVectorQ
. > run-main scalation.linalgebra.VectorQTest -
object
VectorR
extends Serializable
The
VectorR
object is the companion object for theVectorR
class. -
object
VectorRTest
extends App
The
VectorRTest
object tests the operations provided byVectorR
.The
VectorRTest
object tests the operations provided byVectorR
. > run-main scalation.linalgebra.VectorRTest -
object
VectorS
extends Serializable
The
VectorS
object is the companion object for theVectorS
class. -
object
VectorSTest
extends App
The
VectorSTest
object tests the operations provided byVectorS
.The
VectorSTest
object tests the operations provided byVectorS
. > run-main scalation.linalgebra.VectorSTest


|
Biosphere framework
0.1
<to be filled>
|
Functions | |
| ssize_t | EncodeUtf16 (u32 In, u16 *Out) |
| ssize_t | DecodeUtf16 (u16 *In, u32 *Out) |
| ssize_t | Utf16To8 (u16 *In, u8 *Out, size_t Length) |
| ssize_t | Utf16To32 (u16 *In, u32 *Out, size_t Length) |
| ssize_t | Utf32To8 (u32 *In, u8 *Out, size_t Length) |
| ssize_t | Utf32To16 (u32 *In, u16 *Out, size_t Length) |
| ssize_t | EncodeUtf8 (u32 In, u8 *Out) |
| ssize_t | DecodeUtf8 (u8 *In, u32 *Out) |
| ssize_t | Utf8To16 (u8 *In, u16 *Out, size_t Length) |
| ssize_t | Utf8To32 (u8 *In, u32 *Out, size_t Length) |


{% extends "base.html" %} {% block title %}home{% endblock %} {% block head %} {{ super() }} {% endblock %} {% block my_content %} {{ super() }}
This is Clay Jones' senior project for his Computer Science degree at California Polytechnic State University.
It is an insightful health practice but not a technical challenge to record all the food a patient or user eats. However, there are many ways to improve the user's likelihood to record all food, quality of the data, and quality of the advice provided. Existing solutions lack customization, were designed on outdated nutrition practices, have suboptimal user interfaces, and lack clinical support.
It is a meticulous process to enter the nutrition info of all the food you eat, especially foods lacking labels or brand names. We are asking patients to take a small amount of time every time they eat to enter this data. This leads to patients forgetting or quitting the food tracking habit.
Technology can be employed to assist with this.
It is easier for people to "jot down" what they ate, but complex nutritional analysis requires a lot of data regarding portion size, nutrient composition, or brand of food. My goal is to offload as much of this labor to software as possible.
Please contact me for a testing account. Your data will be used by the system and visible to developers (myself). No other users will be able to see your food log. I do my best to backup all data but this project is a work in progress and highly unstable.
At first, there may not be much analysis or interesting features. I still believe it is a good practice to write down food intake because it makes you aware of your choices. Later when more features are avaliable, these food logs will still be in the database.
Nutrition info via USDA National Nutrient Database
NLP corpora via NLTK
pip freeze:
alembic Flask Flask-Bcrypt Flask-Bootstrap Flask-Login Flask-Migrate Flask-Moment Flask-Script Flask-SQLAlchemy Flask-WTF itsdangerous Jinja2 nltk oauth requests SQLAlchemy tweepy Twisted Werkzeug WTForms{% endblock %}


I am an experienced software developer, trainer and technology enthusiast.
Product Development Training including Design Thinking, Prototyping etc. (Pilot at Exeter Premedia)
Design, Development and Execution of coding programs for students 8+
Courses in Scratch, AppInventor, Python, HTML/CSS/JS, Kotlin for Android
Manage hybrid and native mobile development projects.
Development and support of memory design software
Design, Development and marketing of Hybrid mobile development platform
Development and support of Storage Area Network firmware
Design and development of compiler based product for EDA companies
Compiler Enhancements and WatchPad, an embedded linux project!
GPA: 3.9
Apart from being a developer and trainer, I enjoy sports and music. I play most sports tolerably, and the dholak enough to accompany small groups satsangs :)
When indoors, I watch sports and movies, do some inspired (=neccesary!) cooking, and train a few kids in chess and coding.
I have a more than passing interest in the brain and how learning happens


Office of the Principal Accountant Nigerian National Petroleum Corporation {NNPC} Falomo Office Complex- Lagos - Nigeria Tel.: +234-802-2329001 Email<EMAIL_ADDRESS>Dear Sir, STRICTLY CONFIDENTIAL REQUEST FOR URGENT BUSINESS TRANSACTION I am CHIEF MAXWELL UDOKA, the Principal Accountant with the Nigerian National Petroleum Corporation {NNPC}, Headquarters Lagos. I am writing on behalf of my colleages in the Nigerian National Peretroleum Corporation {NNPC} and have been assigned to seek for the assistance of a reliable Foreign Company through which we can transfer the sum of Thirty One Million Five Hundred Thousand United States Dollars {USD$31,500,000.00}. This money is now depostied in the NNPC Treasur Accorunt with the Central bank of Nigeria {CBN}. ORIGIN OF THE FUND This sum arose from the deliberate over-invoicing of a contract awared by the NNPC to a Foreign Firm in the twinlight days of the last military regime. This contract has been completely executed and commisoned and the contractor that handled this contract has collected his full and final payment thus leaving behind the above stated amount which represent the over-invoiced sum. We have been safe-guarding this money waiting for conducive time for its transfer out of the country for our personal use. However, the code of employment does not allow us {civil servants} to own and operate foreign accounts and because the contract was handled by a foreign firm and the payment made in Dollars, we now need a foreign partner that will present himself as the sub-contractor so that the money will be transferred into his company's or personal account. Your address was made abailable to us by a very good friend who works with the Nigeria Chambers of Commerce and Industry. He assured us of your company's viability and capability in business transactions. This assurance gave us the courage to link you up in this pareticular transaction and I hope it will be of mutual benefit to all of us. Note that the nature of your business is not particularly relevant to the success of this transaction. All we require is your willingness to present yourself as the sub-contractor by providing your bank informations so that the fund will be transferred into your account. SHARING RATIO For your assistance in this business, your share will be 25% of the total money. I and my colleagues will take 65% while 10% has been mapped out for any expenses that might be incured in the course of this transaction. If you are willing to assist us in this business, send the following informations: 1.} Name of your Bank and address 2.} Your account number/beneficiary's name 3.} Your private telephone and fax numbers for easy communication This information will enable us put an application for payment approval to the concerned ministries and final to the Central Bank of Nigeria {CBN} and it is going to last for 10 to 14 banking days, starting from the day we recieve the above informations. All modalities for the take off of this business transaction has been worked out and further action will commence immediately we hear from you. I am waiting for your reply by the above email. Thanks for your understanding and due co-operation. CHIEF MAXWELL UDOKA.


EXIT WOUNDS A film review by Steve Rhodes Copyright 2001 Steve Rhodes RATING (0 TO ****): **
What happens if you single-handedly save the life of the Vice President, killing dozens of bad guys in the process and risking your own life? If you're Steven Seagal, you will, of course, get in trouble with your superiors for using excessive force.
EXIT WOUNDS, by director Andrzej Bartkowiak, a cinematographer whose only other directorial assignment was on ROMEO MUST DIE, is a standard issue Steven Seagal picture. With plenty of car crashes, loud explosions, noisy guns and corrupt cops, the script follows the usual formula. Only in the brief introduction of a dot-com subtheme does the film vary from the standard recipe. Why they needed two screenwriters (Ed Horowitz and Richard D'Ovidio) and one novelist (John Westermann) to come up with the canonical story is the only mystery.
The story opens hypocritically with the Vice President lecturing on the evils of guns in our society. After this sop to morality, the hyperviolence begins. Too bad they couldn't have gotten Quentin Tarantino to do a cameo as the Vice President. Now, that would have been funny.
Tom Arnold provides the movie's humor, playing controversial television host Henry Wayne. Officer Orin Boyd (Seagal) meets Wayne in a rageaholic meeting. Boyd is sent to the therapy session by his new commander, played by Jill Hennessy ("Law and Order"). Watching this intelligent actress being completely wasted in such a mindless role is embarrassing. One only hopes that she collected a sizeable paycheck for the part.
The plot involves drugs, with Latrill Walker (DMX) being the flashiest big-time dealer around. Going to a new car dealership, Latrill plunks down almost three hundred thousand in cash so he can drive away with the fastest and most expensive car on the showroom floor.
If you have a high tolerance for violence and like lots of stunt work, EXIT WOUNDS delivers. Sit on the front row so that you can get the maximum adrenaline rush. The movie is like a roller coaster ride at an amusement park, so you might as well go for maximum thrills. Those wanting a bit more substance for their entertainment dollars would be well advised to pick another theater door.
EXIT WOUNDS runs 1:40. It is rated R for strong violence, language and some sexuality/nudity and would be acceptable for older teenagers.
Web: http://www.InternetReviews.com Email<EMAIL_ADDRESS>Want free reviews and weekly movie and video recommendations via Email? Just send me a letter with the word "subscribe" in the subject line.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Elizabeth's Marvelous Movie Rating
Movies
Title
Director
Year
Rating
Poster URL
Add a Movie!
Add a Movie!
Title
Director
Year
Rating
Poster URL
submit
View/Edit a Movie!
View or Edit
Title
Director
Year
Rating
Poster URL
submit


{% extends "api/base.html" %} {% load static %} {% block head %} {% endblock %} {% block content %} {% block lazy_script %} {% endblock %}
From here you can download much of the historic data accumulated by the SmartCambridge project as 'comma separated variable' (CSV) files which can be imported into a range of tools for analysis. It is intended to be used interactively - to access this data from programs and apps you might be better off using our Program API.
The data is supplied in ZIP archives, each containing a single CSV file. Depending on data availability and file size, these files contain data for individual years and/or months and/or days.
The data is available to anyone, but you will need to authenticate to this platform and agree to the platform's Terms and Conditions before you can access it. You will be prompted to authenticate or to register for an account when you access the data.
{% for feed in feeds %}{{ feed.desc }}


Speaker: Dr Sara Johansson Fernstad
Time and Location: Monday 19th June 2017 10:45-12:00, Foyer Space, Ground Floor, The Core
Abstract: Missing data are records that are absent from a data set. They are data that were intended to be recorded, but for some reason were not. Missing data occur in almost any domain and is a common data analysis challenge that causes problems such as biased results and reduced statistical rigour. Although data visualization has great potential to provide invaluable support for the investigation of missing data, missing data challenges are rarely addressed by the visualization society. This talk will cover various concepts and aspects in missing data analysis, suggesting patterns of relevance for gaining further understanding of ‘missingness’ in datasets and present the result of an evaluation of different visual representations of missing data. It will also suggest some directions for designing visualization to support the understanding of ‘missingness’ in data.
← Go Back.


|
Client sends this SNAC when wants to retrieve messages that was sent by another
user and buffered by server during client was offline. Server should respond with
0 or more SNAC(15,03)/0041 packets with SNAC bit1=1
and after that it should send last SNAC(15,03)/0042.
Warn: Server doesn't delete messages from database and will send them again.
You should ask it to delete them by SNAC(15,02)/003E
| 00 15 |
|
word |
|
SNAC family |
| 00 02 |
|
word |
|
SNAC subtype |
| 00 00 |
|
word |
|
SNAC flags |
| xx xx xx xx |
|
dword |
|
SNAC request-id |
|
|
| |
| 00 01 |
|
word |
|
TLV.Type(1) - encapsulated META_DATA |
| 00 0A |
|
word |
|
TLV.Length |
|
|
| |
| 08 00 |
|
word (LE) |
|
data chunk size (TLV.Length-2) |
| xx xx xx xx |
|
dword (LE) |
|
client uin |
| 3C 00 |
|
word (LE) |
|
data type: offline message request cmd |
| xx xx |
|
word (LE) |
|
request sequence number |
|
|
| |
| |
|
|
| |
| |
|
|
|


{% extends 'base.html' %} {% block title %}Design Smells{% endblock %} {% block content %}
Showing details of that smell detected


ILF: Inductive Learning Framework
The Inductive Learning Framework provides a toolkit for people working with symbolic learning and rule abduction. It allows you to select data, identify features, select and test a learning algorithm. At all of these stages, you can either use the modules provided, or add your own. In particular, you will want to add your own learning modules - the ILF provides an easy way to test your learning algorithms against standard data sets.
This project is still under development.
Project repository
The code for the Inductive Learning Framework ishere: https://gitlab.fhnw.ch/bradley.richards/InductiveLearningFramework.


Join an application
You have been invited to join a new application into the competition 'Technology Inspired'.
Sign up to a new account, or sign in to an existing account to continue.
You have been invited to join a new application into the competition 'Technology Inspired'.
Sign up to a new account, or sign in to an existing account to continue.


Gasly: “I thought, okay I have these nine races where I’m going to show my skills"
by Joseph TyrrellPierre Gasly's 2019 was certainly a roller coaster as he faced promotion, demotion and a podium all in one season. The Frenchman has admitted he felt as if he had nine races to prove himself after returning to Toro Rosso.
Gasly started the season with Red Bull but the tone for his year was set at Albert Park as he missed out on the points on his debut. It gradually improved but during the summer break Red Bull took the decision to drop Gasly to Toro Rosso, and replace him with Alex Albon and that is how it will stay next season.
However, Gasly showed some signs of a resurgence at Toro Rosso, especially when he finished second in Brazil, ensuing jubilant scenes after the race. The Frenchman has admitted he was shocked and angry after receiving the news of his demotion.
“Of course when I got the news I was really shocked and kind of angry,” Gasly told Motorsportweek.com.
“I don’t feel it was fair, because these first six months were nowhere near what we should have shown. You do care, because you want to be in the fastest car.
“And I’ve tried to make changes in my way, and I’ve been promised things that in the end didn’t happen. There were many things that didn’t go in the right way.
“But at the end of the day this was the situation, it was done, it was passed, I couldn’t change it.
“I thought, okay, I have these nine races where I’m going to show my skills, my speed, my consistency, the things I’ve shown since I started single-seaters until I got to Red Bull."


--- layout: project title: Economic Decision-Making alongside a Robot shorttitle: Economic Decision-Making alongside a Robot location: Cornell University, USA type: robotics image: ebrd-project.jpg category: projects published: true year: 2018 duration: January 2018 - Ongoing collaborators: Alap Kshirsagar (Cornell), Bnaya Dreyfuss (HUJI), Guy Ishai (HUJI), Ori Heffetz (Cornell and HUJI), and Guy Hoffman (Cornell). --- {% include JB/setup %}
This project aims to study how people make decisions in the presence of robots when there are monetary rewards at stake.
This work is a collaboration between Behavioral Economists from Hibrew University of Jerusalem, Israel (HUJI) and Robotics Researchers from Cornell University, USA (Cornell)


Meow Shop
{#
#} {#
#} {#
{{ username }}
#} {#
#} {#
#}
登出
首页
会员套餐
订单列表
会员信息
{#
#}
当前所有套餐
1
-
3
of
3
results
名称
所属类型
测试专用商品
£ 1
Actor
商品已购买
test
123
{#
#}
Meow Shop is a full-featured mall, including background management, payment, order viewing, etc.
{#
#}
Contacts
ChaoYang, Beijing
+8618310703270 +8615600803270
<EMAIL_ADDRESS>Useful Links
About
Projects
Blog


How are contributions counted?
Following is the criteria for any user editorial to be considered -
- The problem must not have an Official editorial on the parent site.
- Editorial must be accepted by admin. Some common reasons for rejection maybe -
- - Formatting is not correct.
- - Editorial is submitted for a live contest.
- - Editorial has inappropriate content.
- - Submitted editorial is just a code snippet without any explanation.
- - Editorial is copied from a previous editorial.
- - Any other reason which might seem inappropriate for the platform.