class LazyVariableElimination extends FactoredAlgorithm[Double] with LazyAlgorithm
Algorithm that lazily performs variable elimination. This algorithm is a lazy algorithm that can be run to any depth. Given a depth, it expands the model up to that depth and creates factors for the expanded elements. It also creates factors that capture the effect of parts of the model that have not been expanded on the query targets. These factors are used to compute lower or upper bounds on the queries. Then it uses ordinary variable elimination to solve these factors.
 Alphabetic
 By Inheritance
 LazyVariableElimination
 LazyAlgorithm
 FactoredAlgorithm
 Algorithm
 AnyRef
 Any
 Hide All
 Show All
 Public
 All
Instance Constructors
Value Members

final
def
!=(arg0: Any): Boolean
 Definition Classes
 AnyRef → Any

final
def
##(): Int
 Definition Classes
 AnyRef → Any

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

val
active: Boolean
 Attributes
 protected
 Definition Classes
 Algorithm

final
def
asInstanceOf[T0]: T0
 Definition Classes
 Any

def
cleanUp(): Unit
Called when the algorithm is killed.
Called when the algorithm is killed. By default, does nothing. Can be overridden.
 Definition Classes
 Algorithm

def
clone(): AnyRef
 Attributes
 protected[java.lang]
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )

val
comparator: Option[(Double, Double) ⇒ Boolean]
Some variable elimination algorithms, such as computing the most probable explanation, record values of variables as they are eliminated.
Some variable elimination algorithms, such as computing the most probable explanation, record values of variables as they are eliminated. Such values are stored in a factor that maps values of the other variables to a value of the eliminated variable. This factor is produced by finding the value of the variable that "maximizes" the entry associated with the value in the product factor resulting from eliminating this variable, for some maximization function. The recordingFunction determines which of two entries is greater according to the maximization function. It returns true iff the second entry is greater. The recording function is an option so that variable elimination algorithms that do not use it can ignore it.
 var currentResult: Factor[(Double, Double)]
 var debug: Boolean

val
dependentAlgorithm: Null
 Definition Classes
 LazyVariableElimination → FactoredAlgorithm

val
dependentUniverses: List[Nothing]
 Definition Classes
 LazyVariableElimination → FactoredAlgorithm

val
depth: Int
The current depth to which the algorithm should be run.
The current depth to which the algorithm should be run.
 Definition Classes
 LazyAlgorithm

def
doElimination(allFactors: List[Factor[Double]], targetVariables: Seq[Variable[_]]): Set[Factor[Double]]
 Attributes
 protected

def
doKill(): Unit
Kill the algorithm.
Kill the algorithm.
 Definition Classes
 LazyAlgorithm → Algorithm

def
doResume(): Unit
Resume the algorithm by increasing the depth and running again.
Resume the algorithm by increasing the depth and running again.
 Definition Classes
 LazyAlgorithm → Algorithm

def
doStart(): Unit
Start the algorithm.
Start the algorithm. This will run the algorithm to one depth.
 Definition Classes
 LazyAlgorithm → Algorithm

def
doStop(): Unit
Stop the algorithm.
Stop the algorithm.
 Definition Classes
 LazyAlgorithm → Algorithm

def
eliminationOrder(allVars: Set[Variable[_]], factors: Traversable[Factor[Double]], toPreserve: Traversable[Variable[_]]): List[Variable[_]]
Method for choosing the elimination order.
Method for choosing the elimination order. The default order chooses first the variable that minimizes the number of extra factor entries that would be created when it is eliminated. Override this method if you want a different rule.

final
def
eq(arg0: AnyRef): Boolean
 Definition Classes
 AnyRef

def
equals(arg0: Any): Boolean
 Definition Classes
 AnyRef → Any

def
finalize(): Unit
 Attributes
 protected[java.lang]
 Definition Classes
 AnyRef
 Annotations
 @throws( classOf[java.lang.Throwable] )

def
finishNoBounds(factorsAfterElimination: Set[Factor[Double]]): Factor[(Double, Double)]
Postprocess the factors produced by eliminating variables, assuming the entire model has been expanded so the lower and upper bounds are the same.

