BopParametersOrBuilder (com.google.ortools:ortools-java 9.12.9999 API)

All Superinterfaces:

com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder

All Known Implementing Classes:

BopParameters, BopParameters.Builder
```
public interface BopParametersOrBuilder
extends com.google.protobuf.MessageOrBuilder
```

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`boolean`	`getComputeEstimatedImpact()` Compute estimated impact at each iteration when true; only once when false.
`double`	`getDecomposedProblemMinTimeInSeconds()` HACK.
`int`	`getDecomposerNumVariablesThreshold()` Only try to decompose the problem when the number of variables is greater than the threshold.
`java.lang.String`	`getDefaultSolverOptimizerSets()` optional string default_solver_optimizer_sets = 33 [default = "methods:{type:LOCAL_SEARCH } methods:{type:RANDOM_FIRST_SOLUTION } methods:{type:LINEAR_RELAXATION } methods:{type:LP_FIRST_SOLUTION } methods:{type:OBJECTIVE_FIRST_SOLUTION } methods:{type:USER_GUIDED_FIRST_SOLUTION } methods:{type:RANDOM_CONSTRAINT_LNS_GUIDED_BY_LP } methods:{type:RANDOM_VARIABLE_LNS_GUIDED_BY_LP } methods:{type:RELATION_GRAPH_LNS } methods:{type:RELATION_GRAPH_LNS_GUIDED_BY_LP } methods:{type:RANDOM_CONSTRAINT_LNS } methods:{type:RANDOM_VARIABLE_LNS } methods:{type:SAT_CORE_BASED } methods:{type:COMPLETE_LNS } "];
`com.google.protobuf.ByteString`	`getDefaultSolverOptimizerSetsBytes()` optional string default_solver_optimizer_sets = 33 [default = "methods:{type:LOCAL_SEARCH } methods:{type:RANDOM_FIRST_SOLUTION } methods:{type:LINEAR_RELAXATION } methods:{type:LP_FIRST_SOLUTION } methods:{type:OBJECTIVE_FIRST_SOLUTION } methods:{type:USER_GUIDED_FIRST_SOLUTION } methods:{type:RANDOM_CONSTRAINT_LNS_GUIDED_BY_LP } methods:{type:RANDOM_VARIABLE_LNS_GUIDED_BY_LP } methods:{type:RELATION_GRAPH_LNS } methods:{type:RELATION_GRAPH_LNS_GUIDED_BY_LP } methods:{type:RANDOM_CONSTRAINT_LNS } methods:{type:RANDOM_VARIABLE_LNS } methods:{type:SAT_CORE_BASED } methods:{type:COMPLETE_LNS } "];
`boolean`	`getExploitSymmetryInSatFirstSolution()` If true, find and exploit symmetries in proving satisfiability in the first problem.
`int`	`getGuidedSatConflictsChunk()` The first solutions based on guided SAT will work in chunk of that many conflicts at the time.
`boolean`	`getLogSearchProgress()` Whether the solver should log the search progress to LOG(INFO).
`double`	`getLpMaxDeterministicTime()` The max deterministic time given to the LP solver each time it is called.
`double`	`getMaxDeterministicTime()` Maximum time allowed in deterministic time to solve a problem.
`int`	`getMaxLpSolveForFeasibilityProblems()` The maximum number of time the LP solver will run to feasibility for pure feasibility problems (with a constant-valued objective function).
`long`	`getMaxNumberOfBacktracksInLs()` Maximum number of backtracks times the number of variables in Local Search, ie. max num backtracks == max_number_of_backtracks_in_ls / num variables.
`int`	`getMaxNumberOfConflictsForQuickCheck()` The number of conflicts the SAT solver has to solve a random LNS subproblem for the quick check of infeasibility.
`int`	`getMaxNumberOfConflictsInRandomLns()` The number of conflicts the SAT solver has to solve a random LNS subproblem.
`int`	`getMaxNumberOfConflictsInRandomSolutionGeneration()` The number of conflicts the SAT solver has to generate a random solution.
`int`	`getMaxNumberOfConsecutiveFailingOptimizerCalls()` Maximum number of consecutive optimizer calls without improving the current solution.
`long`	`getMaxNumberOfExploredAssignmentsPerTryInLs()` The maximum number of assignments the Local Search iterates on during one try.
`int`	`getMaxNumBrokenConstraintsInLs()` Abort the LS search tree as soon as strictly more than this number of constraints are broken.
`int`	`getMaxNumDecisionsInLs()` Maximum number of cascading decisions the solver might use to repair the current solution in the LS.
`double`	`getMaxTimeInSeconds()` Maximum time allowed in seconds to solve a problem.
`int`	`getNumberOfSolvers()` The number of solvers used to run Bop.
`int`	`getNumBopSolversUsedByDecomposition()` The number of BopSolver created (thread pool workers) used by the integral solver to solve a decomposed problem.
`int`	`getNumRandomLnsTries()` Number of tries in the random lns.
`int`	`getNumRelaxedVars()` Number of variables to relax in the exhaustive Large Neighborhood Search.
`boolean`	`getPruneSearchTree()` Avoid exploring both branches (b, a, ...) and (a, b, ...).
`int`	`getRandomSeed()` The seed used to initialize the random generator.
`double`	`getRelativeGapLimit()` Limit used to stop the optimization as soon as the relative gap is smaller than the given value.
`BopSolverOptimizerSet`	`getSolverOptimizerSets(int index)` List of set of optimizers to be run by the solvers.
`int`	`getSolverOptimizerSetsCount()` List of set of optimizers to be run by the solvers.
`java.util.List<BopSolverOptimizerSet>`	`getSolverOptimizerSetsList()` List of set of optimizers to be run by the solvers.
`BopSolverOptimizerSetOrBuilder`	`getSolverOptimizerSetsOrBuilder(int index)` List of set of optimizers to be run by the solvers.
`java.util.List<? extends BopSolverOptimizerSetOrBuilder>`	`getSolverOptimizerSetsOrBuilderList()` List of set of optimizers to be run by the solvers.
`boolean`	`getSortConstraintsByNumTerms()` Sort constraints by increasing total number of terms instead of number of contributing terms.
`BopParameters.ThreadSynchronizationType`	`getSynchronizationType()` `optional .operations_research.bop.BopParameters.ThreadSynchronizationType synchronization_type = 25 [default = NO_SYNCHRONIZATION];`
`boolean`	`getUseLearnedBinaryClausesInLp()` Whether we use the learned binary clauses in the Linear Relaxation.
`boolean`	`getUseLpLns()` Use Large Neighborhood Search based on the LP relaxation.
`boolean`	`getUseLpStrongBranching()` Use strong branching in the linear relaxation optimizer.
`boolean`	`getUsePotentialOneFlipRepairsInLs()` Whether we keep a list of variable that can potentially repair in one flip all the current infeasible constraints (such variable must at least appear in all the infeasible constraints for this to happen).
`boolean`	`getUseRandomLns()` Use the random Large Neighborhood Search instead of the exhaustive one.
`boolean`	`getUseSatToChooseLnsNeighbourhood()` Whether we use sat propagation to choose the lns neighbourhood.
`boolean`	`getUseSymmetry()` If true, find and exploit the eventual symmetries of the problem.
`boolean`	`getUseTranspositionTableInLs()` Whether we use an hash set during the LS to avoid exploring more than once the "same" state.
`boolean`	`hasComputeEstimatedImpact()` Compute estimated impact at each iteration when true; only once when false.
`boolean`	`hasDecomposedProblemMinTimeInSeconds()` HACK.
`boolean`	`hasDecomposerNumVariablesThreshold()` Only try to decompose the problem when the number of variables is greater than the threshold.
`boolean`	`hasDefaultSolverOptimizerSets()` optional string default_solver_optimizer_sets = 33 [default = "methods:{type:LOCAL_SEARCH } methods:{type:RANDOM_FIRST_SOLUTION } methods:{type:LINEAR_RELAXATION } methods:{type:LP_FIRST_SOLUTION } methods:{type:OBJECTIVE_FIRST_SOLUTION } methods:{type:USER_GUIDED_FIRST_SOLUTION } methods:{type:RANDOM_CONSTRAINT_LNS_GUIDED_BY_LP } methods:{type:RANDOM_VARIABLE_LNS_GUIDED_BY_LP } methods:{type:RELATION_GRAPH_LNS } methods:{type:RELATION_GRAPH_LNS_GUIDED_BY_LP } methods:{type:RANDOM_CONSTRAINT_LNS } methods:{type:RANDOM_VARIABLE_LNS } methods:{type:SAT_CORE_BASED } methods:{type:COMPLETE_LNS } "];
`boolean`	`hasExploitSymmetryInSatFirstSolution()` If true, find and exploit symmetries in proving satisfiability in the first problem.
`boolean`	`hasGuidedSatConflictsChunk()` The first solutions based on guided SAT will work in chunk of that many conflicts at the time.
`boolean`	`hasLogSearchProgress()` Whether the solver should log the search progress to LOG(INFO).
`boolean`	`hasLpMaxDeterministicTime()` The max deterministic time given to the LP solver each time it is called.
`boolean`	`hasMaxDeterministicTime()` Maximum time allowed in deterministic time to solve a problem.
`boolean`	`hasMaxLpSolveForFeasibilityProblems()` The maximum number of time the LP solver will run to feasibility for pure feasibility problems (with a constant-valued objective function).
`boolean`	`hasMaxNumberOfBacktracksInLs()` Maximum number of backtracks times the number of variables in Local Search, ie. max num backtracks == max_number_of_backtracks_in_ls / num variables.
`boolean`	`hasMaxNumberOfConflictsForQuickCheck()` The number of conflicts the SAT solver has to solve a random LNS subproblem for the quick check of infeasibility.
`boolean`	`hasMaxNumberOfConflictsInRandomLns()` The number of conflicts the SAT solver has to solve a random LNS subproblem.
`boolean`	`hasMaxNumberOfConflictsInRandomSolutionGeneration()` The number of conflicts the SAT solver has to generate a random solution.
`boolean`	`hasMaxNumberOfConsecutiveFailingOptimizerCalls()` Maximum number of consecutive optimizer calls without improving the current solution.
`boolean`	`hasMaxNumberOfExploredAssignmentsPerTryInLs()` The maximum number of assignments the Local Search iterates on during one try.
`boolean`	`hasMaxNumBrokenConstraintsInLs()` Abort the LS search tree as soon as strictly more than this number of constraints are broken.
`boolean`	`hasMaxNumDecisionsInLs()` Maximum number of cascading decisions the solver might use to repair the current solution in the LS.
`boolean`	`hasMaxTimeInSeconds()` Maximum time allowed in seconds to solve a problem.
`boolean`	`hasNumberOfSolvers()` The number of solvers used to run Bop.
`boolean`	`hasNumBopSolversUsedByDecomposition()` The number of BopSolver created (thread pool workers) used by the integral solver to solve a decomposed problem.
`boolean`	`hasNumRandomLnsTries()` Number of tries in the random lns.
`boolean`	`hasNumRelaxedVars()` Number of variables to relax in the exhaustive Large Neighborhood Search.
`boolean`	`hasPruneSearchTree()` Avoid exploring both branches (b, a, ...) and (a, b, ...).
`boolean`	`hasRandomSeed()` The seed used to initialize the random generator.
`boolean`	`hasRelativeGapLimit()` Limit used to stop the optimization as soon as the relative gap is smaller than the given value.
`boolean`	`hasSortConstraintsByNumTerms()` Sort constraints by increasing total number of terms instead of number of contributing terms.
`boolean`	`hasSynchronizationType()` `optional .operations_research.bop.BopParameters.ThreadSynchronizationType synchronization_type = 25 [default = NO_SYNCHRONIZATION];`
`boolean`	`hasUseLearnedBinaryClausesInLp()` Whether we use the learned binary clauses in the Linear Relaxation.
`boolean`	`hasUseLpLns()` Use Large Neighborhood Search based on the LP relaxation.
`boolean`	`hasUseLpStrongBranching()` Use strong branching in the linear relaxation optimizer.
`boolean`	`hasUsePotentialOneFlipRepairsInLs()` Whether we keep a list of variable that can potentially repair in one flip all the current infeasible constraints (such variable must at least appear in all the infeasible constraints for this to happen).
`boolean`	`hasUseRandomLns()` Use the random Large Neighborhood Search instead of the exhaustive one.
`boolean`	`hasUseSatToChooseLnsNeighbourhood()` Whether we use sat propagation to choose the lns neighbourhood.
`boolean`	`hasUseSymmetry()` If true, find and exploit the eventual symmetries of the problem.
`boolean`	`hasUseTranspositionTableInLs()` Whether we use an hash set during the LS to avoid exploring more than once the "same" state.

