Trait/Object

Dist

Related Docs: object Dist | package random

Permalink

trait Dist[A] extends Any

Self Type: Dist[A]

Linear Supertypes

Any

Known Subclasses

Ordering

Alphabetic
By Inheritance

Inherited

Dist
Any

Hide All
Show All

Visibility

Public
All

Abstract Value Members

abstract def apply(gen: Generator): A
abstract def getClass(): Class[_]

Definition Classes
Any

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
Any
final def ==(arg0: Any): Boolean

Definition Classes
Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
final def count(pred: (A) ⇒ Boolean, n: Int)(implicit gen: Generator): Int
def equals(arg0: Any): Boolean

Definition Classes
Any
def ev(n: Int)(implicit gen: Generator, alg: Field[A]): A
def fill(gen: Generator, arr: Array[A]): Unit
final def filter(pred: (A) ⇒ Boolean): Dist[A]
final def flatMap[B](f: (A) ⇒ Dist[B]): Dist[B]
def foldn[B](init: B, n: Int)(f: (B, A) ⇒ B): Dist[B]
final def given(pred: (A) ⇒ Boolean): Dist[A]
def hashCode(): Int

Definition Classes
Any
def histogram(n: Int)(implicit gen: Generator): Map[A, Double]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterate(n: Int, f: (A) ⇒ Dist[A]): Dist[A]
def iterateUntil(pred: (A) ⇒ Boolean, f: (A) ⇒ Dist[A]): Dist[A]
final def map[B](f: (A) ⇒ B): Dist[B]
def pack(n: Int)(implicit ct: ClassTag[A]): Dist[Array[A]]
def pr(pred: (A) ⇒ Boolean, n: Int)(implicit gen: Generator): Double
def rawHistogram(n: Int)(implicit gen: Generator): Map[A, Int]
def repeat[CC[X] <: Seq[X]](n: Int)(implicit cbf: CanBuildFrom[Nothing, A, CC[A]]): Dist[CC[A]]
def sample[CC[X] <: Iterable[X]](n: Int)(implicit gen: Generator, cbf: CanBuildFrom[CC[A], A, CC[A]]): CC[A]
def sum(n: Int)(implicit gen: Generator, alg: Rig[A]): A
final def toIterator(gen: Generator): Iterator[A]
final def toStream(gen: Generator): Stream[A]
def toString(): String

Definition Classes
Any
def unfold[B](init: B)(f: (B, A) ⇒ B)(pred: (B) ⇒ Boolean): Dist[B]
def until(pred: (A) ⇒ Boolean): Dist[Seq[A]]
final def zip[B](that: Dist[B]): Dist[(A, B)]
def zipWith[B, C](that: Dist[B])(f: (A, B) ⇒ C): Dist[C]

Inherited from Any

Ungrouped