class MatrixN[T] extends Matrix[T] with Error with Serializable
The MatrixN class stores and operates on Numeric Matrices of various sizes
and types. The element type may be any subtype of Numeric.
- Alphabetic
- By Inheritance
- MatrixN
- Serializable
- Serializable
- Matrix
- Error
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
-
new
MatrixN(u: MatrixN[T])(implicit arg0: ClassTag[T], arg1: Numeric[T])
Construct a matrix and assign values from matrix 'u'.
Construct a matrix and assign values from matrix 'u'.
- u
the matrix of values to assign
-
new
MatrixN(u: Array[VectorN[T]])(implicit arg0: ClassTag[T], arg1: Numeric[T])
Construct a matrix and assign values from array of vectors 'u'.
Construct a matrix and assign values from array of vectors 'u'.
- u
the 2D array of values to assign
-
new
MatrixN(dim: (Int, Int), u: T*)(implicit arg0: ClassTag[T], arg1: Numeric[T])
Construct a matrix from repeated values.
Construct a matrix from repeated values.
- dim
the (row, column) dimensions
- u
the repeated values
-
new
MatrixN(u: Array[Array[T]])(implicit arg0: ClassTag[T], arg1: Numeric[T])
Construct a matrix and assign values from array of arrays 'u.'
Construct a matrix and assign values from array of arrays 'u.'
- u
the 2D array of values to assign
-
new
MatrixN(dim1: Int, x: T, y: T)(implicit arg0: ClassTag[T], arg1: Numeric[T])
Construct a 'dim1-by-dim1' square matrix with 'x' assigned on the diagonal and y assigned off the diagonal.
Construct a 'dim1-by-dim1' square matrix with 'x' assigned on the diagonal and y assigned off the diagonal. To obtain an identity matrix, let 'x = 1' and 'y = 0'.
- dim1
the row and column dimension
- x
the scalar value to assign on the diagonal
- y
the scalar value to assign off the diagonal
-
new
MatrixN(dim1: Int, dim2: Int, x: T)(implicit arg0: ClassTag[T], arg1: Numeric[T])
Construct a 'dim1-by-dim2' matrix and assign each element the value 'x'.
Construct a 'dim1-by-dim2' matrix and assign each element the value 'x'.
- dim1
the row dimension
- dim2
the column dimension
- x
the scalar value to assign
-
new
MatrixN(dim1: Int)(implicit arg0: ClassTag[T], arg1: Numeric[T])
Construct a 'dim1-by-dim1' square matrix.
Construct a 'dim1-by-dim1' square matrix.
- dim1
the row and column dimension
-
new
MatrixN(d1: Int, d2: Int, v: Array[Array[T]] = null)(implicit arg0: ClassTag[T], arg1: Numeric[T])
- d1
the first/row dimension
- d2
the second/column dimension
- v
the 2D array used to store matrix elements
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
def
*(x: T): MatrixN[T]
Multiply this matrix by scalar 'x'.
-
def
*(u: VectorD): VectorD
Multiply this matrix by vector 'u' (efficient solution).
Multiply this matrix by vector 'u' (efficient solution).
- u
the vector to multiply by
-
def
*(u: VectorN[T]): VectorN[T]
Multiply this matrix by vector 'u' (efficient solution).
-
def
*(b: MatrixN[T]): MatrixN[T]
Multiply this matrix by matrix 'b' (efficient solution).
Multiply this matrix by matrix 'b' (efficient solution).
- b
the matrix to multiply by (requires 'sameCrossDimensions')
-
def
**(u: VectorN[T]): MatrixN[T]
Multiply this matrix by vector 'u' to produce another matrix 'a_ij * b_j'.
-
def
**=(u: VectorN[T]): MatrixN[T]
Multiply in-place this matrix by vector 'u' to produce another matrix 'a_ij * b_j'.
-
def
*=(x: T): MatrixN[T]
Multiply in-place this matrix by scalar 'x'.
-
def
*=(b: MatrixN[T]): MatrixN[T]
Multiply in-place this matrix by matrix 'b'.
Multiply in-place this matrix by matrix 'b'. If 'b' and this reference the same matrix 'b == this', a copy of the this matrix is made.
- b
the matrix to multiply by (requires square and 'sameCrossDimensions')
-
def
+(x: T): MatrixN[T]
Add this matrix and scalar 'x'.
-
def
+(u: MatrixN[T]): MatrixN[T]
Add this matrix and matrix 'u'.
Add this matrix and matrix 'u'.
- u
the matrix to add (requires 'leDimensions')
-
def
++(u: VectorN[T]): MatrixN[T]
Concatenate this matrix and vector 'u'.
-
def
+=(x: T): MatrixN[T]
Add in-place this matrix and scalar 'x'.
-
def
+=(b: MatrixN[T]): MatrixN[T]
Add in-place this matrix and matrix 'b'.
Add in-place this matrix and matrix 'b'.
- b
the matrix to add (requires 'leDimensions')
-
def
-(x: T): MatrixN[T]
From this matrix subtract scalar 'x'.
-
def
-(b: MatrixN[T]): MatrixN[T]
From this matrix subtract matrix 'b'.
From this matrix subtract matrix 'b'.
- b
the matrix to subtract (requires 'leDimensions')
-
def
-=(x: T): MatrixN[T]
From this matrix subtract in-place scalar x.
-
def
-=(b: MatrixN[T]): MatrixN[T]
From this matrix subtract in-place matrix 'b'.
From this matrix subtract in-place matrix 'b'.
- b
the matrix to subtract (requires 'leDimensions')
-
def
/(x: T)(implicit fr: Fractional[T]): MatrixN[T]
Divide this matrix by scalar 'x'.
-
def
/=(x: T)(implicit fr: Fractional[T]): MatrixN[T]
Divide in-place this matrix by scalar 'x'.
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
val
_0: T
Numeric zero (0)
-
val
_1: T
Numeric one (1)
-
val
_1n: T
Numeric minus one (-1)
-
def
apply(i: Int, jr: Range): VectorN[T]
Get a slice this matrix row-wise at index 'i' and column-wise on range 'jr'.
-
def
apply(ir: Range, j: Int): VectorN[T]
Get a slice this matrix row-wise on range 'ir' and column-wise at index 'j'.
-
def
apply(ir: Range, jr: Range): MatrixN[T]
Get a slice this matrix row-wise on range 'ir' and column-wise on range 'jr'.
-
def
apply(i: Int): VectorN[T]
Get this matrix's vector at the 'i'th index position ('i'th row).
-
def
apply(i: Int, j: Int): T
Get this matrix's element at the 'i,j'-th index position.
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clean(thres: T, relative: Boolean = true)(implicit fr: Fractional[T]): MatrixN[T]
Clean values in matrix at or below the threshold by setting them to zero.
Clean values in matrix at or below the threshold by setting them to zero. Iterative algorithms give approximate values and if very close to zero, may throw off other calculations, e.g., in computing eigenvectors.
- thres
the cutoff threshold (a small value)
- relative
whether to use relative or absolute cutoff
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
def
col(col: Int, from: Int = 0): VectorN[T]
Get column 'col' from the matrix, returning it as a vector.
- val d1: Int
- val d2: Int
-
def
det: T
Compute the determinant of this matrix.
-
def
diag(p: Int, q: Int): MatrixN[T]
Form a matrix '[Ip, this, Iq]' where 'Ir' is a 'r-by-r' identity matrix, by positioning the three matrices 'Ip', this and 'Iq' along the diagonal.
-
def
diag(b: MatrixN[T]): MatrixN[T]
Combine this matrix with matrix 'b', placing them along the diagonal and filling in the bottom left and top right regions with zeros; '[this, b]'.
Combine this matrix with matrix 'b', placing them along the diagonal and filling in the bottom left and top right regions with zeros; '[this, b]'.
- b
the matrix to combine with this matrix
-
lazy val
dim1: Int
Dimension 1
-
lazy val
dim2: Int
Dimension 2
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
flaw(method: String, message: String): Unit
Show the flaw by printing the error message.
Show the flaw by printing the error message.
- method
the method where the error occurred
- message
the error message
- Definition Classes
- Error
-
def
foreach[U](f: (Array[T]) ⇒ U): Unit
Iterate over the matrix row by row.
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
-
def
getDiag(k: Int = 0): VectorN[T]
Get 'k'th main diagonal of this matrix.
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
-
def
inverse(implicit fr: Fractional[T]): MatrixN[T]
Invert this matrix (requires a 'squareMatrix') using partial pivoting.
-
def
inverse_ip(implicit fr: Fractional[T]): MatrixN[T]
Invert in-place this matrix (requires a 'squareMatrix') using partial pivoting.
-
def
inverse_npp(implicit fr: Fractional[T]): MatrixN[T]
Invert this matrix (requires a 'squareMatrix') not using partial pivoting.
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
isNonnegative: Boolean
Check whether this matrix is nonnegative (has no negative elements).
-
def
isRectangular: Boolean
Check whether this matrix is rectangular (all rows have the same number of columns).
-
def
isSquare: Boolean
Check whether this matrix is square (same row and column dimensions).
Check whether this matrix is square (same row and column dimensions).
- Definition Classes
- Matrix
-
def
isSymmetric: Boolean
Check whether this matrix is symmetric.
Check whether this matrix is symmetric.
- Definition Classes
- Matrix
-
def
leDimensions(b: Matrix[T]): Boolean
Check whether this matrix dimensions are less than or equal to 'le' those of the other Matrix.
Check whether this matrix dimensions are less than or equal to 'le' those of the other Matrix.
- b
the other matrix
- Definition Classes
- Matrix
-
def
lud(implicit fr: Fractional[T]): (MatrixN[T], MatrixN[T])
Decompose this matrix into the product of lower and upper triangular matrices '(l, u)' using the 'LU' Decomposition algorithm.
-
def
lud_ip(implicit fr: Fractional[T]): (MatrixN[T], MatrixN[T])
Decompose in-place this matrix into the product of lower and upper triangular matrices '(l, u)' using the 'LU' Decomposition algorithm.
-
def
lud_npp(implicit fr: Fractional[T]): (MatrixN[T], MatrixN[T])
Decompose this matrix into the product of upper and lower triangular matrices '(l, u)' using the 'LU' Decomposition algorithm.
Decompose this matrix into the product of upper and lower triangular matrices '(l, u)' using the 'LU' Decomposition algorithm. This version uses no partial pivoting.
-
def
mag: T
Find the magnitude of this matrix, the element value farthest from zero.
-
def
max(e: Int = dim1): T
Find the maximum element in this matrix.
-
def
min(e: Int = dim1): T
Find the minimum element in this matrix.
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
norm1: T
Compute the 1-norm of this matrix, i.e., the maximum 1-norm of the column vectors.
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
-
val
nu: Numeric[T]
Import Numeric evidence (gets nu val from superclass)
-
def
nullspace(implicit fr: Fractional[T]): VectorN[T]
Compute the (right) nullspace of this 'm-by-n' matrix (requires 'n = m + 1') by performing Gauss-Jordan reduction and extracting the negation of the last column augmented by 1.
Compute the (right) nullspace of this 'm-by-n' matrix (requires 'n = m + 1') by performing Gauss-Jordan reduction and extracting the negation of the last column augmented by 1. The nullspace of matrix 'a' is "this vector 'v' times any scalar 's'", i.e., 'a*(v*s) = 0'. The left nullspace of matrix 'a' is the same as the right nullspace of 'a.t' ('a' transpose).
-
def
nullspace_ip(implicit fr: Fractional[T]): VectorN[T]
Compute the (right) nullspace in-place of this 'm-by-n' matrix (requires 'n = m + 1') by performing Gauss-Jordan reduction and extracting the negation of the last column augmented by 1.
Compute the (right) nullspace in-place of this 'm-by-n' matrix (requires 'n = m + 1') by performing Gauss-Jordan reduction and extracting the negation of the last column augmented by 1. The nullspace of matrix 'a' is "this vector 'v' times any scalar 's'", i.e., 'a*(v*s) = 0'. The left nullspace of matrix 'a' is the same as the right nullspace of 'a.t' ('a' transpose).
-
val
range1: Range
Range for the storage array on dimension 1 (rows)
Range for the storage array on dimension 1 (rows)
- Attributes
- protected
- Definition Classes
- Matrix
-
val
range2: Range
Range for the storage array on dimension 2 (columns)
Range for the storage array on dimension 2 (columns)
- Attributes
- protected
- Definition Classes
- Matrix
-
def
rank(implicit fr: Fractional[T]): Int
Determine the rank of this 'm-by-n' matrix by taking the upper triangular matrix from the 'LU' Decomposition and counting the number of non-zero diagonal elements.
Determine the rank of this 'm-by-n' matrix by taking the upper triangular matrix from the 'LU' Decomposition and counting the number of non-zero diagonal elements. FIX: should implement in implementing classes.
- Definition Classes
- Matrix
-
def
reduce(implicit fr: Fractional[T]): MatrixN[T]
Use Gauss-Jordan reduction on this matrix to make the left part embed an identity matrix.
-
def
reduce_ip(implicit fr: Fractional[T]): Unit
Use Gauss-Jordan reduction in-place on this matrix to make the left part embed an identity matrix.
-
def
sameCrossDimensions(b: Matrix[T]): Boolean
Check whether this matrix and the other matrix have the same cross dimensions.
Check whether this matrix and the other matrix have the same cross dimensions.
- b
the other matrix
- Definition Classes
- Matrix
-
def
sameDimensions(b: Matrix[T]): Boolean
Check whether this matrix and the other Matrix have the same dimensions.
Check whether this matrix and the other Matrix have the same dimensions.
- b
the other matrix
- Definition Classes
- Matrix
-
def
selectCols(colIndex: Array[Int]): MatrixN[T]
Select columns from this matrix according to the given index/basis.
-
def
selectRows(rowIndex: Array[Int]): MatrixN[T]
Select rows from this matrix according to the given index/basis.
-
def
set(i: Int, u: VectorN[T], j: Int = 0): Unit
Set this matrix's 'i'th row starting at column 'j' to the vector 'u'.
-
def
set(u: Array[Array[T]]): Unit
Set all the values in this matrix as copies of the values in 2D array 'u'.
-
def
set(x: T): Unit
Set all the elements in this matrix to the scalar 'x'.
-
def
setCol(col: Int, u: VectorN[T]): Unit
Set column 'col' of the matrix to a vector.
-
def
setDiag(x: T): Unit
Set the main diagonal of this matrix to the scalar 'x'.
-
def
setDiag(u: VectorN[T], k: Int = 0): Unit
Set the 'k'th diagonal of this matrix to the vector 'u'.
-
def
slice(r_from: Int, r_end: Int, c_from: Int, c_end: Int): MatrixN[T]
Slice this matrix row-wise 'r_from' to 'r_end' and column-wise 'c_from' to 'c_end'.
-
def
slice(from: Int, end: Int): MatrixN[T]
Slice this matrix row-wise 'from' to 'end'.
-
def
sliceExclude(row: Int, col: Int): MatrixN[T]
Slice this matrix excluding the given row and column.
-
def
solve(b: VectorN[T])(implicit fr: Fractional[T]): VectorN[T]
Solve for 'x' in the equation 'a*x = b' where 'a' is this matrix (see 'lud' above).
-
def
solve(lu: (Matrix[T], Matrix[T]), b: VectorN[T])(implicit fr: Fractional[T]): VectorN[T]
Solve for 'x' in the equation 'l*u*x = b' (see 'lud' above).
-
def
solve(l: Matrix[T], u: Matrix[T], b: VectorN[T])(implicit fr: Fractional[T]): VectorN[T]
Solve for 'x' in the equation 'l*u*x = b' (see 'lud' above).
-
def
sum: T
Compute the sum of this matrix, i.e., the sum of its elements.
-
def
sumAbs: T
Compute the 'abs' sum of this matrix, i.e., the sum of the absolute value of its elements.
-
def
sumLower: T
Compute the sum of the lower triangular region of this matrix.
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
t: MatrixN[T]
Transpose this matrix (rows => columns).
-
def
toString(): String
Convert this matrix to a string.
Convert this matrix to a string.
- Definition Classes
- MatrixN → AnyRef → Any
-
def
trace: T
Compute the trace of this matrix, i.e., the sum of the elements on the main diagonal.
-
def
update(i: Int, jr: Range, u: VectorN[T]): Unit
Set a slice this matrix row-wise at index 'i' and column-wise on range 'jr'.
-
def
update(ir: Range, j: Int, u: VectorN[T]): Unit
Set a slice this matrix row-wise on range 'ir' and column-wise at index 'j'.
-
def
update(ir: Range, jr: Range, b: MatrixN[T]): Unit
Set a slice this matrix row-wise on range 'ir' and column-wise on range 'jr'.
Set a slice this matrix row-wise on range 'ir' and column-wise on range 'jr'. Ex: a(2..4, 3..5) = b
- ir
the row range
- jr
the column range
- b
the matrix to assign
-
def
update(i: Int, u: VectorN[T]): Unit
Set this matrix's row at the 'i'th index position to the vector 'u'.
-
def
update(i: Int, j: Int, x: T): Unit
Set this matrix's element at the 'i,j'-th index position to the scalar 'x'.
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
def
~^(p: Int): MatrixN[T]
Raise this matrix to the 'p'th power (for some integer 'p >= 2').