Methods inherited from interface com.google.protobuf.MessageOrBuilder
findInitializationErrors, getAllFields, getDefaultInstanceForType, getDescriptorForType, getField, getInitializationErrorString, getOneofFieldDescriptor, getRepeatedField, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof

Methods inherited from interface com.google.protobuf.MessageLiteOrBuilder
isInitialized

Method Detail

hasMaxTimeInSeconds

boolean hasMaxTimeInSeconds()

 Maximum time allowed in seconds to solve a problem.
 The counter will starts as soon as Solve() is called.

optional double max_time_in_seconds = 1 [default = inf];

Returns:: Whether the maxTimeInSeconds field is set.

getMaxTimeInSeconds

double getMaxTimeInSeconds()

 Maximum time allowed in seconds to solve a problem.
 The counter will starts as soon as Solve() is called.

optional double max_time_in_seconds = 1 [default = inf];

Returns:: The maxTimeInSeconds.

hasMaxDeterministicTime

boolean hasMaxDeterministicTime()

 Maximum time allowed in deterministic time to solve a problem.
 The deterministic time should be correlated with the real time used by the
 solver, the time unit being roughly the order of magnitude of a second.
 The counter will starts as soon as SetParameters() or SolveWithTimeLimit()
 is called.

optional double max_deterministic_time = 27 [default = inf];

