CounterLike

abstract def data: M

abstract def default: V

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def %[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpMod, That]): That

Alias for :%(b) when b is a scalar.

final def %=[TT >: This, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpMod]): This

Alias for :%=(b) when b is a scalar.

final def &&[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpAnd, That]): That

Alias for :&&(b) for all b.

final def *[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpMulMatrix, That]): That

Matrix multiplication

final def *=[TT >: This, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpMulScalar]): This

Alias for :*=(b) when b is a scalar.

final def +[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpAdd, That]): That

Alias for :+(b) for all b.

final def +=[TT >: This, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpAdd]): This

Alias for :+=(b) for all b.

final def +=?[TT >: This, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpAdd]): BinaryUpdateOp[TT, B, OpAdd]

Returns the operator delegate used in +=

final def -[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpSub, That]): That

Alias for :-(b) for all b.

final def -=[TT >: This, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpSub]): This

Alias for :-=(b) for all b.

final def /[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpDiv, That]): That

Alias for :/(b) when b is a scalar.

final def /=[TT >: This, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpDiv]): This

Alias for :/=(b) when b is a scalar.

final def :!=[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpNe, That]): That

Element-wise inequality comparator of this and b.

final def :%[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpMod, That]): That

Element-wise modulo of this and b.

final def :%=[TT >: This, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpMod]): This

Mutates this by element-wise modulo of b into this.

final def :&&[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpAnd, That]): That

Element-wise logical "and" operator -- returns true if corresponding elements are non-zero.

final def :*[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpMulScalar, That]): That

Element-wise product of this and b.

final def :*=[TT >: This, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpMulScalar]): This

Mutates this by element-wise multiplication of b into this.

final def :+[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpAdd, That]): That

Element-wise sum of this and b.

final def :+=[TT >: This, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpAdd]): This

Mutates this by element-wise addition of b into this.

final def :-[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpSub, That]): That

Element-wise difference of this and b.

final def :-=[TT >: This, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpSub]): This

Mutates this by element-wise subtraction of b from this

final def :/[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpDiv, That]): That

Element-wise quotient of this and b.

final def :/=[TT >: This, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpDiv]): This

Mutates this by element-wise division of b into this

final def :<[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpLT, That]): That

Element-wise less=than comparator of this and b.

final def :<=[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpLTE, That]): That

Element-wise less-than-or-equal-to comparator of this and b.

final def :=[TT >: This, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpSet]): This

Mutates this by element-wise assignment of b into this.

final def :==[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpEq, That]): That

Element-wise equality comparator of this and b.

final def :>[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpGT, That]): That

Element-wise greater-than comparator of this and b.

final def :>=[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpGTE, That]): That

Element-wise greater-than-or-equal-to comparator of this and b.

final def :^[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpPow, That]): That

Element-wise exponentiation of this and b.

final def :^=[TT >: This, B](b: B)(implicit op: BinaryUpdateOp[TT, B, OpPow]): This

Mutates this by element-wise exponentiation of this by b.

final def :^^[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpXor, That]): That

Element-wise logical "xor" operator -- returns true if only one of the corresponding elements is non-zero.

final def :||[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpOr, That]): That

Element-wise logical "or" operator -- returns true if either element is non-zero.

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def \[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpSolveMatrixBy, That]): That

Shaped solve of this by b.

final def ^^[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpXor, That]): That

Alias for :^^(b) for all b.

def active: TensorActive[K, V, This]

def activeIterator: Iterator[(K, V)]

def activeKeysIterator: Iterator[K]

def activeSize: Int

def activeValuesIterator: Iterator[V]

def all(implicit semi: Semiring[V]): Boolean

Returns true if all elements are non-zero

def any(implicit semi: Semiring[V]): Boolean

Returns true if no elements are non-zero

def apply(k: K): V

def apply[Slice1, Slice2, Result](slice1: Slice1, slice2: Slice2)(implicit canSlice: CanSlice2[This, Slice1, Slice2, Result]): Result

