HeuristicCollapseStrategy

abstract def burnIn(): Int

Number of samples to throw away initially.

abstract def createBlocks(): List[Block]

Method to create a blocking scheme given information about the model and factors.

abstract val dependentAlgorithm: (Universe, List[NamedEvidence[_]]) ⇒ () ⇒ Double

The algorithm to compute probability of specified evidence in a dependent universe.

abstract val dependentUniverses: List[(Universe, List[NamedEvidence[_]])]

A list of universes that depend on this universe such that evidence on those universes should be taken into account in this universe.

abstract def doKill(): Unit

abstract def doResume(): Unit

abstract def doStart(): Unit

abstract def doStop(): Unit

abstract def interval(): Int

Iterations thrown away between samples.

abstract val targetElements: List[Element[_]]

Elements whose samples will be recorded at each iteration.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

var active: Boolean

def addFactor[T](factor: Factor[T], map: Map[Variable[_], MultiSet[Factor[T]]]): Unit

add a factor to the list

var allLastUpdates: Map[Element[_], LastUpdate[_]]

var allTimesSeen: Map[Element[_], TimesSeen[_]]

var alpha: Int

Only variables with alpha or fewer neighbors in the primal graph are candidates for collapsing.

var alphaChoose2: Double

We use ( alpha C 2 ) often, may as well store it.

final def asInstanceOf[T0]: T0

var blockSamplerCreate: BlockSamplerCreator

var blockSamplers: List[BlockSampler]

def cleanUp(): Unit

Called when the algorithm is killed.

def clone(): AnyRef

def collapseVariables(): Unit

Perform the collapsing step.

def correctBlocks(originalBlocks: List[Block]): List[Block]

We want to alter the original blocks so that we filter out any variables which have been eliminated.

val currentSamples: Map[Variable[_], Int]

The most recent set of samples, used for sampling variables conditioned on the values of other variables.

def distributionDistance[T, U](var1: Variable[T], var2: Variable[U]): Double

Hellinger distance is defined in the source paper (amongst other places).

def doSample(): Unit

def eliminate(variable: Variable[_], factors: MultiSet[Factor[Double]], map: Map[Variable[_], MultiSet[Factor[Double]]]): Unit

Eliminate a variable.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

var factors: List[Factor[Double]]

List of all factors.

def finalize(): Unit

var gamma: Int

final def getClass(): Class[_]

def getFactors(neededElements: List[Element[_]], targetElements: List[Element[_]], upperBounds: Boolean = false): List[Factor[Double]]

All implementations of factored algorithms must specify a way to get the factors from the given universe and dependent universes.

def getNeededElements(starterElements: List[Element[_]], depth: Int, parameterized: Boolean = false): (List[Element[_]], Boolean)

Get the elements that are needed by the query target variables and the evidence variables.

def getSampleCount: Int

Number of samples taken

var globalGraph: VEGraph

globalGraph lets us traverse the primal graph.

def graphHeuristicFunction[T](var1: Variable[T]): Double

Compute the score of a given variable.

def graphTerm[T](var1: Variable[T]): Double

Returns how many edges would be added to the primal graph by removing var1.

def hashCode(): Int

var hellingerDistances: Map[(Int, Int), Double]

def initUpdates(): Unit

def initialize(): Unit

Called when the algorithm is started before running any steps.

def isActive: Boolean

final def isInstanceOf[T0]: Boolean

def kill(): Unit

Kill the algorithm so that it is inactive.

def makeResultFactor(factorsAfterElimination: MultiSet[Factor[Double]]): Factor[Double]

Combine all the remaining factors into one 'result factor', as in VE.

def marginalize(resultFactor: Factor[Double]): List[Factor[Double]]

Marginalize all factors to their component variables.

def marginalizeToTarget(factor: Factor[Double], target: Variable[_]): Factor[Double]

Marginalize a factor to a particular variable.

var marginals: Map[Int, Map[Int, Double]]

final def ne(arg0: AnyRef): Boolean

def newLastUpdate[T](target: Element[T]): LastUpdate[T]

def newTimesSeen[T](target: Element[T]): TimesSeen[T]

final def notify(): Unit

final def notifyAll(): Unit

var numSamplesSeenSoFar: Int

var originalBlocks: List[Block]

var pairwiseMarignals: Map[(Int, Int), Map[(Int, Int), Double]]

lazy val queryTargets: List[Element[_]]

def removeFactor[T](factor: Factor[T], map: Map[Variable[_], MultiSet[Factor[T]]]): Unit

remove a factor from the list

def resetCounts(): Unit

def resetMarginals(): Unit

Reset all the marginal and p.m.

def resume(): Unit

Resume the computation of the algorithm, if it has been stopped.

def sample(): (Boolean, Sample)

Produce a single sample.

def sampleAllBlocks(): Unit

def sampleAllBlocksWithTracking(): Unit

Sample all blocks, then store that sample in the marginal and p.m.

var sampleCount: Int

val semiring: LogSumProductSemiring

Semiring for use in factors.

def sortByHeuristic(varList: List[Variable[_]], HeuristicMap: Map[Variable[_], Double]): List[Variable[_]]

Sort variables by the target heuristic, if they have fewer than alpha neighbors and are not targets.

def start(): Unit

Start the algorithm and make it active.

def stop(): Unit

Stop the algorithm from computing.

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

var targetVariables: List[Variable[_]]

List of variables corresponding to target elements.

var targs: Seq[Element[_]]

Store which elements are our target variables so that subclasses can make use of them.

def toString(): String

var totalSamples: Int

val trackingSamples: Int

val universe: Universe

def update(): Unit

def updateDistances(): Unit

Use the marginal maps to compute Hellinger maps.

def updateTimesSeenForTarget[T](elem: Element[T], newValue: T): Unit

def updateTimesSeenWithValue[T](value: T, timesSeen: TimesSeen[T], seen: Int): Unit

var upperB: Boolean

Store which elements are our target variables so that subclasses can make use of them.

var variables: Set[Variable[_]]

Variables to sample at each time step.

var varsInOrder: List[Variable[_]]

We need a list of variables in order so we can access them by index.

final def wait(): Unit

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

final def wait(arg0: Long): Unit