compound

Type Members

class BooleanElement extends AnyRef

Elements over Booleans on which element-level Boolean operators are defined.
class CPD1[T1, U] extends CachingChain[T1, U]

A conditional probability distribution with one parent.
class CPD2[T1, T2, U] extends CachingChain[(T1, T2), U]

A conditional probability distribution with two parents.
class CPD3[T1, T2, T3, U] extends CachingChain[(T1, T2, T3), U]

A conditional probability distribution with three parents.
class CPD4[T1, T2, T3, T4, U] extends CachingChain[(T1, T2, T3, T4), U]

A conditional probability distribution with four parents.
class CPD5[T1, T2, T3, T4, T5, U] extends CachingChain[(T1, T2, T3, T4, T5), U]

A conditional probability distribution with five parents.
sealed abstract class CPDCase[-T] extends AnyRef

A case in a conditional probability distribution.
class DoubleElement extends AnyRef

Elements over Doubles on which element-level Double operators are defined.
class DuoElement[T1, T2] extends AnyRef

Elements over pairs on which element-level component extraction is defined.
class Eq[T] extends Apply2[T, T, Boolean]

Element representing equality between two elements.
Element representing equality between two elements. You can use the === operator defined on elements to create this element.
class FastIf[T] extends Apply1[Boolean, T]

Element that conditions on the test and results in either the then clause or else clause.
Element that conditions on the test and results in either the then clause or else clause. The then and else clauses are constants.
class FoldLeft[T, U] extends Deterministic[U] with ValuesMaker[U]

Element representing the folding of a function through a sequence of elements.
Element representing the folding of a function through a sequence of elements. Elements are processed left to right. Factored algorithms use the decomposition of the fold to avoid creating huge factors.
class If[T] extends CachingChain[Boolean, T]

Element that conditions on the test and results in either the then clause or else clause.
Element that conditions on the test and results in either the then clause or else clause. The then and else clauses are elements.
class IntElement extends AnyRef

Elements over Ints on which element-level Int operators are defined.
class IntSelector extends Element[Int] with IfArgsCacheable[Int] with ValuesMaker[Int]

An IntSelector represents the selection of an integer from 0 (inclusive) to a variable upper bound (exclusive).
An IntSelector represents the selection of an integer from 0 (inclusive) to a variable upper bound (exclusive). The upper bound is an element represented by the bound argument. The IntSelector class has been defined so that (1) the value is always uniformly distributed in the range, no matter how the upper bound changes, and (2) it attempts to avoid changing the value as much as it possibly can as the upper bound changes. This latter property makes the class useful in an algorithm like Metropolis-Hastings, where we would like to change as little as possible as we make a proposal.
class Neq[T] extends Apply2[T, T, Boolean]

Element representing inequality between two elements.
Element representing inequality between two elements. You can use the !== operator defined on elements to create this element.
case class NoneOf[T](elems: T*) extends CPDCase[T] with Product with Serializable

A case in a conditional probability distribution that excludes the given elements.
case class OneOf[T](elems: T*) extends CPDCase[T] with Product with Serializable

A case in a conditional probability distribution that includes the given elements.
class QuartetElement[T1, T2, T3, T4] extends AnyRef

Elements over quadruples on which element-level component extraction is defined.
class QuintetElement[T1, T2, T3, T4, T5] extends AnyRef

Elements over quintuples on which element-level component extraction is defined.
class RichCPD1[T1, U] extends CachingChain[T1, U]

A conditional probability distributions with rich cases with one parent.
class RichCPD2[T1, T2, U] extends CachingChain[(T1, T2), U]

A conditional probability distributions with rich cases with two parents.
class RichCPD3[T1, T2, T3, U] extends CachingChain[(T1, T2, T3), U]

A conditional probability distributions with rich cases with three parents.
class RichCPD4[T1, T2, T3, T4, U] extends CachingChain[(T1, T2, T3, T4), U]

A conditional probability distributions with rich cases with four parents.
class RichCPD5[T1, T2, T3, T4, T5, U] extends CachingChain[(T1, T2, T3, T4, T5), U]

A conditional probability distributions with rich cases with five parents.
class TrioElement[T1, T2, T3] extends AnyRef

Elements over triples on which element-level component extraction is defined.
class MakeList[T] extends Apply1[List[T], List[T]]

An element representing making a list of a random number of random items.
An element representing making a list of a random number of random items. The first argument is an element representing the number of items. The second argument is an expression that generates an element representing an item. MakeList is designed to store all the item elements and not change them as the number of elements changes.

Annotations
@deprecated
Deprecated
(Since version 3.2.1) MakeList is deprecated. Please use the collections library for future support of MakeList capabilities

Value Members

object * extends CPDCase[Any] with Product with Serializable

A "wild-card" case in a conditional probability distribution that includes all elements.
object CPD
object FoldLeft
object FoldRight

Element representing the folding of a function through a sequence of elements.
Element representing the folding of a function through a sequence of elements. Elements are processed right to left. Factored algorithms use the decomposition of the fold to avoid creating huge factors.
object If
object IntSelector
object MakeList
object Reduce

Element representing the reducing of a function through a sequence of elements, with no initial value.
Element representing the reducing of a function through a sequence of elements, with no initial value. Elements are processed left to right. Factored algorithms use the decomposition of the fold to avoid creating huge factors.
object RichCPD
object ^^

package compound

Type Members

class BooleanElement extends AnyRef

class CPD1[T1, U] extends CachingChain[T1, U]

class CPD2[T1, T2, U] extends CachingChain[(T1, T2), U]

class CPD3[T1, T2, T3, U] extends CachingChain[(T1, T2, T3), U]

class CPD4[T1, T2, T3, T4, U] extends CachingChain[(T1, T2, T3, T4), U]

class CPD5[T1, T2, T3, T4, T5, U] extends CachingChain[(T1, T2, T3, T4, T5), U]

sealed abstract class CPDCase[-T] extends AnyRef

class DoubleElement extends AnyRef

class DuoElement[T1, T2] extends AnyRef

class Eq[T] extends Apply2[T, T, Boolean]

class FastIf[T] extends Apply1[Boolean, T]

class FoldLeft[T, U] extends Deterministic[U] with ValuesMaker[U]

class If[T] extends CachingChain[Boolean, T]

class IntElement extends AnyRef

class IntSelector extends Element[Int] with IfArgsCacheable[Int] with ValuesMaker[Int]

class Neq[T] extends Apply2[T, T, Boolean]

case class NoneOf[T](elems: T*) extends CPDCase[T] with Product with Serializable

case class OneOf[T](elems: T*) extends CPDCase[T] with Product with Serializable

class QuartetElement[T1, T2, T3, T4] extends AnyRef

class QuintetElement[T1, T2, T3, T4, T5] extends AnyRef

class RichCPD1[T1, U] extends CachingChain[T1, U]

class RichCPD2[T1, T2, U] extends CachingChain[(T1, T2), U]

class RichCPD3[T1, T2, T3, U] extends CachingChain[(T1, T2, T3), U]

class RichCPD4[T1, T2, T3, T4, U] extends CachingChain[(T1, T2, T3, T4), U]

class RichCPD5[T1, T2, T3, T4, T5, U] extends CachingChain[(T1, T2, T3, T4, T5), U]

class TrioElement[T1, T2, T3] extends AnyRef

class MakeList[T] extends Apply1[List[T], List[T]]

Value Members

object * extends CPDCase[Any] with Product with Serializable

object CPD

object FoldLeft

object FoldRight

object If

object IntSelector

object MakeList

object Reduce

object RichCPD

object ^^

Ungrouped