def
finishWithBounds(lowerFactors: Set[Factor[Double]], upperFactors: Set[Factor[Double]]): Factor[(Double, Double)]
Postprocess the factors produced by eliminating variables, when the lower and upper bounds may be different.
Postprocess the factors produced by eliminating variables, when the lower and upper bounds may be different.
 lowerFactors
the factors produced with the upperBounds flag = false
 upperFactors
the factors produced with the upperBounds flag = true

final
def
getClass(): Class[_]
 Definition Classes
 AnyRef → Any

def
getFactors(neededElements: List[Element[_]], targetElements: List[Element[_]], upperBounds: Boolean = false): List[Factor[Double]]
Create the necessary factors.
Create the necessary factors.
 neededElements
elements that have been expanded that need factors created
 targetElements
query targets
 upperBounds
flag indicating whether lower (false) or upper (true) bounds should be computed for unexpanded parts of the model
 Definition Classes
 LazyVariableElimination → FactoredAlgorithm

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.
Get the elements that are needed by the query target variables and the evidence variables. Also compute the values of those variables to the given depth. Only get factors for elements that are actually used by the target variables. This is more efficient. Also, it avoids problems when values of unused elements have not been computed.
In addition to getting all the needed elements, it determines if any of the conditioned, constrained, or dependent universe parent elements has * in its range. If any of these elements has * in its range, the lower and upper bounds of factors will be different, so we need to compute both. If they don't, we don't need to compute bounds.
 Definition Classes
 FactoredAlgorithm

def
hashCode(): Int
 Definition Classes
 AnyRef → Any

def
initialize(): Unit
Called when the algorithm is started before running any steps.
Called when the algorithm is started before running any steps. By default, does nothing. Can be overridden.
 Definition Classes
 Algorithm

def
isActive: Boolean
 Definition Classes
 Algorithm

final
def
isInstanceOf[T0]: Boolean
 Definition Classes
 Any

def
kill(): Unit
Kill the algorithm so that it is inactive.
Kill the algorithm so that it is inactive. It will no longer be able to provide answers.Throws AlgorithmInactiveException if the algorithm is not active.
 Definition Classes
 Algorithm

final
def
ne(arg0: AnyRef): Boolean
 Definition Classes
 AnyRef

final
def
notify(): Unit
 Definition Classes
 AnyRef

final
def
notifyAll(): Unit
 Definition Classes
 AnyRef

def
probabilityBounds[T](target: Element[_], value: T): (Double, Double)
Returns the lower and upper bounds of the probability of the target.

def
pump(): Unit
Increase the depth and run the algorithm again.
Increase the depth and run the algorithm again.
 Definition Classes
 LazyAlgorithm

var
recordingFactors: List[Factor[_]]
 Attributes
 protected

def
resume(): Unit
Resume the computation of the algorithm, if it has been stopped.
Resume the computation of the algorithm, if it has been stopped. Throws AlgorithmInactiveException if the algorithm is not active.
 Definition Classes
 Algorithm

def
run(depth: Int): Unit
Run the algorithm to the given depth.
Run the algorithm to the given depth.
 Definition Classes
 LazyVariableElimination → LazyAlgorithm

val
semiring: SumProductSemiring
 Definition Classes
 LazyVariableElimination → FactoredAlgorithm
 var showTiming: Boolean

def
start(): Unit
Start the algorithm and make it active.
Start the algorithm and make it active. After it returns, the algorithm must be ready to provide answers. Throws AlgorithmActiveException if the algorithm is already active.
 Definition Classes
 Algorithm

def
stop(): Unit
Stop the algorithm from computing.
Stop the algorithm from computing. The algorithm is still ready to provide answers after it returns. Throws AlgorithmInactiveException if the algorithm is not active.
 Definition Classes
 Algorithm

final
def
synchronized[T0](arg0: ⇒ T0): T0
 Definition Classes
 AnyRef
 var targetFactors: Map[Element[_], Factor[(Double, Double)]]

def
toString(): String
 Definition Classes
 AnyRef → Any

implicit
val
universe: Universe
 Definition Classes
 LazyVariableElimination → FactoredAlgorithm

final
def
wait(): Unit
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )

final
def
wait(arg0: Long, arg1: Int): Unit
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )

final
def
wait(arg0: Long): Unit
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )