Distribution

abstract def get: A

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def *(x: A)(implicit n: Numeric[A]): Distribution[A]

def *(d: Distribution[A])(implicit n: Numeric[A]): Distribution[A]

def +(x: A)(implicit n: Numeric[A]): Distribution[A]

def +(d: Distribution[A])(implicit n: Numeric[A]): Distribution[A]

def -(x: A)(implicit n: Numeric[A]): Distribution[A]

def -(d: Distribution[A])(implicit n: Numeric[A]): Distribution[A]

def /(x: A)(implicit toDouble: <:<[A, Double]): Distribution[Double]

def /(d: Distribution[A])(implicit toDouble: <:<[A, Double]): Distribution[Double]

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def bucketedHist(min: Double, max: Double, nbuckets: Int, roundDown: Boolean = false)(implicit ord: Ordering[A], toDouble: <:<[A, Double]): Unit

def bucketedHist(buckets: Int)(implicit ord: Ordering[A], toDouble: <:<[A, Double]): Unit

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def ev(implicit toDouble: <:<[A, Double]): Double

def filter(pred: (A) ⇒ Boolean): Distribution[A]

def finalize(): Unit

def flatMap[B](f: (A) ⇒ Distribution[B]): Distribution[B]

def freeze: Distribution[A]

"Freeze" a distribution by taking a sample and serving values out of that sample at random.

final def getClass(): java.lang.Class[_]

def given(pred: (A) ⇒ Boolean): Distribution[A]

def hashCode(): Int

def hist(implicit ord: Ordering[A] = null, d: <:<[A, Double] = null): Unit

def histData: Map[A, Double]

final def isInstanceOf[T0]: Boolean

def kurtosis(implicit toDouble: <:<[A, Double]): Double

def map[B](f: (A) ⇒ B): Distribution[B]

def markov(pred: (A) ⇒ Boolean)(f: (A) ⇒ Distribution[A]): Distribution[A]

final def markov(n: Int)(f: (A) ⇒ Distribution[A]): Distribution[A]

Markov chains

def mean(implicit toDouble: <:<[A, Double]): Double

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def posterior[B](experiment: (A) ⇒ Distribution[B])(observed: (B) ⇒ Boolean): Distribution[A]

Using this distribution as a prior, compute the posterior distribution after running an experiment and observing some outcomes and not others.

def pr(pred: (A) ⇒ Boolean, given: (A) ⇒ Boolean = (a: A) => true, samples: Int = N): Double

def repeat(n: Int): Distribution[List[A]]

def sample(n: Int = N): List[A]

def skewness(implicit toDouble: <:<[A, Double]): Double

def stdev(implicit toDouble: <:<[A, Double]): Double

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

def toString(): String

def until(pred: (List[A]) ⇒ Boolean): Distribution[List[A]]

def variance(implicit toDouble: <:<[A, Double]): Double

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zip[B](d: Distribution[B]): Distribution[(A, B)]

def zipWith[B, C](d: Distribution[B])(f: (A, B) ⇒ C): Distribution[C]