-
final
def
!=(arg0: AnyRef ): Boolean
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
-
def
*(f: Double): Tensor1
-
def
*=(ds: DoubleSeq ): Unit
-
def
*=(d: Double): Unit
-
def
*=(i: Int, incr: Double): Unit
-
-
-
def
++=(is: Iterable[Int]): Unit
-
def
++=(is: Array[Int]): Unit
-
-
def
+=(i: Int, v: Double): Unit
In SparseBinary, this is equivalent to update(i,v)
-
def
+=(i: Int): 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
-=(i: Int): Unit
-
def
-=(ds: DoubleSeq ): Unit
-
final
def
-=(d: Double): Unit
-
def
-=(i: Int, incr: Double): Unit
-
def
/(f: Double): Tensor1
-
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: AnyRef ): Boolean
-
final
def
==(arg0: Any): Boolean
-
-
def
_appendAll(elts: TraversableOnce[Int]): Unit
-
def
_appendAll(elts: Array[Int]): Unit
-
-
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(): Unit
-
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.
Return the index at which value i should be inserted in order to maintain sorted order.
This assumes that the existing elements already already sorted. If value i is already present, return its index.
- Attributes
- protected
- Definition Classes
- ProtectedIntArrayBuffer
-
def
_indexForInsertSortedLinear(i: Int): Int
-
def
_indexOf(i: Int): Int
Return the index containing the value i, or -1 if i is not found.
Return the index containing the value i, or -1 if i is not found.
- Attributes
- protected
- Definition Classes
- ProtectedIntArrayBuffer
-
def
_indexOfSorted(i: Int): Int
Return the index containing the value i, or -1 if i is not found.
Return the index containing the value i, or -1 if i is not found. Do so more efficiently by assuming that the contents are sorted in ascending order.
Look by starting near the last index as which a search was successful.
- Attributes
- protected
- Definition Classes
- ProtectedIntArrayBuffer
-
def
_indices: Array[Int]
Efficient (but dangerous) direct access to underlying array of indices.
Efficient (but dangerous) direct access to underlying array of indices. Note that the array.length may be larger than the number of indices.
- Definition Classes
- ArraySparseBinaryTensor → SparseTensor
-
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
_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
-
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
abs(): Unit
-
-
def
activeDomain1: IntSeq
-
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.
Append a string representation of this DoubleSeq to the StringBuilder.
- Definition Classes
- DoubleSeq
-
final
def
apply(index: Int): Double
-
def
asArray: Array[Double]
Return the values as an Array[Double].
Return the values as an Array[Double]. Not guaranteed to be a copy; in fact if it is possible to return a pointer to an internal array, it will simply return this.
- Definition Classes
- DoubleSeq
-
final
def
asInstanceOf[T0]: T0
-
def
asSeq: Seq[Double]
With uncopied contents
-
def
blankCopy: Tensor1
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
-
@throws(
...
)
-
final
def
contains(index: Int): Boolean
-
def
contains(d: Double): Boolean
-
def
containsNaN: Boolean
-
-
def
cosineSimilarity(t: DoubleSeq ): Double
-
def
defaultValue: Double
The default value at indices not covered by activeDomain.
The default value at indices not covered by activeDomain. Subclasses may override this
- Definition Classes
- Tensor
-
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
- Definition Classes
- AnyRef → Any
-
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.
Exponential the elements of the array such that they are normalized to sum to one,
but do so efficiently by providing logZ. Note that to maximize efficiency, this method
does not verify that the logZ value was the correct one to cause proper normalization.
- Definition Classes
- MutableDoubleSeq
-
def
expNormalize(): Double
Exponentiate the elements of the array, and then normalize them to sum to one.
Exponentiate the elements of the array, and then normalize them to sum to one.
- Definition Classes
- MutableDoubleSeq
-
def
expNormalized: Tensor
-
def
exponentiate(): Unit
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
-
@throws(
classOf[java.lang.Throwable]
)
-
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[_]
- Definition Classes
- AnyRef → Any
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
-
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.
Assumes that the values in both DoubleSeq are already normalized to sum to 1.
- Definition Classes
- SparseDoubleSeq → DoubleSeq
-
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
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
printLength: Int
-
def
reshape(dim: Array[Int]): 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.
Careful, for many subclasses this is inefficient because it calls the method "sum" to get the normalizer.
- Definition Classes
- DoubleSeq
-
final
def
size: Int
-
def
sizeHint(size: Int): Unit
-
def
stringPrefix: String
-
def
substitute(oldValue: Double, newValue: Double): Unit
-
def
sum: Double
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
def
toArray: Array[Double]
Return the values as an Array[Double].
Return the values as an Array[Double]. Guaranteed to be a copy, not just a pointer to an internal array that would change with changes to the DoubleSeq
- Definition Classes
- SparseDoubleSeq → DoubleSeq
-
def
toIntArray: Array[Int]
-
def
toSeq: Seq[Double]
With copied contents
-
def
toString(): String
- Definition Classes
- Tensor → AnyRef → Any
-
def
top(n: Int): TopN[String]
Return records for the n elements with the largest values.
Return records for the n elements with the largest values.
- Definition Classes
- DoubleSeq
-
final
def
twoNorm: Double
-
def
twoNormSquared: Double
-
def
twoNormalize(): Double
-
def
twoSquaredNormalize(): Double
-
def
update(i: Int, v: Double): Unit
-
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
zero(): Unit