IntStrategyFactory (org.choco-solver-choco-solver 3.3.1-j7 API)

java.lang.Object
- org.chocosolver.solver.search.strategy.IntStrategyFactory

Direct Known Subclasses:

ISF
```
public class IntStrategyFactory
extends Object
```
Strategies, Variable selectors and Value selectors factory. Just there to simplify strategies creation.

Since:

5 juil. 2010

Author:

Charles Prud'homme, Jean-Guillaume Fages

Method Summary

Methods
Modifier and Type	Method and Description
`static AbstractStrategy<IntVar>`	`activity(IntVar[] VARS, double GAMMA, double DELTA, int ALPHA, double RESTART, int FORCE_SAMPLING, long SEED)` Deprecated.
`static AbstractStrategy<IntVar>`	`activity(IntVar[] VARS, double GAMMA, double DELTA, int ALPHA, int FORCE_SAMPLING, long SEED)` Create an Activity based search strategy.
`static AbstractStrategy<IntVar>`	`activity(IntVar[] VARS, long SEED)` Create an Activity based search strategy.
`static DecisionOperator<IntVar>`	`assign()` Assign the selected variable to the selected value e.g.
`static IntStrategy`	`custom(VariableSelector<IntVar> VAR_SELECTOR, IntValueSelector VAL_SELECTOR, DecisionOperator<IntVar> DEC_OPERATOR, IntVar... VARS)` Builds your own search strategy
`static IntStrategy`	`custom(VariableSelector<IntVar> VAR_SELECTOR, IntValueSelector VAL_SELECTOR, IntVar... VARS)` Builds your own assignment strategy : Selects a variable X and a value V to make the decision X = V.
`static AbstractStrategy<IntVar>`	`domOverWDeg(IntVar[] VARS, long SEED)` Assignment strategy which selects a variable according to `DomOverWDeg` and assign it to its lower bound
`static AbstractStrategy<IntVar>`	`domOverWDeg(IntVar[] VARS, long SEED, IntValueSelector VAL_SELECTOR)` Assignment strategy which selects a variable according to `DomOverWDeg` and assign it to the selected value
`static AbstractStrategy<IntVar>`	`generateAndTest(Solver SOLVER)` Create a Generate-And-Test search strategy which evaluate each remaining complete instantiation and check its satisfiability.
`static AbstractStrategy<IntVar>`	`generateAndTest(Solver SOLVER, AbstractStrategy<IntVar> mainStrategy, int searchSpaceLimit)` Create a Generate-And-Test search strategy which evaluate each remaining complete instantiation and check its satisfiability.
`static AbstractStrategy<IntVar>`	`impact(IntVar[] VARS, int ALPHA, int SPLIT, int NODEIMPACT, long SEED, boolean INITONLY)` Create an Impact-based search strategy.
`static AbstractStrategy<IntVar>`	`impact(IntVar[] VARS, long SEED)` Create an Impact-based search strategy.
`static AbstractStrategy`	`lastConflict(Solver SOLVER)` Use the last conflict heuristic as a pluggin to improve a former search heuristic STRAT
`static AbstractStrategy`	`lastConflict(Solver SOLVER, AbstractStrategy STRAT)` Use the last conflict heuristic as a pluggin to improve a former search heuristic STRAT
`static AbstractStrategy`	`lastKConflicts(Solver SOLVER, int K, AbstractStrategy STRAT)` Use the last conflict heuristic as a pluggin to improve a former search heuristic STRAT Considers the K last conflicts
`static IntStrategy`	`lexico_LB(IntVar... VARS)` Assigns the first non-instantiated variable to its lower bound.
`static IntStrategy`	`lexico_Neq_LB(IntVar... VARS)` Removes the lower bound value from the domain of the first non-instantiated variable
`static IntStrategy`	`lexico_Split(IntVar... VARS)` Splits the domain of the first non-instantiated variable.
`static IntStrategy`	`lexico_UB(IntVar... VARS)` Assigns the first non-instantiated variable to its upper bound.
`static VariableSelector<IntVar>`	`lexico_var_selector()` Selects the first non-instantiated variable, to branch on it.
`static IntValueSelector`	`max_value_selector()` Selects the variable upper bound
`static IntStrategy`	`maxDom_Split(IntVar... VARS)` Splits the domain of the variable of largest domain
`static VariableSelector<IntVar>`	`maxDomainSize_var_selector()` Selects the non-instantiated variable of largest domain, to branch on it.
`static IntStrategy`	`maxReg_LB(IntVar... VARS)` Assigns the non-instantiated variable of maximum regret to its lower bound.
`static VariableSelector<IntVar>`	`maxRegret_var_selector()` Selects the non-instantiated variable with the largest difference between the two smallest values in its domain, to branch on it.
`static IntValueSelector`	`mid_value_selector()` Selects a value at the middle between the variable lower and upper bounds BEWARE: this should not be used within assignments and/or value removals if variables have a bounded domain.
`static IntValueSelector`	`min_value_selector()` Selects the variable lower bound
`static IntStrategy`	`minDom_LB(IntVar... VARS)` Assigns the non-instantiated variable of smallest domain size to its lower bound.
`static IntStrategy`	`minDom_MidValue(IntVar... VARS)` Assigns the non-instantiated variable of smallest domain size to a value at the middle of its domain.
`static IntStrategy`	`minDom_UB(IntVar... VARS)` Assigns the non-instantiated variable of smallest domain size to its upper bound.
`static VariableSelector<IntVar>`	`minDomainSize_var_selector()` Selects the non-instantiated variable of smallest domain, to branch on it.
`static IntStrategy`	`random_bound(IntVar[] VARS)` Randomly selects a variable and assigns it to a value randomly taken in {LB,UB} i.e. it fixes the variable to one of its bounds Uses fixed seed 0 by default
`static IntStrategy`	`random_bound(IntVar[] VARS, long SEED)` Randomly selects a variable and assigns it to a value randomly taken in {LB,UB} i.e. it fixes the variable to one of its bounds
`static IntValueSelector`	`random_value_selector(long SEED)` Selects randomly a value in the variable domain.
`static IntStrategy`	`random_value(IntVar[] VARS)` Randomly selects a variable and assigns it to a value randomly taken in [LB,UB] Uses fixed seed 0 by default
`static IntStrategy`	`random_value(IntVar[] VARS, long SEED)` Randomly selects a variable and assigns it to a value randomly taken in [LB,UB]
`static VariableSelector<IntVar>`	`random_var_selector(long SEED)` Selects randomly a non-instantiated variable to branch on
`static IntValueSelector`	`randomBound_value_selector(long SEED)` Selects randomly either the lower bound or the upper bound of the variable Takes an arbitrary value in {LB,UB}
`static DecisionOperator<IntVar>`	`remove()` Remove the selected value from the selected variable domain e.g.
`static DecisionOperator<IntVar>`	`reverse_split()` Split the domain of the selected variable at the selected value, by updating the lower bound.
`static AbstractStrategy`	`sequencer(AbstractStrategy... strategies)` Build a sequence of `AbstractStrategy`.
`static DecisionOperator<IntVar>`	`split()` Split the domain of the selected variable at the selected value, by updating the upper bound.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - lexico_var_selector
```
public static VariableSelector<IntVar> lexico_var_selector()
```
    Selects the first non-instantiated variable, to branch on it.
    
    Returns:
    a variable selector
  - random_var_selector
