Matrix

A matrix.

In the following descriptions, "v" represents a vector, "s" a scalar, "m" a matrix, "b" a boolean, "i" and integer, "d" a double, "r" a range of integers (e.g. "1 to 5" or "3 until 9").

The update operations, such as "+=", update the elements of the matrix in place.

Constructors:
  Matrix(i, i)
  Matrix(i, i, Array[d])
  copy

Dimensions:
  rows               => i        (number of rows in matrix)
  columns            => i        (number of columns in matrix)
  size               => i        (total # elements in matrix)

Linear element access:
  apply(i)           => s        (access element linearly)
  update(i, s)                   (write element i with value s)

2D element access:
  apply(i, i)        => s        (access element by 2D coordinates)
  update(i, i, s)                (write element (i, i) with value s)

Submatrix multi-element reads:
  row(i)             => m        (extract a copy of a row)
  column(i)          => m        (extract a copy of a column)
  submatrix(r, r)    => m        (extract a subregion of a matrix)
  reshape(i, i)      => m        (reshape the matrix)

Matrix operations:
  map(f: d => d)     => m        (map a Matrix by applying f to each element)
  mapSelf(f: d => d)			    (use f to map each element in place)
  reduce((d, d)=> d) => d        (reduce a Matrix to a scalar)
  randomize                      (initialize to random values in [0, 1))

Matrix / Scalar operations:
  m + s   => m          (add scalar to each element to produce a new matrix)
  m += s                (add scalar to all elements of matrix in-place)
  m - s   => m
  m -= s
  m * s   => m
  m *= s
  m / s   => m
  m /= s
  -m      => m          (map each element to new matrix my multiplying by -1)
  m := s                (assign scalar to all elements of the matrix)

Matrix / Matrix operations:
  m + m          => m
  m += m
  m - m          => m
  m -= m
  m :* m         => m   (element-wise multiplication)
  m :*= m               (element-wise multiplication in-place)
  m :/ m         => m   (element-wise right division)
  m :/= n               (element-wise right division in-place)
  m :\ m         => m   (element-wise left division)
  m :\= m               (element-wise left division in-place)
  m1 === m2		=> b   (m1 and m2 have same shape, identical elements)
  m1 !=== m2     => b
  m1 ~== m2
  m1 !~== m2
  m1 := m2			   (assign elements of m2 to m1)

Matrix multiplication:
  m * m          => m   (matrix multiplication)

Matrix decompositions:
  cholesky       => m         (Cholesky decomposition)
  eigen          => (m, m)    (eigenvector matrix, diag eigenvalue matrix)
  lu             => (m, m)    (L matrix, U matrix)
  qr             => (m, m)    (Q matrix, R matrix)
  svd            => (m, m, m) (U matrix, S matrix, V matrix)

Miscellaneous cogx.utilities:
  abs            => m   (absolute value of each element)
  sgn            => m   (sign of each element: -1, 0, 1)
  rectify        => m   (clip negative elements to 0)
  normalizeRows         (normalize rows using L2 norm)
  normalizeColumns      (normalize columns using L2 norm)
  print                 (print a matrix for debugging)

Annotations: @SerialVersionUID()

Linear Supertypes

Tensor, Serializable, Serializable, AnyRef, Any

Instance Constructors

new Matrix(tensor: Tensor)

Create a Matrix from a 2-D tensor.
new Matrix(rows: Int, columns: Int)

Constructor that allocates memory for Matrix (most common).
new Matrix(rows: Int, columns: Int, data: Array[Float])

rows
The number of rows in the matrix.
columns
The number of columns in the matrix.
data
Storage for matrix elements; length must be equal to rows * columns.

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def !===(that: Matrix): Boolean
def !~==(that: Matrix): Boolean
final def ##(): Int

Definition Classes
AnyRef → Any
def *(that: Vector): Vector

Matrix multiplication.
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

Definition Classes
AnyRef → Any
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

Synonym for submatrix.
Synonym for submatrix.
rows
Range of rows to extract.
columns
Range of columns to extract.
returns
The specified submatrix.
def apply(row: Int, column: Int): Float

2D coordinates element access
def apply(index: Int): Float

Linear element access
def asArray: Array[Float]

View the matrix as a flat array of data.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def backwardDivergence(v1: Matrix): Matrix
def canEqual(other: Any): Boolean

Helper for equals.
Helper for equals.

Definition Classes
Tensor
def cholesky: Matrix
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def column(colIndex: Int): Matrix
val columns: Int

The number of columns in the matrix.
def compactString: String
def convolve(that: Matrix): Matrix

Convolve this matrix with another.
Convolve this matrix with another. Useful for convolving two filters. Works only with square, odd-sized filters.
that
The matrix to be convolved with this.
returns
The convolution of the filters, larger than either.
def copy: Matrix

Make a copy of a Matrix.
def dot(that: Matrix): Float

Dot product of "this" and "that"
def eigen: (Matrix, Matrix)
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(other: Any): Boolean

Test "this" and "other" for deep equality.
Test "this" and "other" for deep equality. Allows "==" to work.

Definition Classes
Tensor → AnyRef → Any
def expand(bigRows: Int, bigColumns: Int, borderFill: Boolean): Matrix

Expand the matrix, optionally extending the border into the expanded region.
Expand the matrix, optionally extending the border into the expanded region. This operation is a key part of the FFT. The new matrix is of size "bigRows" x "bigColumns" and element (0, 0) of this is anchored at (0, 0) in the larger matrix. If "borderFill" is true, then the four edges of the matrix are extended evenly in all directions, as though the bigger matrix were actually a torus with opposite edges touching.
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def flip: Matrix

Flip the matrix left-to-right and top-to-bottom.
Flip the matrix left-to-right and top-to-bottom. This is useful for creating correlation matrices that are implemented using convolution.
def forwardGradient: (Matrix, Matrix)
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getData: Array[Float]

Get the data in the tensor, flattened to a linear array.
Get the data in the tensor, flattened to a linear array.

Attributes
protected[cogx]
def hashCode(): Int

Required because of overriding equals.
Required because of overriding equals.

Definition Classes
Tensor → AnyRef → Any
def invert: Matrix
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def length: Int

The number of "numbers" held in the tensor.
The number of "numbers" held in the tensor.

Definition Classes
Tensor
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

Definition Classes
AnyRef
def normalizeColumns: Unit
def normalizeRows: Unit
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def print: Unit
def pseudoInverse: Matrix

Compute the Moore-Penrose pseudo inverse.
def qr: (Matrix, Matrix)
def randomize: Matrix
def rank: Int

Find the rank of a matrix.
Find the rank of a matrix.
returns
Rank of the matrix.
def read(index: Int): Float

Tensor accessor.
Tensor accessor.

Definition Classes
Matrix → Tensor
def reciprocal: Matrix
def rectify: Matrix
def reduce(f: (Float, Float) ⇒ Float): Float

Reduce the matrix to a scalar.
def reshape(newRows: Int, newColumns: Int): Matrix
def row(rowIndex: Int): Matrix
val rows: Int

The number of rows in the matrix.
def separate: Option[(Vector, Vector)]

Attempt to separate this matrix into an outer product of two vectors.
Attempt to separate this matrix into an outer product of two vectors. Relies on a tolerance, here taken to be the machine epsilon.
returns
Some((verticalVector, horizontalVector)) if separable, otherwise None.
def sgn: Matrix
def shape: geometry.Shape

Shape of the matrix.
Shape of the matrix.

Definition Classes
Matrix → Tensor
def shift(shiftRows: Int, shiftColumns: Int): Matrix

Shift a matrix with zero fill on the edges.
Shift a matrix with zero fill on the edges.
shiftRows
Number of rows to shift this down.
shiftColumns
Number of columns to shift this to the right.
returns
Shifted matrix, zero-filling on edges.
def shiftAndExpand(shift: Int, bigRows: Int, bigColumns: Int): Matrix

Shift "this" matrix down by "shift" rows and right by "shift" columns, expand to a "bigRows" x "bigColumns" complex matrix, padding with zeros everywhere an element is not defined by "this".
def shiftCyclic(deltaRows: Int, deltaColumns: Int): Matrix

Shifts the elements of a matrix cyclicly as though it were a torus, wrapping around the left side to the right side, and the top to the bottom.
Shifts the elements of a matrix cyclicly as though it were a torus, wrapping around the left side to the right side, and the top to the bottom. The rotation is specified by the tuple("deltaRows", "deltaColumns"). For example, the tuple value (2, 3) would cause the element at location (0, 0) to be moved to location (2, 3). In a 5 x 5 matrix, the same tuple would cause the element at (4, 4) to be moved to (1, 2), wrapping around the torus. Returns the cyclicly shifted matrix.
val size: Int
def sizeString: String

Get the size of the matrix as a string.
def submatrix(rowRange: Range, columnRange: Range): Matrix
def svd: (Matrix, Matrix, Matrix)
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def toVector: Vector

Flatten the rows of this matrix to a vector.
def transpose: Matrix
def trim(smallRows: Int, smallColumns: Int): Matrix

Trim "this" to a "smallRows" x "smallColumns" matrix.
def unary_-: Matrix
def update(row: Int, vector: Vector): Unit

Write the row "row" with the data in "vector".
def update(rowRange: Range, columnRange: Range, values: Matrix): Unit

Update a subset of a matrix.
Update a subset of a matrix.
rowRange
Range of rows to update.
columnRange
Range of columns to update.
values
The new values to be written in the submatrix specified by rows and columns. This must have the exact same shape as (rows, columns), or it must be a 1 x 1 matrix, in which case it is treated like a scalar.
def update(row: Int, column: Int, value: Float): Unit

Modify an element given its 2D coordinates.
def update(index: Int, value: Float): Unit

Modify an element given its linear position.
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( ... )
def ~==(that: Matrix): Boolean

Related Docs: object Matrix | package real

class Matrix extends Tensor with Serializable

Instance Constructors

new Matrix(tensor: Tensor)

new Matrix(rows: Int, columns: Int)

new Matrix(rows: Int, columns: Int, data: Array[Float])

Value Members

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