package refine
 Alphabetic
 Public
 All
Type Members

class
BacktrackingStrategy
extends RefiningStrategy
Refining strategies that start with a list of components belonging to a single problem, working bottomup to expand the model lazily.
Refining strategies that start with a list of components belonging to a single problem, working bottomup to expand the model lazily. "Backtracking" refers to the fact that this strategy propagates updates to ensure consistency. For example, if refining the subproblem of an expandable component forces the creation of new subproblems, then the strategy expands subproblems again until this process terminates.
In terms of performance characteristics, it is known that there exist models with n components for which this strategy requires Omega(n^{2}) time. However, upper bounds on running time, as well as sufficient conditions for this algorithm to take linear time, remain open. For an alternative lazy algorithm with better understood performance, consider
RecursionDepthStrategy
. 
abstract
class
DepthFirstStrategy
extends RefiningStrategy
Strategies that recursively refine depthfirst through arguments and subproblems of problem components.
Strategies that recursively refine depthfirst through arguments and subproblems of problem components. These strategies never visit a component more than once; thus they are not reusable.

class
FlatStrategy
extends DepthFirstStrategy
Strategies that refine a fixed set of components without recursing or visiting other components.
Strategies that refine a fixed set of components without recursing or visiting other components. The primary purpose of this strategy is as a ranging tool. New elements will not be added to the collection, unless they belong to newly expanded subproblems, in which case they will be added without being refined. Another way of saying this is that this strategy will not recursively refine subproblems.

class
RecursionDepthStrategy
extends DepthFirstStrategy
Strategies that refine lazily to a fixed recursion depth, as defined in
ComponentCollection
.Strategies that refine lazily to a fixed recursion depth, as defined in
ComponentCollection
. That is, they refine any component belonging to a problem for which the recursion depth associated with that subproblem is at most the depth given.This strategy has the advantage that it guarantees no need for backtracking, because components are never visited more than once. This is made possible by the fact that the depth of a component is known at the time of expansion; i.e. it cannot change. However, this strategy is not universal: it may fail when a model uses a recursive process for which the associated component collection fails to increment the depth. For example, if one uses a recursive model without Chain function memoization and uses a
SelectiveIncrementingCollection
, the collection will not increment the depth at socalled recursive calls. ARecursionDepthStrategy
running on such a model will fail to terminate. 
abstract
class
RefiningStrategy
extends AnyRef
A refining strategy takes an inference problem over a set of factors and improves it to better reflect the underlying model.
A refining strategy takes an inference problem over a set of factors and improves it to better reflect the underlying model. The exact notion of "improvement" should be specified in subclasses. The most common use cases include generating ranges, expanding additional subproblems, or sampling additional values for elements with infinite ranges.
Refining is separate from solving, but can be thought of as the process of deciding how much of a problem we want to solve.

class
TopDownStrategy
extends FlatStrategy
Strategies that refine a fixed set of components, as well as all dependent components that are also in the collection.
Value Members
 object TopDownStrategy