Mat

abstract def copy: Mat[A]

Copy of original matrix

abstract def foldLeft[B](init: B)(f: (B, A) ⇒ B): B

Performs a left fold over each element in the matrix in row-major order using a function (B, A) => B

abstract def map[B](f: (A) ⇒ B)(implicit arg0: ST[B]): Mat[B]

Maps a function over each element in the matrix

abstract def numCols: Int

Returns number of columns in the matrix shape

abstract def numRows: Int

Returns number of rows in the matrix shape

abstract def reshape(r: Int, c: Int): Mat[A]

Changes the shape of matrix without changing the underlying data

abstract def scalarTag: ScalarTag[A]

abstract def takeRows(locs: Array[Int]): Mat[A]

Create Mat comprised of same values in specified rows

abstract def transpose: Mat[A]

Transpose of original matrix

abstract def withoutRows(locs: Array[Int]): Mat[A]

Create Mat comprised of same values without the specified rows

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def %[B, That](other: B)(implicit op: BinOp[Mod, Mat[A], B, That]): That

Integer modulus of division

def &[B, That](other: B)(implicit op: BinOp[BitAnd, Mat[A], B, That]): That

Bit-wise AND

def &&[B, That](other: B)(implicit op: BinOp[AndOp, Mat[A], B, That]): That

Logical AND

def *[B, That](other: B)(implicit op: BinOp[Multiply, Mat[A], B, That]): That

Multiplication

def **[B, That](other: B)(implicit op: BinOp[Power, Mat[A], B, That]): That

Exponentiation

def +[B, That](other: B)(implicit op: BinOp[Add, Mat[A], B, That]): That

Addition

def -[B, That](other: B)(implicit op: BinOp[Subtract, Mat[A], B, That]): That

Subtraction

def /[B, That](other: B)(implicit op: BinOp[Divide, Mat[A], B, That]): That

Division

def <[B, That](other: B)(implicit op: BinOp[LtOp, Mat[A], B, That]): That

Less-than comparison operator

def <<[B, That](other: B)(implicit op: BinOp[BitShl, Mat[A], B, That]): That

Bit-shift left

def <=[B, That](other: B)(implicit op: BinOp[LteOp, Mat[A], B, That]): That

Less-than-or-equal-to comparison operator

def <>[B, That](other: B)(implicit op: BinOp[NeqOp, Mat[A], B, That]): That

Element-wise inequality operator

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def =?[B, That](other: B)(implicit op: BinOp[EqOp, Mat[A], B, That]): That

Element-wise equality operator

def >[B, That](other: B)(implicit op: BinOp[GtOp, Mat[A], B, That]): That

Greater-than comparison operator

def >=[B, That](other: B)(implicit op: BinOp[GteOp, Mat[A], B, That]): That

Greater-than-or-equal-to comparison operator

def >>[B, That](other: B)(implicit op: BinOp[BitShr, Mat[A], B, That]): That

Bit-shift right (arithmetic)

def >>>[B, That](other: B)(implicit op: BinOp[BitUShr, Mat[A], B, That]): That

Bit-shift right (logical)

def T: Mat[A]

Transpose of original matrix

def ^[B, That](other: B)(implicit op: BinOp[BitXor, Mat[A], B, That]): That

Bit-wise EXCLUSIVE OR

final def asInstanceOf[T0]: T0

def at(r: Int, c: Int): Scalar[A]

Return scalar value of matrix at at row/column

def at(i: Int): Scalar[A]

Return scalar value of matrix at offset from zero in row-major order

def clone(): AnyRef

def col(c: Int)(implicit ev: ST[A]): Vec[A]

Returns a specific column of the Mat as a Vec

def cols()(implicit ev: ST[A]): IndexedSeq[Vec[A]]

Returns columns of matrix as an indexed sequence of Vec instances

def colsWithNA(implicit ev: ST[A]): Set[Int]

Yields column indices where column has some NA value

def contents: Array[A]

Returns (a copy of) the contents of matrix as a single array in row-major order

def dot[B, That](other: B)(implicit op: BinOp[InnerProd, Mat[A], B, That]): That

Dot (inner) product

def dropColsWithNA(implicit ev: ST[A]): Mat[A]

Yields a matrix without those cols that have NA

def dropRowsWithNA(implicit ev: ST[A]): Mat[A]

Yields a matrix without those rows that have NA

final def eq(arg0: AnyRef): Boolean

def equals(o: Any): Boolean

Row-by-row equality check of all values.

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

Default hashcode is simple rolling prime multiplication of sums of hashcodes for all values.

def isEmpty: Boolean

Returns true if the matrix is empty

final def isInstanceOf[T0]: Boolean

def isSquare: Boolean

Returns true if rows == cols

def length: Int

Returns total number of entries in the matrix

def mult[B](m: Mat[B])(implicit evA: NUM[A], evB: NUM[B]): Mat[Double]

Multiplies this matrix against another

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def outer[B, That](other: B)(implicit op: BinOp[OuterProd, Mat[A], B, That]): That

Outer product

def print(nrows: Int = 8, ncols: Int = 8, stream: OutputStream = System.out): Unit

Pretty-printer for Mat, which simply outputs the result of stringify.

def raw(r: Int, c: Int): A

Return unboxed value of matrix at row/column

def raw(i: Int): A

Return unboxed value of matrix at an offset from zero in row-major order

def roundTo(sig: Int = 2)(implicit ev: NUM[A]): Mat[Double]

Rounds elements in the matrix (which must be numeric) to a significance level

def row(r: Int)(implicit ev: ST[A]): Vec[A]

Returns a specific row of the Mat as a Vec

def rows()(implicit ev: ST[A]): IndexedSeq[Vec[A]]

Returns rows of matrix as an indexed sequence of Vec instances

def rowsWithNA(implicit ev: ST[A]): Set[Int]

Yields row indices where row has some NA value

def stringify(nrows: Int = 8, ncols: Int = 8): String

Creates a string representation of Mat

final def synchronized[T0](arg0: ⇒ T0): T0

def takeCols(locs: Array[Int]): Mat[A]

Create Mat comprised of same values in specified columns

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withoutCols(locs: Array[Int]): Mat[A]

Create Mat comprised of same values without the specified columns

def xor[B, That](other: B)(implicit op: BinOp[XorOp, Mat[A], B, That]): That

Logical EXCLUSIVE OR

def |[B, That](other: B)(implicit op: BinOp[BitOr, Mat[A], B, That]): That

Bit-wise OR

def ||[B, That](other: B)(implicit op: BinOp[OrOp, Mat[A], B, That]): That

Logical OR