-
final
def
!=(arg0: AnyRef ): Boolean
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
-
-
def
*=(ds: DoubleSeq ): Unit
-
def
*=(d: Double): Unit
-
def
*=(i: Int, incr: Double): Unit
-
-
-
-
def
+=(i: Int, incr: Double): 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
-=(ds: DoubleSeq ): Unit
-
final
def
-=(d: Double): Unit
-
def
-=(i: Int, incr: Double): Unit
-
-
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
_indices: Array[Int]
-
def
_makeReadable(): Unit
-
def
_unsafeActiveDomainSize: Int
-
-
def
abs(): Unit
-
-
def
activeDomain1: IntSeq
-
val
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
-
def
apply(i: 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
-
-
final
def
booleanValue: Boolean
-
val
category: Boolean
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
-
@throws(
...
)
-
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
-
val
dim1: Int
-
def
dimensions: Array[Int]
-
def
dimensionsMatch(t: Tensor ): Boolean
-
-
def
dot(t: 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
-
final
def
intValue: Int
-
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
-
val
singleIndex: Int
-
def
singleValue: Double
-
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
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.
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