Returns:: Whether the maxDeterministicTime field is set.

getMaxDeterministicTime

double getMaxDeterministicTime()

 Maximum time allowed in deterministic time to solve a problem.
 The deterministic time should be correlated with the real time used by the
 solver, the time unit being roughly the order of magnitude of a second.
 The counter will starts as soon as SetParameters() or SolveWithTimeLimit()
 is called.

optional double max_deterministic_time = 27 [default = inf];

Returns:: The maxDeterministicTime.

hasLpMaxDeterministicTime

boolean hasLpMaxDeterministicTime()

 The max deterministic time given to the LP solver each time it is called.
 If this is not enough to solve the LP at hand, it will simply be called
 again later (and the solve will resume from where it stopped).

optional double lp_max_deterministic_time = 37 [default = 1];

Returns:: Whether the lpMaxDeterministicTime field is set.

getLpMaxDeterministicTime

double getLpMaxDeterministicTime()

 The max deterministic time given to the LP solver each time it is called.
 If this is not enough to solve the LP at hand, it will simply be called
 again later (and the solve will resume from where it stopped).

optional double lp_max_deterministic_time = 37 [default = 1];

Returns:: The lpMaxDeterministicTime.

hasMaxNumberOfConsecutiveFailingOptimizerCalls

boolean hasMaxNumberOfConsecutiveFailingOptimizerCalls()

 Maximum number of consecutive optimizer calls without improving the
 current solution. If this number is reached, the search will be aborted.
 Note that this parameter only applies when an initial solution has been
 found or is provided. Also note that there is no limit to the number of
 calls, when the parameter is not set.

