SparseBinaryTensorLike3

abstract def dim1: Int

abstract def dim2: Int

abstract def dim3: Int

final def !=(arg0: Any): Boolean

final def ##(): Int

def *(v: Double): Tensor

def *=(ds: DoubleSeq): Unit

def *=(d: Double): Unit

def *=(i: Int, incr: Double): Unit

def +(that: Tensor): Tensor

def ++=(is: Iterable[Int]): Unit

def ++=(is: Array[Int]): Unit

def ++=(tensors: Iterable[Tensor]): SparseBinaryTensorLike3.this.type

def +=(i: Int, j: Int, k: Int): Unit

def +=(i: Int, v: Double): Unit

In SparseBinary, this is equivalent to update(i,v)

def +=(i: Int): Unit

def +=(i: Int, j: Int, k: Int, v: Double): Unit

def +=(ds: DoubleSeq, factor: DoubleSeq): Unit

Increment by the element-wise product of ds and factor.

def +=(a: Array[Double], factor: Double): Unit

def +=(ds: DoubleSeq, factor: Double): Unit

def +=(a: Array[Double]): Unit

final def +=(ds: DoubleSeq): Unit

def +=(d: Double): Unit

def -(that: Tensor): Tensor

def -=(i: Int): Unit

def -=(ds: DoubleSeq): Unit

final def -=(d: Double): Unit

def -=(i: Int, incr: Double): Unit

def /(v: Double): Tensor

def /=(ds: DoubleSeq): Unit

final def /=(d: Double): Unit

final def /=(i: Int, incr: Double): Unit

def :=(a: Array[Double], offset: Int): Unit

def :=(a: Array[Double]): Unit

def :=(ds: DoubleSeq): Unit

def :=(d: Double): Unit

def =+(a: Array[Double], offset: Int, f: Double): Unit

Increment given array (starting at offset index) with contents of this DoubleSeq, multiplied by factor f.

final def =+(a: Array[Double], f: Double): Unit

final def =+(a: Array[Double], offset: Int): Unit

final def =+(a: Array[Double]): Unit

final def ==(arg0: Any): Boolean

final def _append(elem: Int): SparseBinaryTensorLike3.this.type

def _appendAll(elts: TraversableOnce[Int]): Unit

def _appendAll(elts: Array[Int]): Unit

def _appendUnsafe(i: Int): ArraySparseBinaryTensor

final def _apply(index: Int): Int

def _array: Array[Int]

final def _asArray: Array[Int]

def _asIntSeq: IntSeq

def _asSeq: IndexedSeq[Int]

def _capacityGrowthFactor: Double

def _clear(): Unit

def _considerShrinkingCapacity(): Boolean

If _size is sufficiently smaller than the array length so that substantial space would be saved, then reallocate the array length to be max(_size,_initialCapacity), and return true.

def _containsSorted(x: Int): Boolean

def _copyToArray(a: Array[Int]): Unit

final def _ensureCapacity(cap: Int): Unit

def _fill(elt: Int): Unit

def _foreach[U](f: (Int) ⇒ U): Unit

final def _increment(index: Int, incr: Int): Unit

def _indexForInsertSorted(i: Int): Int

Return the index at which value i should be inserted in order to maintain sorted order.

def _indexForInsertSortedLinear(i: Int): Int

def _indexOf(i: Int): Int

Return the index containing the value i, or -1 if i is not found.

def _indexOfSorted(i: Int): Int

Return the index containing the value i, or -1 if i is not found.

def _indices: Array[Int]

Efficient (but dangerous) direct access to underlying array of indices.

def _initialCapacity: Int

def _insert(index: Int, elt: Int): Unit

def _insertAll(index: Int, seq: Traversable[Int]): Unit

def _insertAllSorted(seq: Traversable[Int]): Unit

def _insertSorted(elt: Int): Unit

def _insertSortedNoDuplicates(elt: Int): Unit

final def _length: Int

def _makeReadable(): Unit

def _mapToArray[A](a: Array[A], f: (Int) ⇒ A): Unit

def _prepend(elt: Int): Unit

def _prependAll(elts: TraversableOnce[Int]): Unit

def _rawArray: Array[Double]

Return the values as an Array[Double] whose length may be longer than this.length.

def _reduceToSize(newSize: Int): Unit

def _remove(index: Int): Unit

def _remove(index: Int, count: Int): Unit

def _set(elts: Seq[Int]): Unit

def _set(elts: Array[Int]): Unit

final def _setCapacity(cap: Int): Unit

Reallocate the array to be exactly 'cap' or _initialCapacity, whichever is bigger.

def _sizeHint(len: Int): Unit

def _sum: Int

def _takeAsIntSeq(len: Int): IntSeq

def _toArray: Array[Int]

def _toSeq: IndexedSeq[Int]

