Base

abstract def k(angle: Float): Float

Steering coefficient for the filter.

final def !=(arg0: Any): Boolean

def !===(that: Matrix): Boolean

def !~==(that: Matrix): Boolean

final def ##(): Int

def *(that: Vector): Vector

def *(that: Matrix): Matrix

def *(scalar: Float): Matrix

def *=(scalar: Float): Unit

def +(that: Matrix): Matrix

def +(scalar: Float): Matrix

def +=(that: Matrix): Unit

def +=(scalar: Float): Unit

def -(that: Matrix): Matrix

def -(scalar: Float): Matrix

def -=(that: Matrix): Unit

def -=(scalar: Float): Unit

def /(scalar: Float): Matrix

def /=(scalar: Float): Unit

def :*(that: Matrix): Matrix

def :*=(that: Matrix): Unit

def :/(that: Matrix): Matrix

def :/=(that: Matrix): Unit

def :=(that: Matrix): Unit

def :=(scalar: Float): Unit

def :\(that: Matrix): Matrix

def :\=(that: Matrix): Unit

def :^(that: Matrix): Matrix

def :^=(that: Matrix): Unit

def <(v: Float): Matrix

def <=(v: Float): Matrix

final def ==(arg0: Any): Boolean

def ===(that: Matrix): Boolean

def >(v: Float): Matrix

def >=(v: Float): Matrix

def ^(scalar: Float): Matrix

def ^=(scalar: Float): Unit

def abs: Matrix

def apply(rows: Range, columns: Range): Matrix

def apply(row: Int, column: Int): Float

def apply(index: Int): Float

def asArray: Array[Float]

final def asInstanceOf[T0]: T0

def backwardDivergence(v1: Matrix): Matrix

def canEqual(other: Any): Boolean

def cholesky: Matrix

def clone(): AnyRef

def column(colIndex: Int): Matrix

val columns: Int

def compactString: String

def convolve(that: Matrix): Matrix

def copy: Matrix

def dot(that: Matrix): Float

def eigen: (Matrix, Matrix)

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

def expand(bigRows: Int, bigColumns: Int, borderFill: Boolean): Matrix

def finalize(): Unit

def flip: Matrix

def forwardGradient: (Matrix, Matrix)

final def getClass(): Class[_]

def getData: Array[Float]

def hashCode(): Int

def invert: Matrix

final def isInstanceOf[T0]: Boolean

def length: Int

def lu: (Matrix, Matrix)

def map(f: (Float) ⇒ Float): Matrix

def mapSelf(f: (Float) ⇒ Float): Unit

def max(that: Matrix): Matrix

def min(that: Matrix): Matrix

final def ne(arg0: AnyRef): Boolean

def normalizeColumns: Unit

def normalizeRows: Unit

final def notify(): Unit

final def notifyAll(): Unit

val offset: Int

def print: Unit

def pseudoInverse: Matrix

def qr: (Matrix, Matrix)

def randomize: Matrix

def rank: Int

def read(index: Int): Float

def reciprocal: Matrix

def rectify: Matrix

def reduce(f: (Float, Float) ⇒ Float): Float

def reshape(newRows: Int, newColumns: Int): Matrix

def row(rowIndex: Int): Matrix

val rows: Int

def separate: Option[(Vector, Vector)]

def sgn: Matrix

def shape: Shape

def shift(shiftRows: Int, shiftColumns: Int): Matrix

def shiftAndExpand(shift: Int, bigRows: Int, bigColumns: Int): Matrix

def shiftCyclic(deltaRows: Int, deltaColumns: Int): Matrix

val size: Int

def sizeString: String

def submatrix(rowRange: Range, columnRange: Range): Matrix

def svd: (Matrix, Matrix, Matrix)

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

def toString(): String

def toVector: Vector

def transpose: Matrix

def trim(smallRows: Int, smallColumns: Int): Matrix

def unary_-: Matrix

def update(row: Int, vector: Vector): Unit

def update(rowRange: Range, columnRange: Range, values: Matrix): Unit

def update(row: Int, column: Int, value: Float): Unit

def update(index: Int, value: Float): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def ~==(that: Matrix): Boolean