optional int32 max_number_of_consecutive_failing_optimizer_calls = 35;

Returns:: Whether the maxNumberOfConsecutiveFailingOptimizerCalls field is set.

getMaxNumberOfConsecutiveFailingOptimizerCalls

int getMaxNumberOfConsecutiveFailingOptimizerCalls()

 Maximum number of consecutive optimizer calls without improving the
 current solution. If this number is reached, the search will be aborted.
 Note that this parameter only applies when an initial solution has been
 found or is provided. Also note that there is no limit to the number of
 calls, when the parameter is not set.

optional int32 max_number_of_consecutive_failing_optimizer_calls = 35;

Returns:: The maxNumberOfConsecutiveFailingOptimizerCalls.

hasRelativeGapLimit

boolean hasRelativeGapLimit()

 Limit used to stop the optimization as soon as the relative gap is smaller
 than the given value.
 The relative gap is defined as:
 abs(solution_cost - best_bound)
 / max(abs(solution_cost), abs(best_bound)).

optional double relative_gap_limit = 28 [default = 0.0001];

Returns:: Whether the relativeGapLimit field is set.

getRelativeGapLimit

double getRelativeGapLimit()

 Limit used to stop the optimization as soon as the relative gap is smaller
 than the given value.
 The relative gap is defined as:
 abs(solution_cost - best_bound)
 / max(abs(solution_cost), abs(best_bound)).

