Matrix2

This is the future Matrix API. The old one will be removed in scalding 0.10.0 (or 1.0.0).

Create Matrix2 instances with methods in the Matrix2 object. Note that this code optimizes the order in which it evaluates matrices, and replaces equivalent terms to avoid recomputation. Also, this code puts the parenthesis in the optimal place in terms of size according to the sizeHints. For instance: (A*B)*C == A*(B*C) but if B is a 10 x 10^{6 matrix, and C is 10}6 x 100, it is better to do the B*C product first in order to avoid storing as much intermediate output.

NOTE THIS REQUIREMENT: for each formula, you can only have one Ring[V] in scope. If you evaluate part of the formula with one Ring, and another part with another, you must go through a TypedPipe (call toTypedPipe) or the result may not be correct.

Source: Matrix2.scala

Linear Supertypes

Serializable, AnyRef, Any

Known Subclasses

HadamardProduct, MatrixLiteral, OneC, OneR, Product, Sum

Type Hierarchy

Abstract Value Members

implicit abstract def colOrd: Ordering[C]
abstract def negate(implicit g: Group[V]): Matrix2[R, C, V]
implicit abstract def rowOrd: Ordering[R]
abstract def toTypedPipe: TypedPipe[(R, C, V)]

Convert the current Matrix to a TypedPipe
abstract def transpose: Matrix2[C, R, V]

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def #*#(that: Matrix2[R, C, V])(implicit ring: Ring[V]): Matrix2[R, C, V]

Represents the pointwise, or Hadamard, product of two matrices.
def *(that: Scalar2[V])(implicit ring: Ring[V], mj: MatrixJoiner2): Matrix2[R, C, V]
def *[C2](that: Matrix2[C, C2, V])(implicit ring: Ring[V], mj: MatrixJoiner2): Matrix2[R, C2, V]
def +(that: Matrix2[R, C, V])(implicit mon: Monoid[V]): Matrix2[R, C, V]
def -(that: Matrix2[R, C, V])(implicit g: Group[V]): Matrix2[R, C, V]
def /(that: Scalar2[V])(implicit field: algebird.Field[V]): Matrix2[R, C, V]
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def ^(power: Int)(implicit ev: =:=[R, C], ring: Ring[V], mj: MatrixJoiner2): Matrix2[R, R, V]

equivalent to multiplying this matrix by itself, power times
def asCol[C2](c2: C2)(implicit ev: =:=[C, Unit], colOrd: Ordering[C2]): Matrix2[R, C2, V]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asRow[R2](r2: R2)(implicit ev: =:=[R, Unit], rowOrd: Ordering[R2]): Matrix2[R2, C, V]

Consider this Matrix as the r2 row of a matrix.
Consider this Matrix as the r2 row of a matrix. The current matrix must be a row, which is to say, its row type must be Unit.
def binarizeAs[NewValT](implicit mon: Monoid[V], ring: Ring[NewValT]): Matrix2[R, C, NewValT]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getColumn(index: C): Matrix2[R, Unit, V]
def getRow(index: R): Matrix2[Unit, C, V]
def hashCode(): Int

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

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def optimizedSelf: Matrix2[R, C, V]

Users should never need this.
Users should never need this. This is the current Matrix2, but in most optimized form. Usually, you will just do matrix operations until you eventually call write or toTypedPipe
def propagate[C2, VecV](vec: Matrix2[C, C2, VecV])(implicit ev: =:=[V, Boolean], mon: Monoid[VecV], mj: MatrixJoiner2): Matrix2[R, C2, VecV]

the result is the same as considering everything on the this to be like a 1 value so we just sum, using only a monoid on VecV, where this Matrix has the value true.
the result is the same as considering everything on the this to be like a 1 value so we just sum, using only a monoid on VecV, where this Matrix has the value true. This is useful for graph propagation of monoids, such as sketchs like HyperLogLog, BloomFilters or CountMinSketch. TODO This is a special kind of product that could be optimized like Product is
def propagateRow[C2](mat: Matrix2[C, C2, Boolean])(implicit ev: =:=[R, Unit], mon: Monoid[V], mj: MatrixJoiner2): Matrix2[Unit, C2, V]
def rowL1Normalize(implicit num: Numeric[V], mj: MatrixJoiner2): Matrix2[R, C, Double]

