SliceVector

final def !=(arg0: Any): Boolean

final def ##(): Int

final def %[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpMod.Impl2[TT, B, That]): That

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

final def %:%[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpMod.Impl2[TT, B, That]): That

Element-wise modulo of this and b.

final def %=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpMod.InPlaceImpl2[TT, B]): SliceVector[K, V]

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

final def &[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpAnd.Impl2[TT, B, That]): That

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

final def &:&[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpAnd.Impl2[TT, B, That]): That

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

final def &=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpAnd.InPlaceImpl2[TT, B]): SliceVector[K, V]

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

final def *[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpMulMatrix.Impl2[TT, B, That]): That

Matrix multiplication (and scalar multiplication that follows standard order of operations)

final def *:*[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpMulScalar.Impl2[TT, B, That]): That

Element-wise product of this and b.

final def *=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpMulScalar.InPlaceImpl2[TT, B]): SliceVector[K, V]

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

final def +[TT >: SliceVector[K, V], B, C, That](b: B)(implicit op: operators.OpAdd.Impl2[TT, B, That]): That

Alias for :+(b) for all b.

final def +:+[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpAdd.Impl2[TT, B, That]): That

Element-wise sum of this and b.

final def +=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpAdd.InPlaceImpl2[TT, B]): SliceVector[K, V]

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

final def -[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpSub.Impl2[TT, B, That]): That

Alias for :-(b) for all b.

final def -:-[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpSub.Impl2[TT, B, That]): That

Element-wise difference of this and b.

final def -=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpSub.InPlaceImpl2[TT, B]): SliceVector[K, V]

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

final def /[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpDiv.Impl2[TT, B, That]): That

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

final def /:/[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpDiv.Impl2[TT, B, That]): That

Element-wise quotient of this and b.

final def /=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpDiv.InPlaceImpl2[TT, B]): SliceVector[K, V]

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

final def :!=[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpNe.Impl2[TT, B, That]): That

Element-wise inequality comparator of this and b.

final def :%=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpMod.InPlaceImpl2[TT, B]): SliceVector[K, V]

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

final def :&=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpAnd.InPlaceImpl2[TT, B]): SliceVector[K, V]

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

final def :*=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpMulScalar.InPlaceImpl2[TT, B]): SliceVector[K, V]

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

final def :+=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpAdd.InPlaceImpl2[TT, B]): SliceVector[K, V]

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

final def :-=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpSub.InPlaceImpl2[TT, B]): SliceVector[K, V]

Mutates this by element-wise subtraction of b from this

final def :/=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpDiv.InPlaceImpl2[TT, B]): SliceVector[K, V]

Mutates this by element-wise division of b into this

final def :=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpSet.InPlaceImpl2[TT, B]): SliceVector[K, V]

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

final def :==[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpEq.Impl2[TT, B, That]): That

Element-wise equality comparator of this and b.

final def :^=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpPow.InPlaceImpl2[TT, B]): SliceVector[K, V]

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

final def :^^=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpXor.InPlaceImpl2[TT, B]): SliceVector[K, V]

Mutates this by element-wise xor of this and b.

final def :|=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpOr.InPlaceImpl2[TT, B]): SliceVector[K, V]

Mutates this by element-wise or of this and b.

final def <:<[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpLT.Impl2[TT, B, That]): That

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

final def <:=[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpLTE.Impl2[TT, B, That]): That

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

final def ==(arg0: Any): Boolean

final def >:=[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpGTE.Impl2[TT, B, That]): That

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

final def >:>[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpGT.Impl2[TT, B, That]): That

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

def \[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpSolveMatrixBy.Impl2[TT, B, That]): That

Shaped solve of this by b.

final def ^:^[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpPow.Impl2[TT, B, That]): That

Element-wise exponentiation of this and b.

final def ^^[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpXor.Impl2[TT, B, That]): That

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

final def ^^:^^[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpXor.Impl2[TT, B, That]): That

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

final def ^^=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpXor.InPlaceImpl2[TT, B]): SliceVector[K, V]

Mutates this by element-wise xor of this and b.

def active: TensorActive[Int, V, SliceVector[K, V]]

def activeIterator: Iterator[(Int, V)]

def activeKeysIterator: Iterator[Int]

def activeSize: Int

def activeValuesIterator: Iterator[V]

def apply(i: Int): V

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

Method for slicing that is tuned for Matrices.

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

Slice a sequence of elements.

def apply[Slice, Result](slice: Slice)(implicit canSlice: CanSlice[SliceVector[K, V], Slice, Result]): Result

method for slicing a tensor.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def copy: DenseVector[V]

final def dot[TT >: SliceVector[K, V], B, BB >: B, That](b: B)(implicit op: operators.OpMulInner.Impl2[TT, BB, That]): That

Inner product of this and b.

final def eq(arg0: AnyRef): Boolean

def equals(p1: Any): Boolean

def exists(f: (V) ⇒ Boolean): Boolean

def finalize(): Unit

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

Returns all indices k whose value satisfies a predicate.

def fold[E1 >: V](z: E1)(op: (E1, E1) ⇒ E1): E1

See scala.collection.mutable.ArrayOps.fold.

def foldLeft[B >: V](z: B)(op: (B, V) ⇒ B): B

See scala.collection.mutable.ArrayOps.foldLeft.

def foldRight[B >: V](z: B)(op: (V, B) ⇒ B): B

See scala.collection.mutable.ArrayOps.foldRight.

def forall(f: (V) ⇒ Boolean): Boolean

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

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

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

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

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

Applies the given function to each key in the tensor.

def foreachPair[U](fn: (Int, 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).

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def iterator: Iterator[(Int, V)]

def keySet: Set[Int]

def keys: TensorKeys[Int, V, SliceVector[K, V]]

def keysIterator: Iterator[Int]

def length: Int

def map[V2, That](fn: (V) ⇒ V2)(implicit canMapValues: CanMapValues[SliceVector[K, V], V, V2, That]): That

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

Maps all active key-value pairs values.

def mapActiveValues[TT >: SliceVector[K, V], O, That](f: (V) ⇒ O)(implicit bf: CanMapActiveValues[TT, V, O, That]): That

Maps all non-zero values.

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

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

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

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def padTo(len: Int, elem: V)(implicit cm: ClassTag[V]): Vector[V]

See scala.collection.mutable.ArrayOps.padTo.

def pairs: TensorPairs[Int, V, SliceVector[K, V]]

def reduce[E1 >: V](op: (E1, E1) ⇒ E1): E1

See scala.collection.mutable.ArrayOps.reduce.

def reduceLeft[B >: V](op: (B, V) ⇒ B): B

See scala.collection.mutable.ArrayOps.reduceLeft.

def reduceRight[B >: V](op: (V, B) ⇒ B): B

See scala.collection.mutable.ArrayOps.reduceRight.

def repr: SliceVector[K, V]

def scan[E1 >: V](z: E1)(op: (E1, E1) ⇒ E1)(implicit cm: ClassTag[V], cm1: ClassTag[E1]): Vector[E1]

See scala.collection.mutable.ArrayOps.scan.

def scanLeft[B >: V](z: B)(op: (B, V) ⇒ B)(implicit cm1: ClassTag[B]): Vector[B]

See scala.collection.mutable.ArrayOps.scanLeft.

def scanRight[B >: V](z: B)(op: (V, B) ⇒ B)(implicit cm1: ClassTag[B]): Vector[B]

See scala.collection.mutable.ArrayOps.scanRight.

def size: Int

val slices: IndexedSeq[K]

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

final def t[TT >: SliceVector[K, V], That, Slice1, Result](a: Slice1)(implicit op: CanTranspose[TT, That], canSlice: CanSlice[That, Slice1, Result]): Result

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

final def t[TT >: SliceVector[K, V], 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 >: SliceVector[K, V], That](implicit op: CanTranspose[TT, That]): That

A transposed view of this object.

val tensor: Tensor[K, V]

def toArray(implicit cm: ClassTag[V]): Array[V]

Returns copy of this breeze.linalg.Vector as a scala.Array

def toDenseVector(implicit cm: ClassTag[V]): DenseVector[V]

def toString(): String

def toVector(implicit cm: ClassTag[V]): Vector[V]

Returns copy of this breeze.linalg.Vector as a scala.Vector

final def unary_![TT >: SliceVector[K, V], That](implicit op: operators.OpNot.Impl[TT, That]): That

final def unary_-[TT >: SliceVector[K, V], That](implicit op: operators.OpNeg.Impl[TT, That]): That

def update(i: Int, v: V): Unit

def values: TensorValues[Int, V, SliceVector[K, V]]

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 >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpOr.Impl2[TT, B, That]): That

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

final def |:|[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpOr.Impl2[TT, B, That]): That

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

final def |=[TT >: SliceVector[K, V], B](b: B)(implicit op: operators.OpOr.InPlaceImpl2[TT, B]): SliceVector[K, V]

Mutates this by element-wise or of this and b.

final def :%[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpMod.Impl2[TT, B, That]): That

final def :&[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpAnd.Impl2[TT, B, That]): That

final def :*[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpMulScalar.Impl2[TT, B, That]): That

final def :+[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpAdd.Impl2[TT, B, That]): That

final def :-[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpSub.Impl2[TT, B, That]): That

final def :/[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpDiv.Impl2[TT, B, That]): That

final def :<[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpLT.Impl2[TT, B, That]): That

final def :<=[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpLTE.Impl2[TT, B, That]): That

final def :>[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpGT.Impl2[TT, B, That]): That

final def :>=[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpGTE.Impl2[TT, B, That]): That

final def :^[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpPow.Impl2[TT, B, That]): That

final def :^^[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpXor.Impl2[TT, B, That]): That

final def :|[TT >: SliceVector[K, V], B, That](b: B)(implicit op: operators.OpOr.Impl2[TT, B, That]): That

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 some element is non-zero

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

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

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

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

Returns the k indices with maximum value.

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

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

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

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

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