-
final
def
!=(arg0: AnyRef ): Boolean
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
def
*(v: Double): Tensor
-
def
*=(d: Double): Unit
-
def
*=(ds: DoubleSeq ): Unit
-
def
*=(i: Int, incr: Double): Unit
-
-
-
def
+=(t: DoubleSeq , offset: Int, f: Double): Unit
Increment into this DenseTensor at an offset.
-
def
+=(i: Int, incr: Double): Unit
-
def
+=(t: DoubleSeq , f: Double): Unit
-
Increment by the element-wise product of ds and factor.
-
def
+=(a: Array[Double], 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
/(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.
Increment given array (starting at offset index) with contents of this DoubleSeq, multiplied by factor f.
- Definition Classes
- DenseDoubleSeq → DoubleSeq
-
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
_initialArray: Array[Double]
-
def
_resetValues(s: Int): Unit
-
def
_setArray(a: Array[Double]): Unit
-
def
_values: Array[Double]
-
def
_valuesSize: Int
-
def
abs(): Unit
-
def
activeDomain: IntSeq
-
def
activeDomainSize: Int
-
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
- DenseTensor → DoubleSeq
-
final
def
asInstanceOf[T0]: T0
-
def
asSeq: Seq[Double]
With uncopied contents
-
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
- DenseTensor → Tensor
-
def
defaultValue_*=(v: Double): Unit
-
def
defaultValue_+=(v: Double): Unit
-
def
defaultValue_=(v: Double): Unit
-
def
different(t: DoubleSeq , threshold: Double): Boolean
-
def
dimensionsMatch(t: Tensor ): Boolean
-
def
dot(t2: DoubleSeq ): Double
-
def
ensureDimensionsMatch(t: Tensor ): Unit
-
def
entropy: Double
Assumes that the values are already normalized to sum to 1.
Assumes that the values are already normalized to sum to 1.
- Definition Classes
- DoubleSeq
-
final
def
eq(arg0: AnyRef ): Boolean
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
exists(f: (Double) ⇒ Boolean): Boolean
-
def
expNormalize(): Double
Exponentiate the elements of the array, and then normalize them to sum to one.
-
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
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
-
var
hasLogged: Boolean
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
-
def
indexOf(d: Double): Int
-
def
infinityNorm: Double
-
def
initializeRandomly(mean: Double = 0.0, variance: Double = 1.0)(implicit rng: Random): Unit
-
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.
Assumes that the values are already normalized to sum to 1.
- Definition Classes
- DoubleSeq
-
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
- DoubleSeq
-
def
l2Similarity(t: DoubleSeq ): Double
-
def
logpr(index: Int): Double
-
def
map(f: (Double) ⇒ Double): DoubleSeq
-
def
massTotal: Double
-
def
max: Double
-
def
maxIndex: Int
-
def
maxIndex2: (Int, Int)
-
def
maxNormalize(): Unit
-
def
maxToStringLength: Int
-
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
oneNorm: Double
-
def
oneNormalize(): Double
-
-
final
def
pr(i: Int): Double
Get a normalized entry in this Masses, which can be interpreted as a probability.
Get a normalized entry in this Masses, which can be interpreted as a probability.
- Definition Classes
- Proportions → Masses
- Annotations
-
@inline()
-
def
printLength: 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
- Masses → DoubleSeq
-
def
sampleIndex(normalizer: Double)(implicit r: Random): Int
-
final
def
size: Int
-
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
- DenseDoubleSeq → 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