Mat

Companion object Mat

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 arithmetic expressions which operate on two Mats 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.

Linear Supertypes

NumericOps[Mat[T]], AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

Mat
NumericOps
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

Instance Constructors

new Mat(numRows: Int, numCols: Int, values: Array[T], scalarTag: ScalarTag[T])

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(classOf[java.lang.CloneNotSupportedException]) @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[_ <: AnyRef]
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(classOf[java.lang.InterruptedException])
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @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

Packages

Saddle

Mat

Companion object Mat

final class Mat[T] extends NumericOps[Mat[T]]

Instance Constructors

Value Members

Inherited from NumericOps[Mat[T]]

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Saddle

Mat

Companion object Mat

final class Mat[T] extends NumericOps[Mat[T]]

Instance Constructors

Value Members

Inherited from NumericOps[Mat[T]]

Inherited from AnyRef

Inherited from Any

Ungrouped

Mat