optional double relative_gap_limit = 28 [default = 0.0001];

Returns:: The relativeGapLimit.

hasMaxNumDecisionsInLs

boolean hasMaxNumDecisionsInLs()

 Maximum number of cascading decisions the solver might use to repair the
 current solution in the LS.

optional int32 max_num_decisions_in_ls = 2 [default = 4];

Returns:: Whether the maxNumDecisionsInLs field is set.

getMaxNumDecisionsInLs

int getMaxNumDecisionsInLs()

 Maximum number of cascading decisions the solver might use to repair the
 current solution in the LS.

optional int32 max_num_decisions_in_ls = 2 [default = 4];

Returns:: The maxNumDecisionsInLs.

hasMaxNumBrokenConstraintsInLs

boolean hasMaxNumBrokenConstraintsInLs()

 Abort the LS search tree as soon as strictly more than this number of
 constraints are broken. The default is a large value which basically
 disable this heuristic.

optional int32 max_num_broken_constraints_in_ls = 38 [default = 2147483647];

Returns:: Whether the maxNumBrokenConstraintsInLs field is set.

getMaxNumBrokenConstraintsInLs

int getMaxNumBrokenConstraintsInLs()

 Abort the LS search tree as soon as strictly more than this number of
 constraints are broken. The default is a large value which basically
 disable this heuristic.

optional int32 max_num_broken_constraints_in_ls = 38 [default = 2147483647];

Returns:: The maxNumBrokenConstraintsInLs.

hasLogSearchProgress
```
boolean hasLogSearchProgress()
```
```
 Whether the solver should log the search progress to LOG(INFO).
 
```
optional bool log_search_progress = 14 [default = false];
Returns:

Whether the logSearchProgress field is set.

getLogSearchProgress
```
boolean getLogSearchProgress()
```
```
 Whether the solver should log the search progress to LOG(INFO).
 
```
optional bool log_search_progress = 14 [default = false];
Returns:

The logSearchProgress.

hasComputeEstimatedImpact
```
boolean hasComputeEstimatedImpact()
```
```
 Compute estimated impact at each iteration when true; only once when false.
 
```
optional bool compute_estimated_impact = 3 [default = true];
Returns:

Whether the computeEstimatedImpact field is set.

getComputeEstimatedImpact
```
boolean getComputeEstimatedImpact()
```
```
 Compute estimated impact at each iteration when true; only once when false.
 
```
optional bool compute_estimated_impact = 3 [default = true];
Returns:

The computeEstimatedImpact.

hasPruneSearchTree
```
boolean hasPruneSearchTree()
```
```
 Avoid exploring both branches (b, a, ...) and (a, b, ...).
 
```
optional bool prune_search_tree = 4 [default = false];
Returns:

Whether the pruneSearchTree field is set.

getPruneSearchTree
```
boolean getPruneSearchTree()
```
```
 Avoid exploring both branches (b, a, ...) and (a, b, ...).
 
```
optional bool prune_search_tree = 4 [default = false];
Returns:

The pruneSearchTree.

hasSortConstraintsByNumTerms
```
boolean hasSortConstraintsByNumTerms()
```
```
 Sort constraints by increasing total number of terms instead of number of
 contributing terms.
 
```
optional bool sort_constraints_by_num_terms = 5 [default = false];
Returns:

Whether the sortConstraintsByNumTerms field is set.

getSortConstraintsByNumTerms

boolean getSortConstraintsByNumTerms()

 Sort constraints by increasing total number of terms instead of number of
 contributing terms.

optional bool sort_constraints_by_num_terms = 5 [default = false];

Returns:: The sortConstraintsByNumTerms.