```
public static VariableSelector<IntVar> random_var_selector(long SEED)
```
    Selects randomly a non-instantiated variable to branch on
    
    Parameters:
    SEED - random seed
    
    Returns:
    a variable selector
  - minDomainSize_var_selector
```
public static VariableSelector<IntVar> minDomainSize_var_selector()
```
    Selects the non-instantiated variable of smallest domain, to branch on it. This heuristic is sometimes called FirstFail.
    
    Returns:
    a variable selector
  - maxDomainSize_var_selector
```
public static VariableSelector<IntVar> maxDomainSize_var_selector()
```
    Selects the non-instantiated variable of largest domain, to branch on it. This heuristic is sometimes called AntiFirstFail.
    
    Returns:
    a variable selector
  - maxRegret_var_selector
```
public static VariableSelector<IntVar> maxRegret_var_selector()
```
    Selects the non-instantiated variable with the largest difference between the two smallest values in its domain, to branch on it.
    
    Returns:
    a variable selector
  - min_value_selector
```
public static IntValueSelector min_value_selector()
```
    Selects the variable lower bound
    
    Returns:
    a value selector
  - mid_value_selector
```
public static IntValueSelector mid_value_selector()
```
    Selects a value at the middle between the variable lower and upper bounds
    BEWARE: this should not be used within assignments and/or value removals if variables have a bounded domain.
    
    Returns:
    a value selector
  - max_value_selector
```
public static IntValueSelector max_value_selector()
```
    Selects the variable upper bound
    
    Returns:
    a value selector
  - randomBound_value_selector
```
public static IntValueSelector randomBound_value_selector(long SEED)
```
    Selects randomly either the lower bound or the upper bound of the variable Takes an arbitrary value in {LB,UB}
    
    Returns:
    a value selector
  - random_value_selector
```
public static IntValueSelector random_value_selector(long SEED)
```
    Selects randomly a value in the variable domain. Takes an arbitrary value in [LB,UB]
    BEWARE: this should not be used within assignments and/or value removals if variables have a bounded domain.
    
    Returns:
    a value selector
  - assign
```
public static DecisionOperator<IntVar> assign()
```
    Assign the selected variable to the selected value e.g. X = 42 If this decision fails, it is automatically negated (i.e. X != 42)
    
    Returns:
    a decision operator
  - remove
```
public static DecisionOperator<IntVar> remove()
```
    Remove the selected value from the selected variable domain e.g. X != 42 If this decision fails, it is automatically negated (i.e. X = 42)
    
    Returns:
    a decision operator
  - split
```
public static DecisionOperator<IntVar> split()
```
    Split the domain of the selected variable at the selected value, by updating the upper bound. e.g. X <= 42 If this decision fails, it is automatically negated (i.e. X > 42)
    
    Returns:
    a decision operator
  - reverse_split
```
public static DecisionOperator<IntVar> reverse_split()
```
    Split the domain of the selected variable at the selected value, by updating the lower bound. e.g. X >= 42 If this decision fails, it is automatically negated (i.e. X < 42)
    
    Returns:
    a decision operator
  - custom
```
public static IntStrategy custom(VariableSelector<IntVar> VAR_SELECTOR,
                 IntValueSelector VAL_SELECTOR,
                 DecisionOperator<IntVar> DEC_OPERATOR,
                 IntVar... VARS)
```
    Builds your own search strategy
    
    Parameters:
    VAR_SELECTOR - defines how to select a variable to branch on.
    VAL_SELECTOR - defines how to select a value in the domain of the selected variable
    DEC_OPERATOR - defines how to modify the domain of the selected variable with the selected value
    VARS - variables to branch on
    
    Returns:
    a custom search strategy
  - custom
```
public static IntStrategy custom(VariableSelector<IntVar> VAR_SELECTOR,
                 IntValueSelector VAL_SELECTOR,
                 IntVar... VARS)
```
    Builds your own assignment strategy : Selects a variable X and a value V to make the decision X = V. Note that value assignments are the default decision operators. Therefore, they are not mentioned in the search heuristic name.
    
    Parameters:
    VAR_SELECTOR - defines how to select a variable to branch on.
    VAL_SELECTOR - defines how to select a value in the domain of the selected variable
    VARS - variables to branch on
    
    Returns:
    a custom search strategy
  - lexico_LB
```
public static IntStrategy lexico_LB(IntVar... VARS)
```
    Assigns the first non-instantiated variable to its lower bound.
    
    Parameters:
    VARS - list of variables
    
    Returns:
    int strategy based on value assignments
  - lexico_Neq_LB
```
public static IntStrategy lexico_Neq_LB(IntVar... VARS)
```
    Removes the lower bound value from the domain of the first non-instantiated variable
    
    Parameters:
    VARS - list of variables
    
    Returns:
    int strategy based on value removals
  - lexico_Split
```
public static IntStrategy lexico_Split(IntVar... VARS)
```
    Splits the domain of the first non-instantiated variable.
    
    Parameters:
    VARS - list of variables
    
    Returns:
    int strategy based on domain splits
  - lexico_UB
```
public static IntStrategy lexico_UB(IntVar... VARS)
```
    Assigns the first non-instantiated variable to its upper bound.
    
    Parameters:
    VARS - list of variables
    
    Returns:
    assignment strategy
  - minDom_LB
```
public static IntStrategy minDom_LB(IntVar... VARS)
```
    Assigns the non-instantiated variable of smallest domain size to its lower bound.
    
    Parameters:
    VARS - list of variables
    
    Returns:
    assignment strategy
  - minDom_MidValue
```
public static IntStrategy minDom_MidValue(IntVar... VARS)
```
    Assigns the non-instantiated variable of smallest domain size to a value at the middle of its domain.
    
    Parameters:
    VARS - list of variables
    
    Returns:
    assignment strategy
  - maxDom_Split
```
public static IntStrategy maxDom_Split(IntVar... VARS)
```
    Splits the domain of the variable of largest domain
    
    Parameters:
    VARS - list of variables
    
    Returns:
    an int strategy based on domain splits
  - minDom_UB
```
public static IntStrategy minDom_UB(IntVar... VARS)
```
    Assigns the non-instantiated variable of smallest domain size to its upper bound.
    
    Parameters:
    VARS - list of variables
    
    Returns:
    assignment strategy
  - maxReg_LB
