Factor

abstract def pr(v1: Child.Value, v2: Parent1.Value): Double

abstract def sampledValue(p1: Parent1.Value)(implicit random: Random): Child.Value

final def !=(arg0: Any): Boolean

final def ##(): Int

def <(that: model.Factor): Boolean

def <=(that: model.Factor): Boolean

final def ==(arg0: Any): Boolean

def >(that: model.Factor): Boolean

def >=(that: model.Factor): Boolean

val _1: Child

val _2: Parent1

var _hashCode: Int

def addLimitedDiscreteCurrentValues1(): Unit

def addLimitedDiscreteCurrentValues12(): Unit

def addLimitedDiscreteValues1(i: Int): Unit

def addLimitedDiscreteValues12(i: Int, j: Int): Unit

final def asInstanceOf[T0]: T0

def assignmentScore(a: variable.Assignment): Double

The ability to score a Values object is now removed, and this is its closest alternative.

def assignmentScoreAndStatistics(a: variable.Assignment): (Double, StatisticsType)

final def assignmentStatistics(a: variable.Assignment): StatisticsType

Return this Factor's sufficient statistics for the values in the Assignment.

def child: C

def clone(): AnyRef

def compare(that: model.Factor): Int

Return an object that can iterate over all value assignments to the neighbors of this Factor

def compareTo(that: model.Factor): Int

def currentAssignment: Assignment2[C, P1]

Return a record of the current values of this Factor's neighbors.

def currentScore: Double

This factor's contribution to the unnormalized log-probability of the current possible world.

def currentScoreAndStatistics: (Double, StatisticsType)

Return the score and statistics of the current neighbor values; this method enables special cases in which it is more efficient to calculate them together.

def currentStatistics: StatisticsType

Return this Factor's sufficient statistics of the current values of the Factor's neighbors.

final def eq(arg0: AnyRef): Boolean

def equalityPrerequisite: AnyRef

In order to two Factors to satisfy "equals", the value returned by this method for each Factor must by "eq".

def equals(other: Any): Boolean

def factorName: String

def finalize(): Unit

final def getClass(): Class[_]

def hasLimitedDiscreteValues1: Boolean

def hasLimitedDiscreteValues12: Boolean

def hashCode(): Int

A hashCode matching the criteria in equals, using hashCode of the Factor's class and of the Factor's neighboring variables.

final def isInstanceOf[T0]: Boolean

def limitedDiscreteValues1: SparseBinaryTensor1

def limitedDiscreteValues12: SparseBinaryTensor2

def logpr(v1: Child.Value, v2: Parent1.Value): Double

def logpr: Double

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def numVariables: Int

The number of variables neighboring this factor.

def parents: Seq[P1]

def pr: Double

def resetCollapsedChild(): Boolean

def sampledValue(implicit random: Random): Child.Value

def score(v1: Child.Value, v2: Parent1.Value): Double

def scoreAndStatistics(v1: Child.Value, v2: Parent1.Value): (Double, StatisticsType)

final def statistics(v1: Child.Value, v2: Parent1.Value): (Child.Value, Parent1.Value)

final def statisticsAreValues: Boolean

True iff the statistics are the values (without transformation), e.g.

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

def toString(): String

def touches(variable: variable.Var): Boolean

Does this Factor have the given variable among its neighbors?

def touchesAny(variables: Iterable[variable.Var]): Boolean

Does this Factor have any of the given variables among its neighbors?

def updateCollapsedChild(): Boolean

def updateCollapsedParents(weight: Double): Boolean

Update sufficient statistics in collapsed parents, using current value of child, with weight.

def valuesScore(tensor: Tensor): Double

Return the score for Factors whose values can be represented as a Tensor, otherwise throw an Error.

def valuesScore1(tensor1: Tensor, tensor2: Tensor): la.Tensor1

Given multiplicative factors on values of neighbor _1 (which allow for limited iteration), and given the Tensor value of neighbor _2, return a Tensor1 containing the scores for each possible value neighbor _1, which must be a DiscreteVar.

def valuesScore2(tensor1: Tensor, tensor2: Tensor): la.Tensor1

def valuesScoreAndStatistics(t: Tensor): (Double, Tensor)

def valuesStatistics(tensor: Tensor): Tensor

Given a Tensor representation of the values, return a Tensor representation of the statistics.

def variable(i: Int): variable.Var

The Nth neighboring variable of this factor.

def variables: IndexedSeq[variable.Var]

Returns the collection of variables neighboring this factor.

final def wait(): Unit

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

final def wait(arg0: Long): Unit