final class Mat[T] extends NumericOps[Mat[T]]
Mat
is an immutable container for 2D homogeneous data (a "matrix"). It is
backed by a single array. Data is stored in row-major order.
Several element access methods are provided.
The at
method returns an instance of a org.saddle.scalar.Scalar, which
behaves much like an Option
in that it can be either an instance of
org.saddle.scalar.NA or a org.saddle.scalar.Value case class:
val m = Mat(2,2,Array(1,2,3,4)) m.at(0,0) == Value(1)
The method raw
accesses the underlying value directly.
val m = Mat(2,2,Array(1,2,3,4)) m.raw(0,0) == 1d
Mat
may be used in arithemetic expressions which operate on two Mat
s or
on a Mat
and a primitive value. A fe examples:
val m = Mat(2,2,Array(1,2,3,4)) m * m == Mat(2,2,Array(1,4,9,16)) m dot m == Mat(2,2,Array(7d,10,15,22)) m * 3 == Mat(2, 2, Array(3,6,9,12))
Note, Mat is generally compatible with EJML's DenseMatrix. It may be convenient to induce this conversion to do more complex linear algebra, or to work with a mutable data structure.
- Alphabetic
- By Inheritance
- Mat
- NumericOps
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
def
%[B, That](other: B)(implicit op: BinOp[Mod, Mat[T], B, That]): That
Integer modulus of division
Integer modulus of division
- B
type of the other operand
- That
result type of operation
- other
other operand instance (divisor)
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
%=[B](other: B)(implicit op: BinOpInPlace[Mod, Mat[T], B]): Unit
- Definition Classes
- NumericOps
-
def
&[B, That](other: B)(implicit op: BinOp[BitAnd, Mat[T], B, That]): That
Bit-wise AND
Bit-wise AND
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
&&[B, That](other: B)(implicit op: BinOp[AndOp, Mat[T], B, That]): That
Logical AND
Logical AND
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
*[B, That](other: B)(implicit op: BinOp[Multiply, Mat[T], B, That]): That
Multiplication
Multiplication
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
**[B, That](other: B)(implicit op: BinOp[Power, Mat[T], B, That]): That
Exponentiation
Exponentiation
- B
type of the other operand
- That
result type of operation
- other
other operand instance (exponent)
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
**=[B](other: B)(implicit op: BinOpInPlace[Power, Mat[T], B]): Unit
- Definition Classes
- NumericOps
-
def
*=[B](other: B)(implicit op: BinOpInPlace[Multiply, Mat[T], B]): Unit
- Definition Classes
- NumericOps
-
def
+[B, That](other: B)(implicit op: BinOp[Add, Mat[T], B, That]): That
Addition
Addition
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
+=[B](other: B)(implicit op: BinOpInPlace[Add, Mat[T], B]): Unit
- Definition Classes
- NumericOps
-
def
-[B, That](other: B)(implicit op: BinOp[Subtract, Mat[T], B, That]): That
Subtraction
Subtraction
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
-=[B](other: B)(implicit op: BinOpInPlace[Subtract, Mat[T], B]): Unit
- Definition Classes
- NumericOps
-
def
/[B, That](other: B)(implicit op: BinOp[Divide, Mat[T], B, That]): That
Division
Division
- B
type of the other operand
- That
result type of operation
- other
other operand instance (divisor)
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
/=[B](other: B)(implicit op: BinOpInPlace[Divide, Mat[T], B]): Unit
- Definition Classes
- NumericOps
-
def
<[B, That](other: B)(implicit op: BinOp[LtOp, Mat[T], B, That]): That
Less-than comparison operator
Less-than comparison operator
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
<<[B, That](other: B)(implicit op: BinOp[BitShl, Mat[T], B, That]): That
Bit-shift left
Bit-shift left
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
<=[B, That](other: B)(implicit op: BinOp[LteOp, Mat[T], B, That]): That
Less-than-or-equal-to comparison operator
Less-than-or-equal-to comparison operator
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
<>[B, That](other: B)(implicit op: BinOp[NeqOp, Mat[T], B, That]): That
Element-wise inequality operator
Element-wise inequality operator
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
=?[B, That](other: B)(implicit op: BinOp[EqOp, Mat[T], B, That]): That
Element-wise equality operator
Element-wise equality operator
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
>[B, That](other: B)(implicit op: BinOp[GtOp, Mat[T], B, That]): That
Greater-than comparison operator
Greater-than comparison operator
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
>=[B, That](other: B)(implicit op: BinOp[GteOp, Mat[T], B, That]): That
Greater-than-or-equal-to comparison operator
Greater-than-or-equal-to comparison operator
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
>>[B, That](other: B)(implicit op: BinOp[BitShr, Mat[T], B, That]): That
Bit-shift right (arithmetic)
Bit-shift right (arithmetic)
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
>>>[B, That](other: B)(implicit op: BinOp[BitUShr, Mat[T], B, That]): That
Bit-shift right (logical)
Bit-shift right (logical)
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
- def T: Mat[T]
-
def
^[B, That](other: B)(implicit op: BinOp[BitXor, Mat[T], B, That]): That
Bit-wise EXCLUSIVE OR
Bit-wise EXCLUSIVE OR
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
at(r: Slice[Int], c: Slice[Int]): Mat[T]
Access a slice of the Mat by Slice parameters
Access a slice of the Mat by Slice parameters
- r
Slice to apply to rows
- c
Slice to apply to cols
-
def
at(r: Int, c: Array[Int]): Vec[T]
Access a slice of the Mat by integer offsets
Access a slice of the Mat by integer offsets
- r
Integer row offset
- c
Array of col offsets
-
def
at(r: Array[Int], c: Int): Vec[T]
Access a slice of the Mat by integer offsets
Access a slice of the Mat by integer offsets
- r
Array of row offsets
- c
Integer col offset
-
def
at(r: Array[Int], c: Array[Int]): Mat[T]
Access a slice of the Mat by integer offsets
Access a slice of the Mat by integer offsets
- r
Array of row offsets
- c
Array of col offsets
-
def
at(r: Int, c: Int): Scalar[T]
Return scalar value of Mat at at row/column
Return scalar value of Mat at at row/column
- r
row index
- c
col index
-
def
at(i: Int): Scalar[T]
Return scalar value of matrix at offset from zero in row-major order
Return scalar value of matrix at offset from zero in row-major order
- i
index
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
col(slice: Slice[Int]): Mat[T]
Access mat columns specified by a slice
Access mat columns specified by a slice
- slice
a slice specifier
-
def
col(locs: Array[Int]): Mat[T]
Access Mat columns at a particular integer offsets
Access Mat columns at a particular integer offsets
- locs
an array of integer offsets
-
def
col(locs: Int*): Mat[T]
Access Mat columns at a particular integer offsets
Access Mat columns at a particular integer offsets
- locs
a sequence of integer offsets
-
def
col(c: Int): Vec[T]
Returns a specific column of the Mat as a Vec
Returns a specific column of the Mat as a Vec
- c
Column index
-
def
cols(seq: IndexedSeq[Int]): IndexedSeq[Vec[T]]
Returns columns of Mat as an indexed sequence of Vec instances
-
def
cols: IndexedSeq[Vec[T]]
Returns columns of Mat as an indexed sequence of Vec instances
-
def
colsWithNA: Set[Int]
Yields column indices where column has some NA value
-
def
concat(other: Mat[T]): Mat[T]
Concatenate this Mat to an other Mat vertically, i.e.
Concatenate this Mat to an other Mat vertically, i.e. concatenate as lists of rows
-
def
contents: Array[T]
Returns (a copy of) the contents of matrix as a single array in row-major order
-
def
copy: Mat[T]
Makes a copy of this Mat
-
def
dot[B, That](other: B)(implicit op: BinOp[InnerProd, Mat[T], B, That]): That
Dot (inner) product
Dot (inner) product
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
dropColsWithNA: Mat[T]
Yields a matrix without those cols that have NA
-
def
dropRowsWithNA: Mat[T]
Yields a matrix without those rows that have NA
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(o: Any): Boolean
Row-by-row equality check of all values.
Row-by-row equality check of all values.
- Definition Classes
- Mat → AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
Default hashcode is simple rolling prime multiplication of sums of hashcodes for all values.
Default hashcode is simple rolling prime multiplication of sums of hashcodes for all values.
- Definition Classes
- Mat → AnyRef → Any
-
def
isEmpty: Boolean
Returns true if the matrix is empty
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
isSquare: Boolean
Returns true if rows == cols
-
def
length: Int
Returns total number of entries in the matrix
- def map[B](f: (T) ⇒ B)(implicit arg0: ST[B]): Mat[B]
-
def
mapCols[B](f: (Vec[T], Int) ⇒ Vec[B])(implicit arg0: ST[B]): Mat[B]
Maps a function over each col in the matrix f must return a Vec with numRows elements
-
def
mapRows[B](f: (Vec[T], Int) ⇒ Vec[B])(implicit arg0: ST[B]): Mat[B]
Maps a function over each row in the matrix f must return a Vec with numCols elements
-
def
mutateCols(f: (Vec[T], Int) ⇒ Vec[T]): Unit
In place mutate cols of the matrix
-
def
mutateRows(f: (Vec[T], Int) ⇒ Vec[T]): Unit
In place mutate rows of the matrix
-
def
mutateSetCell(r: Int, c: Int, v: T): Unit
- Annotations
- @inline()
- def mutateSetColumn(c: Int, v: T): Unit
- def mutateSetDiagonal(v: T): Unit
- def mutateSetLowerTriangle(v: T): Unit
- def mutateSetRow(r: Int, v: T): Unit
- def mutateSetUpperTriangle(v: T): Unit
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- val numCols: Int
- val numRows: Int
-
def
outer[B, That](other: B)(implicit op: BinOp[OuterProd, Mat[T], B, That]): That
Outer product
Outer product
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
print(nrows: Int = 8, ncols: Int = 8, stream: OutputStream = System.out): Unit
Pretty-printer for Mat, which simply outputs the result of stringify.
Pretty-printer for Mat, which simply outputs the result of stringify.
- nrows
Number of elements to display
-
def
raw(r: Int, c: Int): T
Return unboxed value of matrix at row/column
Return unboxed value of matrix at row/column
- r
row index
- c
col index
- Annotations
- @inline()
-
def
raw(i: Int): T
Return unboxed value of matrix at an offset from zero in row-major order
Return unboxed value of matrix at an offset from zero in row-major order
- i
index
- Annotations
- @inline()
-
def
reduceCols[B](f: (Vec[T], Int) ⇒ B)(implicit arg0: ST[B]): Vec[B]
Reduces each col with a function f must return a scalar
-
def
reduceRows[B](f: (Vec[T], Int) ⇒ B)(implicit arg0: ST[B]): Vec[B]
Reduces each row with a function f must return a scalar
-
def
reshape(r: Int, c: Int): Mat[T]
Changes the shape of matrix without changing the underlying data
Changes the shape of matrix without changing the underlying data
Backing array will be shared between the two instances!
-
def
roundTo(sig: Int = 2)(implicit ev: NUM[T]): Mat[Double]
Rounds elements in the matrix (which must be numeric) to a significance level
Rounds elements in the matrix (which must be numeric) to a significance level
- sig
Significance level to round to (e.g., 2 decimal places)
-
def
row(slice: Slice[Int]): Mat[T]
Access Mat rows specified by a slice
Access Mat rows specified by a slice
- slice
a slice specifier
-
def
row(locs: Array[Int]): Mat[T]
Access Mat rows at a particular integer offsets
Access Mat rows at a particular integer offsets
- locs
an array of integer offsets
-
def
row(locs: Int*): Mat[T]
Access Mat rows at a particular integer offsets
Access Mat rows at a particular integer offsets
- locs
a sequence of integer offsets
-
def
row(r: Int): Vec[T]
Returns a specific row of the Mat as a Vec
Returns a specific row of the Mat as a Vec
- r
Row index
-
def
rows(seq: IndexedSeq[Int]): IndexedSeq[Vec[T]]
Returns rows of matrix as an indexed sequence of Vec instances
-
def
rows: IndexedSeq[Vec[T]]
Returns rows of matrix as an indexed sequence of Vec instances
-
def
rowsWithNA: Set[Int]
Yields row indices where row has some NA value
- val scalarTag: ScalarTag[T]
-
def
stringify(nrows: Int = 8, ncols: Int = 8): String
Creates a string representation of Mat
Creates a string representation of Mat
- nrows
Max number of rows to include
- ncols
Max number of cols to include
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
takeCols(locs: Int*): Mat[T]
Create Mat comprised of same values in specified columns
-
def
takeCols(locs: Array[Int]): Mat[T]
Create Mat comprised of same values in specified columns
-
def
takeRows(locs: Int*): Mat[T]
Create Mat comprised of same values in specified rows
- def takeRows(locs: Vec[Int]): Mat[T]
- def takeRows(locs: Array[Int]): Mat[T]
-
def
toArray: Array[T]
Returns the backing array of this Mat Mutations to this array are visible to this Mat
Returns the backing array of this Mat Mutations to this array are visible to this Mat
Elements are laid out in row-major order
-
def
toFrame: Frame[Int, Int, T]
Converst to Frame
-
def
toString(): String
- Definition Classes
- Mat → AnyRef → Any
-
def
toVec: Vec[T]
Concatenate all rows into a single row-wise Vec instance
Concatenate all rows into a single row-wise Vec instance
Underlying array is shared between the two instances
- def transpose: Mat[T]
-
def
update(r: Int, c: Int, v: T): Unit
- Annotations
- @inline()
-
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( ... ) @native()
-
def
withoutCols(locs: Int*): Mat[T]
Create Mat comprised of same values without the specified columns
Create Mat comprised of same values without the specified columns
- locs
Col locations to exclude
-
def
withoutCols(locs: Array[Int]): Mat[T]
Create Mat comprised of same values without the specified columns
Create Mat comprised of same values without the specified columns
- locs
Col locations to exclude
-
def
withoutRows(locs: Int*): Mat[T]
Create Mat comprised of same values without the specified rows
Create Mat comprised of same values without the specified rows
- locs
Row locations to exclude
-
def
withoutRows(locs: Array[Int]): Mat[T]
Create Mat comprised of same values without the specified rows
Create Mat comprised of same values without the specified rows
- locs
Row locations to exclude
-
def
xor[B, That](other: B)(implicit op: BinOp[XorOp, Mat[T], B, That]): That
Logical EXCLUSIVE OR
Logical EXCLUSIVE OR
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
|[B, That](other: B)(implicit op: BinOp[BitOr, Mat[T], B, That]): That
Bit-wise OR
Bit-wise OR
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps
-
def
||[B, That](other: B)(implicit op: BinOp[OrOp, Mat[T], B, That]): That
Logical OR
Logical OR
- B
type of the other operand
- That
result type of operation
- other
other operand instance
- op
implicit evidence for operation between this and other
- Definition Classes
- NumericOps