```
public static IntStrategy maxReg_LB(IntVar... VARS)
```
    Assigns the non-instantiated variable of maximum regret to its lower bound.
    
    Parameters:
    VARS - list of variables
    
    Returns:
    assignment strategy
  - random_bound
```
public static IntStrategy random_bound(IntVar[] VARS,
                       long SEED)
```
    Randomly selects a variable and assigns it to a value randomly taken in {LB,UB} i.e. it fixes the variable to one of its bounds
    
    Parameters:
    VARS - list of variables
    SEED - a seed for random
    
    Returns:
    assignment strategy
  - random_bound
```
public static IntStrategy random_bound(IntVar[] VARS)
```
    Randomly selects a variable and assigns it to a value randomly taken in {LB,UB} i.e. it fixes the variable to one of its bounds Uses fixed seed 0 by default
    
    Parameters:
    VARS - list of variables
    
    Returns:
    assignment strategy
  - random_value
```
public static IntStrategy random_value(IntVar[] VARS,
                       long SEED)
```
    Randomly selects a variable and assigns it to a value randomly taken in [LB,UB]
    
    Parameters:
    VARS - list of variables
    SEED - a seed for random
    
    Returns:
    assignment strategy
  - random_value
```
public static IntStrategy random_value(IntVar[] VARS)
```
    Randomly selects a variable and assigns it to a value randomly taken in [LB,UB] Uses fixed seed 0 by default
    
    Parameters:
    VARS - list of variables
    
    Returns:
    assignment strategy
  - sequencer
```
public static AbstractStrategy sequencer(AbstractStrategy... strategies)
```
    Build a sequence of AbstractStrategy. The first strategy in parameter is first called to compute a decision, if possible. Otherwise, the second strategy is called, ... And so on, until the last one.
    
    Parameters:
    strategies - a list of strategies
    
    Returns:
    a strategy sequencer
  - domOverWDeg
```
public static AbstractStrategy<IntVar> domOverWDeg(IntVar[] VARS,
                                   long SEED,
                                   IntValueSelector VAL_SELECTOR)
```
    Assignment strategy which selects a variable according to DomOverWDeg and assign it to the selected value
    
    Parameters:
    VARS - list of variables
    SEED - random seed
    VAL_SELECTOR - heuristic to selected the value to assign to the selected variable
    
    Returns:
    assignment strategy
  - domOverWDeg
```
public static AbstractStrategy<IntVar> domOverWDeg(IntVar[] VARS,
                                   long SEED)
```
    Assignment strategy which selects a variable according to DomOverWDeg and assign it to its lower bound
    
    Parameters:
    VARS - list of variables
    SEED - random seed
    
    Returns:
    assignment strategy
  - activity