hasUseRandomLns
```
boolean hasUseRandomLns()
```
```
 Use the random Large Neighborhood Search instead of the exhaustive one.
 
```
optional bool use_random_lns = 6 [default = true];
Returns:

Whether the useRandomLns field is set.

getUseRandomLns

boolean getUseRandomLns()

 Use the random Large Neighborhood Search instead of the exhaustive one.

optional bool use_random_lns = 6 [default = true];

Returns:: The useRandomLns.

hasRandomSeed

boolean hasRandomSeed()

 The seed used to initialize the random generator.

 TODO(user): Some of our client test fail depending on this value! we need
 to fix them and ideally randomize our behavior from on test to the next so
 that this doesn't happen in the future.

optional int32 random_seed = 7 [default = 8];

Returns:: Whether the randomSeed field is set.

getRandomSeed

int getRandomSeed()

 The seed used to initialize the random generator.

 TODO(user): Some of our client test fail depending on this value! we need
 to fix them and ideally randomize our behavior from on test to the next so
 that this doesn't happen in the future.

optional int32 random_seed = 7 [default = 8];

Returns:: The randomSeed.

hasNumRelaxedVars
```
boolean hasNumRelaxedVars()
```
```
 Number of variables to relax in the exhaustive Large Neighborhood Search.
 
```
optional int32 num_relaxed_vars = 8 [default = 10];
Returns:

Whether the numRelaxedVars field is set.

getNumRelaxedVars

int getNumRelaxedVars()

 Number of variables to relax in the exhaustive Large Neighborhood Search.

optional int32 num_relaxed_vars = 8 [default = 10];

Returns:: The numRelaxedVars.

hasMaxNumberOfConflictsInRandomLns
```
boolean hasMaxNumberOfConflictsInRandomLns()
```
```
 The number of conflicts the SAT solver has to solve a random LNS
 subproblem.
 
```
optional int32 max_number_of_conflicts_in_random_lns = 9 [default = 2500];
Returns:

Whether the maxNumberOfConflictsInRandomLns field is set.

getMaxNumberOfConflictsInRandomLns
```
int getMaxNumberOfConflictsInRandomLns()
```
```
 The number of conflicts the SAT solver has to solve a random LNS
 subproblem.
 
```
optional int32 max_number_of_conflicts_in_random_lns = 9 [default = 2500];
Returns:

The maxNumberOfConflictsInRandomLns.

hasNumRandomLnsTries
```
boolean hasNumRandomLnsTries()
```
```
 Number of tries in the random lns.
 
```
optional int32 num_random_lns_tries = 10 [default = 1];
Returns:

Whether the numRandomLnsTries field is set.

getNumRandomLnsTries
```
int getNumRandomLnsTries()
```
```
 Number of tries in the random lns.
 
```
optional int32 num_random_lns_tries = 10 [default = 1];
Returns:

The numRandomLnsTries.

hasMaxNumberOfBacktracksInLs

boolean hasMaxNumberOfBacktracksInLs()

 Maximum number of backtracks times the number of variables in Local Search,
 ie. max num backtracks == max_number_of_backtracks_in_ls / num variables.

optional int64 max_number_of_backtracks_in_ls = 11 [default = 100000000];

Returns:: Whether the maxNumberOfBacktracksInLs field is set.

getMaxNumberOfBacktracksInLs

long getMaxNumberOfBacktracksInLs()

 Maximum number of backtracks times the number of variables in Local Search,
 ie. max num backtracks == max_number_of_backtracks_in_ls / num variables.

optional int64 max_number_of_backtracks_in_ls = 11 [default = 100000000];

Returns:: The maxNumberOfBacktracksInLs.

hasUseLpLns
```
boolean hasUseLpLns()
```
```
 Use Large Neighborhood Search based on the LP relaxation.
 
```
optional bool use_lp_lns = 12 [default = true];
Returns:

Whether the useLpLns field is set.

getUseLpLns

boolean getUseLpLns()

 Use Large Neighborhood Search based on the LP relaxation.

optional bool use_lp_lns = 12 [default = true];

Returns:: The useLpLns.