Row L1 normalization After this operation, the sum(|x|) alone each row will be 1.
def rowL2Normalize(implicit num: Numeric[V], mj: MatrixJoiner2): Matrix2[R, C, Double]

Row L2 normalization After this operation, the sum(|x|^2) along each row will be 1.
val sizeHint: SizeHint
def sumColVectors(implicit ring: Ring[V], mj: MatrixJoiner2): Matrix2[R, Unit, V]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def trace(implicit mon: Monoid[V], ev: =:=[R, C]): Scalar2[V]
def unary_-(implicit g: Group[V]): Matrix2[R, C, V]
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 write(sink: TypedSink[(R, C, V)])(implicit fd: FlowDef, m: Mode): Matrix2[R, C, V]

Related Docs: object Matrix2 | package mathematics

sealed trait Matrix2[R, C, V] extends Serializable

Abstract Value Members

implicit abstract def colOrd: Ordering[C]

abstract def negate(implicit g: Group[V]): Matrix2[R, C, V]

implicit abstract def rowOrd: Ordering[R]

abstract def toTypedPipe: TypedPipe[(R, C, V)]

abstract def transpose: Matrix2[C, R, V]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def #*#(that: Matrix2[R, C, V])(implicit ring: Ring[V]): Matrix2[R, C, V]

def *(that: Scalar2[V])(implicit ring: Ring[V], mj: MatrixJoiner2): Matrix2[R, C, V]

def *[C2](that: Matrix2[C, C2, V])(implicit ring: Ring[V], mj: MatrixJoiner2): Matrix2[R, C2, V]

def +(that: Matrix2[R, C, V])(implicit mon: Monoid[V]): Matrix2[R, C, V]

def -(that: Matrix2[R, C, V])(implicit g: Group[V]): Matrix2[R, C, V]

def /(that: Scalar2[V])(implicit field: algebird.Field[V]): Matrix2[R, C, V]

final def ==(arg0: Any): Boolean

def ^(power: Int)(implicit ev: =:=[R, C], ring: Ring[V], mj: MatrixJoiner2): Matrix2[R, R, V]

def asCol[C2](c2: C2)(implicit ev: =:=[C, Unit], colOrd: Ordering[C2]): Matrix2[R, C2, V]

final def asInstanceOf[T0]: T0

def asRow[R2](r2: R2)(implicit ev: =:=[R, Unit], rowOrd: Ordering[R2]): Matrix2[R2, C, V]

def binarizeAs[NewValT](implicit mon: Monoid[V], ring: Ring[NewValT]): Matrix2[R, C, NewValT]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def getColumn(index: C): Matrix2[R, Unit, V]

def getRow(index: R): Matrix2[Unit, C, V]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def optimizedSelf: Matrix2[R, C, V]

def propagate[C2, VecV](vec: Matrix2[C, C2, VecV])(implicit ev: =:=[V, Boolean], mon: Monoid[VecV], mj: MatrixJoiner2): Matrix2[R, C2, VecV]

def propagateRow[C2](mat: Matrix2[C, C2, Boolean])(implicit ev: =:=[R, Unit], mon: Monoid[V], mj: MatrixJoiner2): Matrix2[Unit, C2, V]

def rowL1Normalize(implicit num: Numeric[V], mj: MatrixJoiner2): Matrix2[R, C, Double]

def rowL2Normalize(implicit num: Numeric[V], mj: MatrixJoiner2): Matrix2[R, C, Double]

val sizeHint: SizeHint

def sumColVectors(implicit ring: Ring[V], mj: MatrixJoiner2): Matrix2[R, Unit, V]

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

def toString(): String

def trace(implicit mon: Monoid[V], ev: =:=[R, C]): Scalar2[V]

def unary_-(implicit g: Group[V]): Matrix2[R, C, V]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def write(sink: TypedSink[(R, C, V)])(implicit fd: FlowDef, m: Mode): Matrix2[R, C, V]

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped