RLikeMatrixOps

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

def !==(that: Matrix): Boolean

final def ##(): Int

def %*%(that: Vector): Vector

matrix-vector multiplication

def %*%(that: Matrix): Matrix

Structure-optimized mmul

def %*%:(that: Matrix): Matrix

def *(that: Double): Matrix

def *(that: Matrix): Matrix

Hadamard product

def *:(that: Double): Matrix

def *=(that: Double): Matrix

def *=(that: Matrix): Matrix

in-place Hadamard product.

def *=:(that: Double): Matrix

5.

def *=:(that: Matrix): Matrix

A *=: B is equivalent to B *= A.

def +(that: Double): Matrix

def +(that: Matrix): Matrix

def +:(that: Double): Matrix

def +=(that: Double): Matrix

def +=(that: Matrix): Matrix

def +=:(that: Double): Matrix

def +=:(that: Matrix): Matrix

def -(that: Double): Matrix

def -(that: Matrix): Matrix

def -:(that: Double): Matrix

def -:(that: Matrix): Matrix

def -=(that: Double): Matrix

def -=(that: Matrix): Matrix

def -=:(that: Matrix): Matrix

A := B - A which is -(A - B)

def -=:(that: Double): Matrix

def /(that: Double): Matrix

def /(that: Matrix): Matrix

def /:(that: Double): Matrix

1.

def /:(that: Matrix): Matrix

def /=(that: Double): Matrix

def /=(that: Matrix): Matrix

Elementwise deletion

def /=:(that: Double): Matrix

1.

def :%*%(that: Matrix): Matrix

def ::=(f: (Double) ⇒ Double): Matrix

Sparse function assign: iterate and assign over non-zeros only

def ::=(f: (Int, Int, Double) ⇒ Double): Matrix

Sparse assign: iterate and assign over non-zeros only

def :=(f: (Double) ⇒ Double): Matrix

Functional assign with (Double) => Double

def :=(f: (Int, Int, Double) ⇒ Double): Matrix

def :=(that: Double): Matrix

def :=(that: TraversableOnce[Vector]): Unit

Assigning from a row-wise collection of vectors

def :=(that: Matrix): Matrix

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def ===(that: Matrix): Boolean

def ^(that: Double): Matrix

def ^=(that: Double): Matrix

def apply(rowRange: Range, col: Int): Vector

def apply(row: Int, colRange: Range): Vector

def apply(rowRange: Range, colRange: Range): Matrix

def apply(row: Int, col: Int): Double

final def asInstanceOf[T0]: T0

def cbind(that: Double): Matrix

def cbind(that: Matrix): Matrix

def clone(): AnyRef

def cloned: Matrix

def colMeans(): Vector

def colSums(): Vector

def det: Double

def diagv: Vector

def diagv_=(that: Double): Vector

def diagv_=(that: Vector): Vector

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def equiv(that: Matrix): Boolean

Ideally, we would probably want to override equals().

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def isFullRank: Boolean

test if rank == min(nrow,ncol).

final def isInstanceOf[T0]: Boolean

def ncol: Int

final def ne(arg0: AnyRef): Boolean

def nequiv(that: Matrix): Boolean

def norm: Double

final def notify(): Unit

final def notifyAll(): Unit

def nrow: Int

def numNonZeroElementsPerColumn(): Vector

def numNonZeroElementsPerRow(): Vector

def pnorm(p: Int): Double

def rbind(that: Double): Matrix

def rbind(that: Matrix): Matrix

def rowMeans(): Vector

def rowSums(): Vector

def sum: Double

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

def t: Matrix

Warning: This provides read-only view only.

def toString(): String

def unary_-: Matrix

Warning: this creates a clone (as in mx * -1), in many applications inplace inversion mx *= -1 might be an infinitely better choice.

def update(rowRange: Range, col: Int, that: Vector): Vector

def update(row: Int, colRange: Range, that: Vector): Vector

def update(rowRange: Range, colRange: Range, that: Matrix): Matrix

def update(rowRange: Range, col: Int, that: Double): Vector

def update(row: Int, colRange: Range, that: Double): Vector

def update(rowRange: Range, colRange: Range, that: Double): Matrix

def update(row: Int, col: Int, that: Double): Matrix

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def %***%(that: Matrix): Matrix

The "legacy" matrix-matrix multiplication.