hasUseSatToChooseLnsNeighbourhood
```
boolean hasUseSatToChooseLnsNeighbourhood()
```
```
 Whether we use sat propagation to choose the lns neighbourhood.
 
```
optional bool use_sat_to_choose_lns_neighbourhood = 15 [default = true];
Returns:

Whether the useSatToChooseLnsNeighbourhood field is set.

getUseSatToChooseLnsNeighbourhood
```
boolean getUseSatToChooseLnsNeighbourhood()
```
```
 Whether we use sat propagation to choose the lns neighbourhood.
 
```
optional bool use_sat_to_choose_lns_neighbourhood = 15 [default = true];
Returns:

The useSatToChooseLnsNeighbourhood.

hasMaxNumberOfConflictsForQuickCheck
```
boolean hasMaxNumberOfConflictsForQuickCheck()
```
```
 The number of conflicts the SAT solver has to solve a random LNS
 subproblem for the quick check of infeasibility.
 
```
optional int32 max_number_of_conflicts_for_quick_check = 16 [default = 10];
Returns:

Whether the maxNumberOfConflictsForQuickCheck field is set.

getMaxNumberOfConflictsForQuickCheck

int getMaxNumberOfConflictsForQuickCheck()

 The number of conflicts the SAT solver has to solve a random LNS
 subproblem for the quick check of infeasibility.

optional int32 max_number_of_conflicts_for_quick_check = 16 [default = 10];

Returns:: The maxNumberOfConflictsForQuickCheck.

hasUseSymmetry

boolean hasUseSymmetry()

 If true, find and exploit the eventual symmetries of the problem.

 TODO(user): turn this on by default once the symmetry finder becomes fast
 enough to be negligeable for most problem. Or at least support a time
 limit.

optional bool use_symmetry = 17 [default = false];

Returns:: Whether the useSymmetry field is set.

getUseSymmetry

boolean getUseSymmetry()

 If true, find and exploit the eventual symmetries of the problem.

 TODO(user): turn this on by default once the symmetry finder becomes fast
 enough to be negligeable for most problem. Or at least support a time
 limit.

optional bool use_symmetry = 17 [default = false];

Returns:: The useSymmetry.

hasExploitSymmetryInSatFirstSolution

boolean hasExploitSymmetryInSatFirstSolution()

 If true, find and exploit symmetries in proving satisfiability in the first
 problem.
 This feature is experimental. On some problems, computing symmetries may
 run forever. You may also run into unforseen problems as this feature was
 not extensively tested.

optional bool exploit_symmetry_in_sat_first_solution = 40 [default = false];

Returns:: Whether the exploitSymmetryInSatFirstSolution field is set.

getExploitSymmetryInSatFirstSolution

boolean getExploitSymmetryInSatFirstSolution()

 If true, find and exploit symmetries in proving satisfiability in the first
 problem.
 This feature is experimental. On some problems, computing symmetries may
 run forever. You may also run into unforseen problems as this feature was
 not extensively tested.

optional bool exploit_symmetry_in_sat_first_solution = 40 [default = false];

Returns:: The exploitSymmetryInSatFirstSolution.

hasMaxNumberOfConflictsInRandomSolutionGeneration
```
boolean hasMaxNumberOfConflictsInRandomSolutionGeneration()
```
```
 The number of conflicts the SAT solver has to generate a random solution.
 
```
optional int32 max_number_of_conflicts_in_random_solution_generation = 20 [default = 500];
Returns:

Whether the maxNumberOfConflictsInRandomSolutionGeneration field is set.

getMaxNumberOfConflictsInRandomSolutionGeneration
```
int getMaxNumberOfConflictsInRandomSolutionGeneration()
```
```
 The number of conflicts the SAT solver has to generate a random solution.
 
```
optional int32 max_number_of_conflicts_in_random_solution_generation = 20 [default = 500];
Returns:

The maxNumberOfConflictsInRandomSolutionGeneration.

hasMaxNumberOfExploredAssignmentsPerTryInLs

boolean hasMaxNumberOfExploredAssignmentsPerTryInLs()

 The maximum number of assignments the Local Search iterates on during one
 try. Note that if the Local Search is called again on the same solution
 it will not restart from scratch but will iterate on the next
 max_number_of_explored_assignments_per_try_in_ls assignments.