def _trimCapacity(): Unit

def _unsafeActiveDomainSize: Int

final def _update(index: Int, value: Int): Unit

def _valuesSeq: DoubleSeq

def abs(): Unit

def activeDomain: TruncatedArrayIntSeq

def activeDomain1: Nothing

def activeDomain2: Nothing

def activeDomain3: Nothing

def activeDomainSize: Int

def activeDomains: Array[IntSeq]

def activeElements: Iterator[(Int, Double)]

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Append a string representation of this DoubleSeq to the StringBuilder.

final def apply(index: Int): Double

def apply(i: Int, j: Int, k: Int): Double

def asArray: Array[Double]

Return the values as an Array[Double].

final def asInstanceOf[T0]: T0

def asSeq: Seq[Double]

With uncopied contents

def blankCopy: Tensor3

def clone(): AnyRef

final def contains(index: Int): Boolean

def contains(d: Double): Boolean

def containsNaN: Boolean

def copy: Tensor3

def cosineSimilarity(t: DoubleSeq): Double

def defaultValue: Double

The default value at indices not covered by activeDomain.

def different(t: DoubleSeq, threshold: Double): Boolean

def dimensions: Array[Int]

def dimensionsMatch(t: Tensor): Boolean

def dot(v: DoubleSeq): Double

def ensureDimensionsMatch(t: Tensor): Unit

def entropy: Double

Assumes that the values are already normalized to sum to 1.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def expNormalize(logZ: Double): Unit

Exponential the elements of the array such that they are normalized to sum to one, but do so efficiently by providing logZ.

def expNormalize(): Double

Exponentiate the elements of the array, and then normalize them to sum to one.

def expNormalized: Tensor

def exponentiate(): Unit

def filter(f: (Double) ⇒ Boolean): DoubleSeq

def finalize(): Unit

def foldActiveElements(seed: Double, f: (Int, Double, Double) ⇒ Double): Double

def foldLeft[B](z: B)(f: (B, Double) ⇒ B): B

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

def forallActiveElements(f: (Int, Double) ⇒ Boolean): Boolean

def forallElements(f: (Int, Double) ⇒ Boolean): Boolean

def foreach(f: (Double) ⇒ Unit): Unit

def foreachActiveElement(f: (Int, Double) ⇒ Unit): Unit

def foreachElement(f: (Int, Double) ⇒ Unit): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def index1(i: Int): Int

final def index2(i: Int): Int

final def index3(i: Int): Int

def indexOf(d: Double): Int

def infinityNorm: Double

def isDense: Boolean

final def isInstanceOf[T0]: Boolean

def isUniform: Boolean

def jsDivergence(p: DoubleSeq): Double

Assumes that the values are already normalized to sum to 1.

def klDivergence(p: DoubleSeq): Double

Assumes that the values in both DoubleSeq are already normalized to sum to 1.

def l2Similarity(t: DoubleSeq): Double

final def length: Int

def map(f: (Double) ⇒ Double): DoubleSeq

def max: Double

def maxIndex: Int

def maxIndex2: (Int, Int)

def maxNormalize(): Unit

def min: Double

def mkString: String

def mkString(sep: String): String

def mkString(start: String, sep: String, end: String): String

final def multiIndex(i: Int): (Int, Int, Int)

final def ne(arg0: AnyRef): Boolean

def normalize(): Double

def normalizeLogProb(): Double

expNormalize, then put back into log-space.

def normalized: Tensor

final def notify(): Unit

final def notifyAll(): Unit

def numDimensions: Int

def oneNorm: Double

def oneNormalize(): Double

def outer(t: Tensor): Tensor

def printLength: Int

def project(maxNorm: Double): Double

def projected(maxNorm: Double): Tensor

def sampleIndex(normalizer: Double)(implicit r: Random): Int

def sampleIndex(implicit r: Random): Int

Careful, for many subclasses this is inefficient because it calls the method "sum" to get the normalizer.

final def singleIndex(i: Int, j: Int, k: Int): Int

final def size: Int

def sizeHint(size: Int): Unit

def stringPrefix: String

def substitute(f: (Double) ⇒ Double): SparseBinaryTensorLike3.this.type

Like map, but it changes in place.

def substitute(oldValue: Double, newValue: Double): SparseBinaryTensorLike3.this.type

Change all occurrences of oldValue to newValue.

def sum: Double

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

def toArray: Array[Double]

Return the values as an Array[Double].

def toIntArray: Array[Int]

def toSeq: Seq[Double]

With copied contents

def toString(): String

def top(n: Int): TopN[String]

Return records for the n elements with the largest values.

final def twoNorm: Double

def twoNormSquared: Double

def twoNormalize(): Double

def twoSquaredNormalize(): Double

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

def update(i: Int, j: Int, k: Int, v: Double): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zero(): Unit