```
public static AbstractStrategy<IntVar> activity(IntVar[] VARS,
                                double GAMMA,
                                double DELTA,
                                int ALPHA,
                                int FORCE_SAMPLING,
                                long SEED)
```
    Create an Activity based search strategy.
    "Activity-Based Search for Black-Box Constraint Propagramming Solver", Laurent Michel and Pascal Van Hentenryck, CPAIOR12.
    
    Parameters:
    VARS - collection of variables
    GAMMA - aging parameters
    DELTA - for interval domain size estimation
    ALPHA - forget parameter
    FORCE_SAMPLING - minimal number of iteration for sampling phase
    SEED - the seed for random
  activity
  
  @Deprecated public static AbstractStrategy<IntVar> activity(IntVar[] VARS, double GAMMA, double DELTA, int ALPHA, double RESTART, int FORCE_SAMPLING, long SEED)
  
  Deprecated.
  
  (Deprecated) Create an Activity based search strategy.
  "Activity-Based Search for Black-Box Constraint Propagramming Solver", Laurent Michel and Pascal Van Hentenryck, CPAIOR12.
  
  Parameters:
  VARS - collection of variables
  GAMMA - aging parameters
  DELTA - for interval domain size estimation
  ALPHA - forget parameter
  RESTART - restart parameter -- not used
  FORCE_SAMPLING - minimal number of iteration for sampling phase
  SEED - the seed for random
  See Also:
  activity(org.chocosolver.solver.variables.IntVar[], double, double, int, int, long)
  
  activity
  
  public static AbstractStrategy<IntVar> activity(IntVar[] VARS, long SEED)
  
  Create an Activity based search strategy.
  "Activity-Based Search for Black-Box Constraint Propagramming Solver", Laurent Michel and Pascal Van Hentenryck, CPAIOR12.
  Uses default parameters (GAMMA=0.999d, DELTA=0.2d, ALPHA=8, RESTART=1.1d, FORCE_SAMPLING=1)
  
  Parameters:
  VARS - collection of variables
  SEED - the seed for random
  
  impact
  
  public static AbstractStrategy<IntVar> impact(IntVar[] VARS, int ALPHA, int SPLIT, int NODEIMPACT, long SEED, boolean INITONLY)
  
  Create an Impact-based search strategy.
  "Impact-Based Search Strategies for Constraint Programming", Philippe Refalo, CP2004.
  
  Parameters:
  VARS - variables of the problem (should be integers)
  ALPHA - aging parameter
  SPLIT - split parameter for subdomains computation
  NODEIMPACT - force update of impacts every nodeImpact nodes. Set value to 0 to avoid using it.
  SEED - a seed for random
  INITONLY - only apply the initialisation phase, do not update impact thereafter
  
  impact
  
  public static AbstractStrategy<IntVar> impact(IntVar[] VARS, long SEED)
  
  Create an Impact-based search strategy.
  "Impact-Based Search Strategies for Constraint Programming", Philippe Refalo, CP2004. Uses default parameters (ALPHA=2,SPLIT=3,NODEIMPACT=10,INITONLY=true)
  
  Parameters:
  VARS - variables of the problem (should be integers)
  SEED - a seed for random
  
  lastConflict
  
  public static AbstractStrategy lastConflict(Solver SOLVER)
  
  Use the last conflict heuristic as a pluggin to improve a former search heuristic STRAT
  
  Parameters:
  SOLVER - the solver
  
  Returns:
  last conflict strategy
  
  lastConflict
  
  public static AbstractStrategy lastConflict(Solver SOLVER, AbstractStrategy STRAT)
  
  Use the last conflict heuristic as a pluggin to improve a former search heuristic STRAT
  
  Parameters:
  SOLVER - the solver
  STRAT - the main strategy
  
  Returns:
  last conflict strategy
  
  lastKConflicts
  
  public static AbstractStrategy lastKConflicts(Solver SOLVER, int K, AbstractStrategy STRAT)
  
  Use the last conflict heuristic as a pluggin to improve a former search heuristic STRAT Considers the K last conflicts
  
  Parameters:
  SOLVER - the solver
  STRAT - the main strategy
  
  Returns:
  last conflict strategy
  
  generateAndTest
  
  public static AbstractStrategy<IntVar> generateAndTest(Solver SOLVER)
  
  Create a Generate-And-Test search strategy which evaluate each remaining complete instantiation and check its satisfiability. This does not rely on propagation but only on propagator entailment.
  This can be smoothly combined with other (IntVar) strategies, but they should be used first because this one does not let non instantiated int var.
  
  Parameters:
  SOLVER - the solver
  
  Returns:
  a Generate-And-Test search strategy
  See Also:
  generateAndTest(org.chocosolver.solver.Solver, org.chocosolver.solver.search.strategy.strategy.AbstractStrategy, int)
  
  generateAndTest
  
  public static AbstractStrategy<IntVar> generateAndTest(Solver SOLVER, AbstractStrategy<IntVar> mainStrategy, int searchSpaceLimit)
  
  Create a Generate-And-Test search strategy which evaluate each remaining complete instantiation and check its satisfiability. This does not rely on propagation but only on propagator entailment.
  This can be smoothly combined with other (IntVar) strategies, but they should be used first because this one does not let non instantiated int var.
  This signature enables to trigger Generate-And-Test only when the search space is small enough (below searchSpaceLimit, and a main strategy otherwise.
  
  Parameters:
  SOLVER - the solver
  mainStrategy - the strategy to apply first
  searchSpaceLimit - the size of search space which triggers the Generate-And-Test strategy.
  
  Returns:
  a Generate-And-Test search strategy
  See Also:
  generateAndTest(org.chocosolver.solver.Solver)

Class IntStrategyFactory

Method Summary

Methods inherited from class java.lang.Object

Method Detail

lexico_var_selector

random_var_selector

minDomainSize_var_selector

maxDomainSize_var_selector

maxRegret_var_selector

min_value_selector

mid_value_selector

max_value_selector

randomBound_value_selector

random_value_selector

assign

remove

split

reverse_split

custom

custom

lexico_LB

lexico_Neq_LB

lexico_Split

lexico_UB

minDom_LB

minDom_MidValue

maxDom_Split

minDom_UB

maxReg_LB

random_bound

random_bound

random_value

random_value

sequencer

domOverWDeg

domOverWDeg

activity

activity

activity

impact

impact

lastConflict

lastConflict

lastKConflicts

generateAndTest

generateAndTest