optional int64 max_number_of_explored_assignments_per_try_in_ls = 21 [default = 10000];

Returns:: Whether the maxNumberOfExploredAssignmentsPerTryInLs field is set.

getMaxNumberOfExploredAssignmentsPerTryInLs

long getMaxNumberOfExploredAssignmentsPerTryInLs()

 The maximum number of assignments the Local Search iterates on during one
 try. Note that if the Local Search is called again on the same solution
 it will not restart from scratch but will iterate on the next
 max_number_of_explored_assignments_per_try_in_ls assignments.

optional int64 max_number_of_explored_assignments_per_try_in_ls = 21 [default = 10000];

Returns:: The maxNumberOfExploredAssignmentsPerTryInLs.

hasUseTranspositionTableInLs

boolean hasUseTranspositionTableInLs()

 Whether we use an hash set during the LS to avoid exploring more than once
 the "same" state. Note that because the underlying SAT solver may learn
 information in the middle of the LS, this may make the LS slightly less
 "complete", but it should be faster.

optional bool use_transposition_table_in_ls = 22 [default = true];

Returns:: Whether the useTranspositionTableInLs field is set.

getUseTranspositionTableInLs

boolean getUseTranspositionTableInLs()

 Whether we use an hash set during the LS to avoid exploring more than once
 the "same" state. Note that because the underlying SAT solver may learn
 information in the middle of the LS, this may make the LS slightly less
 "complete", but it should be faster.

optional bool use_transposition_table_in_ls = 22 [default = true];

Returns:: The useTranspositionTableInLs.

hasUsePotentialOneFlipRepairsInLs

boolean hasUsePotentialOneFlipRepairsInLs()

 Whether we keep a list of variable that can potentially repair in one flip
 all the current infeasible constraints (such variable must at least appear
 in all the infeasible constraints for this to happen).

optional bool use_potential_one_flip_repairs_in_ls = 39 [default = false];

Returns:: Whether the usePotentialOneFlipRepairsInLs field is set.

getUsePotentialOneFlipRepairsInLs

boolean getUsePotentialOneFlipRepairsInLs()

 Whether we keep a list of variable that can potentially repair in one flip
 all the current infeasible constraints (such variable must at least appear
 in all the infeasible constraints for this to happen).

optional bool use_potential_one_flip_repairs_in_ls = 39 [default = false];

Returns:: The usePotentialOneFlipRepairsInLs.

hasUseLearnedBinaryClausesInLp
```
boolean hasUseLearnedBinaryClausesInLp()
```
```
 Whether we use the learned binary clauses in the Linear Relaxation.
 
```
optional bool use_learned_binary_clauses_in_lp = 23 [default = true];
Returns:

Whether the useLearnedBinaryClausesInLp field is set.

getUseLearnedBinaryClausesInLp
```
boolean getUseLearnedBinaryClausesInLp()
```
```
 Whether we use the learned binary clauses in the Linear Relaxation.
 
```
optional bool use_learned_binary_clauses_in_lp = 23 [default = true];
Returns:

The useLearnedBinaryClausesInLp.

hasNumberOfSolvers

boolean hasNumberOfSolvers()

 The number of solvers used to run Bop. Note that one thread will be created
 per solver. The type of communication between solvers is specified by the
 synchronization_type parameter.

optional int32 number_of_solvers = 24 [default = 1];

Returns:: Whether the numberOfSolvers field is set.

getNumberOfSolvers

int getNumberOfSolvers()

 The number of solvers used to run Bop. Note that one thread will be created
 per solver. The type of communication between solvers is specified by the
 synchronization_type parameter.

optional int32 number_of_solvers = 24 [default = 1];

Returns:: The numberOfSolvers.

hasSynchronizationType
```
boolean hasSynchronizationType()
```
optional .operations_research.bop.BopParameters.ThreadSynchronizationType synchronization_type = 25 [default = NO_SYNCHRONIZATION];

Returns:

Whether the synchronizationType field is set.

getSynchronizationType
```
BopParameters.ThreadSynchronizationType getSynchronizationType()
```
optional .operations_research.bop.BopParameters.ThreadSynchronizationType synchronization_type = 25 [default = NO_SYNCHRONIZATION];

Returns:

The synchronizationType.