Packages

package refine

Ordering
  1. Alphabetic
Visibility
  1. Public
  2. All

Type Members

  1. class BacktrackingStrategy extends RefiningStrategy

    Refining strategies that start with a list of components belonging to a single problem, working bottom-up to expand the model lazily.

    Refining strategies that start with a list of components belonging to a single problem, working bottom-up 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(n2) 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.

  2. abstract class DepthFirstStrategy extends RefiningStrategy

    Strategies that recursively refine depth-first through arguments and subproblems of problem components.

    Strategies that recursively refine depth-first through arguments and subproblems of problem components. These strategies never visit a component more than once; thus they are not reusable.

  3. 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.

  4. 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 so-called recursive calls. A RecursionDepthStrategy running on such a model will fail to terminate.

  5. 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.

  6. 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

  1. object TopDownStrategy

Ungrouped