Method for slicing that is tuned for Matrices.

def apply[Result](a: K, slice: K*)(implicit canSlice: CanSlice[This, Seq[K], Result]): Result

Slice a sequence of elements.

def apply[Slice, Result](slice: Slice)(implicit canSlice: CanSlice[This, Slice, Result]): Result

method for slicing a tensor.

def argmax(implicit ord: Ordering[V]): K

def argmin(implicit ord: Ordering[V]): K

def argsort(implicit ord: Ordering[V]): IndexedSeq[K]

def argtopk(k: Int)(implicit ordering: Ordering[V]): IndexedSeq[K]

Returns the k indices with maximum value.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def contains(k: K): Boolean

final def dot[TT >: This, B, BB >: B, That](b: B)(implicit op: BinaryOp[TT, BB, OpMulInner, That]): That

Inner product of this and b.

final def eq(arg0: AnyRef): Boolean

def equals(p1: Any): Boolean

def finalize(): Unit

def findAll(f: (V) ⇒ Boolean): IndexedSeq[K]

Returns all indices k whose value satisfies a predicate.

def forall(fn: (K, V) ⇒ Boolean): Boolean

Returns true if and only if the given predicate is true for all elements.

def forallValues(fn: (V) ⇒ Boolean): Boolean

Returns true if and only if the given predicate is true for all elements.

def foreachKey[U](fn: (K) ⇒ U): Unit

Applies the given function to each key in the tensor.

def foreachPair[U](fn: (K, V) ⇒ U): Unit

Applies the given function to each key and its corresponding value.

def foreachValue[U](fn: (V) ⇒ U): Unit

Applies the given function to each value in the map (one for each element of the domain, including zeros).

def get(k: K): Option[V]

final def getClass(): Class[_]

def hashCode(): Int

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def iterator: Iterator[(K, V)]

def keySet: Set[K]

def keys: TensorKeys[K, V, This]

def keysIterator: Iterator[K]

def mapActivePairs[TT >: This, O, That](f: (K, V) ⇒ O)(implicit bf: CanMapKeyValuePairs[TT, K, V, O, That]): That

Maps all active key-value pairs values.

def mapActiveValues[TT >: This, O, That](f: (V) ⇒ O)(implicit bf: CanMapValues[TT, V, O, That]): That

Maps all non-zero values.

def mapPairs[TT >: This, O, That](f: (K, V) ⇒ O)(implicit bf: CanMapKeyValuePairs[TT, K, V, O, That]): That

Creates a new map containing a transformed copy of this map.

def mapValues[TT >: This, O, That](f: (V) ⇒ O)(implicit bf: CanMapValues[TT, V, O, That]): That

Creates a new map containing a transformed copy of this map.

def max(implicit ord: Ordering[V]): V

def min(implicit ord: Ordering[V]): V

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pairs: TensorPairs[K, V, This]

def repr: This

def size: Int

def sum(implicit num: Numeric[V]): V

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

final def t[TT >: This, That, Slice1, Slice2, Result](a: Slice1, b: Slice2)(implicit op: CanTranspose[TT, That], canSlice: CanSlice2[That, Slice1, Slice2, Result]): Result

A transposed view of this object, followed by a slice.

final def t[TT >: This, That](implicit op: CanTranspose[TT, That]): That

A transposed view of this object.

def toMap: Map[K, V]

def toString(): String

final def unary_: That

final def unary_-[TT >: This, That](implicit op: UnaryOp[TT, OpNeg, That]): That

def update(k: K, v: V): Unit

def ureduce[A](f: URFunc[V, A]): A

def values: TensorValues[K, V, This]

def valuesIterator: Iterator[V]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def ||[TT >: This, B, That](b: B)(implicit op: BinaryOp[TT, B, OpOr, That]): That

Alias for :||(b) for all b.