BaseMetropolisHastings

abstract def logTransitionProbability(start: T, end: T): Double

abstract def observe(x: T): Process[T]

Force the "next" draw to be x, and return a new process.

abstract def proposalDraw(x: T): T

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def aboveOneCount: Long

def aboveOneFrac: Double

def acceptanceCount: Long

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def condition(p: (T) ⇒ Boolean): Rand[T]

def draw(): T

Gets one sample from the distribution.

def drawOpt(): Option[T]

Overridden by filter/map/flatmap for monadic invocations.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(p: (T) ⇒ Boolean): Rand[T]

def finalize(): Unit

def flatMap[E](f: (T) ⇒ Rand[E]): Rand[E]

Converts a random sampler of one type to a random sampler of another type.

def foreach(f: (T) ⇒ Unit): Unit

Samples one element and qpplies the provided function to it.

 for(x <- Rand.uniform) { println(x) } 

def get(): T

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def likelihood(x: T): Double

def likelihoodRatio(start: T, end: T): Double

def logLikelihood(x: T): Double

def logLikelihoodRatio(start: T, end: T): Double

def map[E](f: (T) ⇒ E): Rand[E]

Converts a random sampler of one type to a random sampler of another type.

final def ne(arg0: AnyRef): Boolean

def nextDouble: Double

final def notify(): Unit

final def notifyAll(): Unit

implicit val rand: RandBasis

def rejectionCount: Long

def rejectionFrac: Double

def sample(n: Int): IndexedSeq[T]

Gets n samples from the distribution.

def sample(): T

Gets one sample from the distribution.

def samples: Iterator[T]

An infinitely long iterator that samples repeatedly from the Rand

def samplesVector[U >: T](size: Int)(implicit m: ClassTag[U]): DenseVector[U]

Return a vector of samples.

def step(): (T, Process[T])

Draw a sample and the next step of the process along with it.

def steps: Iterator[T]

Returns an Iterator that automatically moves the Process along as next is called

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

def toString(): String

def total: Long

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter(p: (T) ⇒ Boolean): Rand[T]