BopParameters.Builder (com.google.ortools:ortools-java 9.10.4067 API)

java.lang.Object
- com.google.protobuf.AbstractMessageLite.Builder
- - com.google.protobuf.AbstractMessage.Builder<BuilderT>
  - - com.google.protobuf.GeneratedMessage.Builder<BopParameters.Builder>
    - - com.google.ortools.bop.BopParameters.Builder

All Implemented Interfaces:

BopParametersOrBuilder, com.google.protobuf.Message.Builder, com.google.protobuf.MessageLite.Builder, com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder, java.lang.Cloneable

Enclosing class:

BopParameters
```
public static final class BopParameters.Builder
extends com.google.protobuf.GeneratedMessage.Builder<BopParameters.Builder>
implements BopParametersOrBuilder
```
```
 Contains the definitions for all the bop algorithm parameters and their
 default values.

 NEXT TAG: 42
 
```
Protobuf type operations_research.bop.BopParameters

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`BopParameters.Builder`	`addAllSolverOptimizerSets(java.lang.Iterable<? extends BopSolverOptimizerSet> values)` List of set of optimizers to be run by the solvers.
`BopParameters.Builder`	`addSolverOptimizerSets(BopSolverOptimizerSet.Builder builderForValue)` List of set of optimizers to be run by the solvers.
`BopParameters.Builder`	`addSolverOptimizerSets(BopSolverOptimizerSet value)` List of set of optimizers to be run by the solvers.
`BopParameters.Builder`	`addSolverOptimizerSets(int index, BopSolverOptimizerSet.Builder builderForValue)` List of set of optimizers to be run by the solvers.
`BopParameters.Builder`	`addSolverOptimizerSets(int index, BopSolverOptimizerSet value)` List of set of optimizers to be run by the solvers.
`BopSolverOptimizerSet.Builder`	`addSolverOptimizerSetsBuilder()` List of set of optimizers to be run by the solvers.
`BopSolverOptimizerSet.Builder`	`addSolverOptimizerSetsBuilder(int index)` List of set of optimizers to be run by the solvers.
`BopParameters`	`build()`
`BopParameters`	`buildPartial()`
`BopParameters.Builder`	`clear()`
`BopParameters.Builder`	`clearComputeEstimatedImpact()` Compute estimated impact at each iteration when true; only once when false.
`BopParameters.Builder`	`clearDecomposedProblemMinTimeInSeconds()` HACK.
`BopParameters.Builder`	`clearDecomposerNumVariablesThreshold()` Only try to decompose the problem when the number of variables is greater than the threshold.
`BopParameters.Builder`	`clearDefaultSolverOptimizerSets()` 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 } "];
`BopParameters.Builder`	`clearExploitSymmetryInSatFirstSolution()` If true, find and exploit symmetries in proving satisfiability in the first problem.
`BopParameters.Builder`	`clearGuidedSatConflictsChunk()` The first solutions based on guided SAT will work in chunk of that many conflicts at the time.
`BopParameters.Builder`	`clearLogSearchProgress()` Whether the solver should log the search progress to LOG(INFO).
`BopParameters.Builder`	`clearLpMaxDeterministicTime()` The max deterministic time given to the LP solver each time it is called.
`BopParameters.Builder`	`clearMaxDeterministicTime()` Maximum time allowed in deterministic time to solve a problem.
`BopParameters.Builder`	`clearMaxLpSolveForFeasibilityProblems()` The maximum number of time the LP solver will run to feasibility for pure feasibility problems (with a constant-valued objective function).
`BopParameters.Builder`	`clearMaxNumberOfBacktracksInLs()` Maximum number of backtracks times the number of variables in Local Search, ie.
`BopParameters.Builder`	`clearMaxNumberOfConflictsForQuickCheck()` The number of conflicts the SAT solver has to solve a random LNS subproblem for the quick check of infeasibility.
`BopParameters.Builder`	`clearMaxNumberOfConflictsInRandomLns()` The number of conflicts the SAT solver has to solve a random LNS subproblem.
`BopParameters.Builder`	`clearMaxNumberOfConflictsInRandomSolutionGeneration()` The number of conflicts the SAT solver has to generate a random solution.
`BopParameters.Builder`	`clearMaxNumberOfConsecutiveFailingOptimizerCalls()` Maximum number of consecutive optimizer calls without improving the current solution.
`BopParameters.Builder`	`clearMaxNumberOfExploredAssignmentsPerTryInLs()` The maximum number of assignments the Local Search iterates on during one try.
`BopParameters.Builder`	`clearMaxNumBrokenConstraintsInLs()` Abort the LS search tree as soon as strictly more than this number of constraints are broken.
`BopParameters.Builder`	`clearMaxNumDecisionsInLs()` Maximum number of cascading decisions the solver might use to repair the current solution in the LS.
`BopParameters.Builder`	`clearMaxTimeInSeconds()` Maximum time allowed in seconds to solve a problem.
`BopParameters.Builder`	`clearNumberOfSolvers()` The number of solvers used to run Bop.
`BopParameters.Builder`	`clearNumBopSolversUsedByDecomposition()` The number of BopSolver created (thread pool workers) used by the integral solver to solve a decomposed problem.
`BopParameters.Builder`	`clearNumRandomLnsTries()` Number of tries in the random lns.
`BopParameters.Builder`	`clearNumRelaxedVars()` Number of variables to relax in the exhaustive Large Neighborhood Search.
`BopParameters.Builder`	`clearPruneSearchTree()` Avoid exploring both branches (b, a, ...) and (a, b, ...).
`BopParameters.Builder`	`clearRandomSeed()` The seed used to initialize the random generator.
`BopParameters.Builder`	`clearRelativeGapLimit()` Limit used to stop the optimization as soon as the relative gap is smaller than the given value.
`BopParameters.Builder`	`clearSolverOptimizerSets()` List of set of optimizers to be run by the solvers.
`BopParameters.Builder`	`clearSortConstraintsByNumTerms()` Sort constraints by increasing total number of terms instead of number of contributing terms.
`BopParameters.Builder`	`clearSynchronizationType()` `optional .operations_research.bop.BopParameters.ThreadSynchronizationType synchronization_type = 25 [default = NO_SYNCHRONIZATION];`
`BopParameters.Builder`	`clearUseLearnedBinaryClausesInLp()` Whether we use the learned binary clauses in the Linear Relaxation.
`BopParameters.Builder`	`clearUseLpLns()` Use Large Neighborhood Search based on the LP relaxation.
`BopParameters.Builder`	`clearUseLpStrongBranching()` Use strong branching in the linear relaxation optimizer.
`BopParameters.Builder`	`clearUsePotentialOneFlipRepairsInLs()` 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).
`BopParameters.Builder`	`clearUseRandomLns()` Use the random Large Neighborhood Search instead of the exhaustive one.
`BopParameters.Builder`	`clearUseSatToChooseLnsNeighbourhood()` Whether we use sat propagation to choose the lns neighbourhood.
`BopParameters.Builder`	`clearUseSymmetry()` If true, find and exploit the eventual symmetries of the problem.
`BopParameters.Builder`	`clearUseTranspositionTableInLs()` Whether we use an hash set during the LS to avoid exploring more than once the "same" state.
`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.
`BopParameters`	`getDefaultInstanceForType()`
`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 } "];
`static com.google.protobuf.Descriptors.Descriptor`	`getDescriptor()`
`com.google.protobuf.Descriptors.Descriptor`	`getDescriptorForType()`
`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.
`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.
`BopSolverOptimizerSet.Builder`	`getSolverOptimizerSetsBuilder(int index)` List of set of optimizers to be run by the solvers.
`java.util.List<BopSolverOptimizerSet.Builder>`	`getSolverOptimizerSetsBuilderList()` 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.
`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.
`protected com.google.protobuf.GeneratedMessage.FieldAccessorTable`	`internalGetFieldAccessorTable()`
`boolean`	`isInitialized()`
`BopParameters.Builder`	`mergeFrom(BopParameters other)`
`BopParameters.Builder`	`mergeFrom(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`
`BopParameters.Builder`	`mergeFrom(com.google.protobuf.Message other)`
`BopParameters.Builder`	`removeSolverOptimizerSets(int index)` List of set of optimizers to be run by the solvers.
`BopParameters.Builder`	`setComputeEstimatedImpact(boolean value)` Compute estimated impact at each iteration when true; only once when false.
`BopParameters.Builder`	`setDecomposedProblemMinTimeInSeconds(double value)` HACK.
`BopParameters.Builder`	`setDecomposerNumVariablesThreshold(int value)` Only try to decompose the problem when the number of variables is greater than the threshold.
`BopParameters.Builder`	`setDefaultSolverOptimizerSets(java.lang.String value)` 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 } "];
`BopParameters.Builder`	`setDefaultSolverOptimizerSetsBytes(com.google.protobuf.ByteString value)` 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 } "];
`BopParameters.Builder`	`setExploitSymmetryInSatFirstSolution(boolean value)` If true, find and exploit symmetries in proving satisfiability in the first problem.
`BopParameters.Builder`	`setGuidedSatConflictsChunk(int value)` The first solutions based on guided SAT will work in chunk of that many conflicts at the time.
`BopParameters.Builder`	`setLogSearchProgress(boolean value)` Whether the solver should log the search progress to LOG(INFO).
`BopParameters.Builder`	`setLpMaxDeterministicTime(double value)` The max deterministic time given to the LP solver each time it is called.
`BopParameters.Builder`	`setMaxDeterministicTime(double value)` Maximum time allowed in deterministic time to solve a problem.
`BopParameters.Builder`	`setMaxLpSolveForFeasibilityProblems(int value)` The maximum number of time the LP solver will run to feasibility for pure feasibility problems (with a constant-valued objective function).
`BopParameters.Builder`	`setMaxNumberOfBacktracksInLs(long value)` Maximum number of backtracks times the number of variables in Local Search, ie.
`BopParameters.Builder`	`setMaxNumberOfConflictsForQuickCheck(int value)` The number of conflicts the SAT solver has to solve a random LNS subproblem for the quick check of infeasibility.
`BopParameters.Builder`	`setMaxNumberOfConflictsInRandomLns(int value)` The number of conflicts the SAT solver has to solve a random LNS subproblem.
`BopParameters.Builder`	`setMaxNumberOfConflictsInRandomSolutionGeneration(int value)` The number of conflicts the SAT solver has to generate a random solution.
`BopParameters.Builder`	`setMaxNumberOfConsecutiveFailingOptimizerCalls(int value)` Maximum number of consecutive optimizer calls without improving the current solution.
`BopParameters.Builder`	`setMaxNumberOfExploredAssignmentsPerTryInLs(long value)` The maximum number of assignments the Local Search iterates on during one try.
`BopParameters.Builder`	`setMaxNumBrokenConstraintsInLs(int value)` Abort the LS search tree as soon as strictly more than this number of constraints are broken.
`BopParameters.Builder`	`setMaxNumDecisionsInLs(int value)` Maximum number of cascading decisions the solver might use to repair the current solution in the LS.
`BopParameters.Builder`	`setMaxTimeInSeconds(double value)` Maximum time allowed in seconds to solve a problem.
`BopParameters.Builder`	`setNumberOfSolvers(int value)` The number of solvers used to run Bop.
`BopParameters.Builder`	`setNumBopSolversUsedByDecomposition(int value)` The number of BopSolver created (thread pool workers) used by the integral solver to solve a decomposed problem.
`BopParameters.Builder`	`setNumRandomLnsTries(int value)` Number of tries in the random lns.
`BopParameters.Builder`	`setNumRelaxedVars(int value)` Number of variables to relax in the exhaustive Large Neighborhood Search.
`BopParameters.Builder`	`setPruneSearchTree(boolean value)` Avoid exploring both branches (b, a, ...) and (a, b, ...).
`BopParameters.Builder`	`setRandomSeed(int value)` The seed used to initialize the random generator.
`BopParameters.Builder`	`setRelativeGapLimit(double value)` Limit used to stop the optimization as soon as the relative gap is smaller than the given value.
`BopParameters.Builder`	`setSolverOptimizerSets(int index, BopSolverOptimizerSet.Builder builderForValue)` List of set of optimizers to be run by the solvers.
`BopParameters.Builder`	`setSolverOptimizerSets(int index, BopSolverOptimizerSet value)` List of set of optimizers to be run by the solvers.
`BopParameters.Builder`	`setSortConstraintsByNumTerms(boolean value)` Sort constraints by increasing total number of terms instead of number of contributing terms.
`BopParameters.Builder`	`setSynchronizationType(BopParameters.ThreadSynchronizationType value)` `optional .operations_research.bop.BopParameters.ThreadSynchronizationType synchronization_type = 25 [default = NO_SYNCHRONIZATION];`
`BopParameters.Builder`	`setUseLearnedBinaryClausesInLp(boolean value)` Whether we use the learned binary clauses in the Linear Relaxation.
`BopParameters.Builder`	`setUseLpLns(boolean value)` Use Large Neighborhood Search based on the LP relaxation.
`BopParameters.Builder`	`setUseLpStrongBranching(boolean value)` Use strong branching in the linear relaxation optimizer.
`BopParameters.Builder`	`setUsePotentialOneFlipRepairsInLs(boolean value)` 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).
`BopParameters.Builder`	`setUseRandomLns(boolean value)` Use the random Large Neighborhood Search instead of the exhaustive one.
`BopParameters.Builder`	`setUseSatToChooseLnsNeighbourhood(boolean value)` Whether we use sat propagation to choose the lns neighbourhood.
`BopParameters.Builder`	`setUseSymmetry(boolean value)` If true, find and exploit the eventual symmetries of the problem.
`BopParameters.Builder`	`setUseTranspositionTableInLs(boolean value)` Whether we use an hash set during the LS to avoid exploring more than once the "same" state.

Methods inherited from class com.google.protobuf.GeneratedMessage.Builder
addRepeatedField, clearField, clearOneof, clone, getAllFields, getField, getFieldBuilder, getOneofFieldDescriptor, getParentForChildren, getRepeatedField, getRepeatedFieldBuilder, getRepeatedFieldCount, getUnknownFields, getUnknownFieldSetBuilder, hasField, hasOneof, internalGetMapField, internalGetMapFieldReflection, internalGetMutableMapField, internalGetMutableMapFieldReflection, isClean, markClean, mergeUnknownFields, mergeUnknownLengthDelimitedField, mergeUnknownVarintField, newBuilderForField, onBuilt, onChanged, parseUnknownField, setField, setRepeatedField, setUnknownFields, setUnknownFieldSetBuilder, setUnknownFieldsProto3

Methods inherited from class com.google.protobuf.AbstractMessage.Builder
findInitializationErrors, getInitializationErrorString, internalMergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, newUninitializedMessageException, toString

Methods inherited from class com.google.protobuf.AbstractMessageLite.Builder
addAll, addAll, mergeDelimitedFrom, mergeDelimitedFrom, newUninitializedMessageException

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

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

Methods inherited from interface com.google.protobuf.Message.Builder
mergeDelimitedFrom, mergeDelimitedFrom

Method Detail

getDescriptor

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor()

internalGetFieldAccessorTable
```
protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable()
```
Specified by:

internalGetFieldAccessorTable in class com.google.protobuf.GeneratedMessage.Builder<BopParameters.Builder>

clear
```
public BopParameters.Builder clear()
```
Specified by:

clear in interface com.google.protobuf.Message.Builder

Specified by:

clear in interface com.google.protobuf.MessageLite.Builder

Overrides:

clear in class com.google.protobuf.GeneratedMessage.Builder<BopParameters.Builder>

getDescriptorForType
```
public com.google.protobuf.Descriptors.Descriptor getDescriptorForType()
```
Specified by:

getDescriptorForType in interface com.google.protobuf.Message.Builder

Specified by:

getDescriptorForType in interface com.google.protobuf.MessageOrBuilder

Overrides:

getDescriptorForType in class com.google.protobuf.GeneratedMessage.Builder<BopParameters.Builder>

getDefaultInstanceForType
```
public BopParameters getDefaultInstanceForType()
```
Specified by:

getDefaultInstanceForType in interface com.google.protobuf.MessageLiteOrBuilder

Specified by:

getDefaultInstanceForType in interface com.google.protobuf.MessageOrBuilder

build
```
public BopParameters build()
```
Specified by:

build in interface com.google.protobuf.Message.Builder

Specified by:

build in interface com.google.protobuf.MessageLite.Builder

buildPartial
```
public BopParameters buildPartial()
```
Specified by:

buildPartial in interface com.google.protobuf.Message.Builder

Specified by:

buildPartial in interface com.google.protobuf.MessageLite.Builder

mergeFrom
```
public BopParameters.Builder mergeFrom(com.google.protobuf.Message other)
```
Specified by:

mergeFrom in interface com.google.protobuf.Message.Builder

Overrides:

mergeFrom in class com.google.protobuf.AbstractMessage.Builder<BopParameters.Builder>

mergeFrom

public BopParameters.Builder mergeFrom(BopParameters other)

isInitialized
```
public final boolean isInitialized()
```
Specified by:

isInitialized in interface com.google.protobuf.MessageLiteOrBuilder

Overrides:

isInitialized in class com.google.protobuf.GeneratedMessage.Builder<BopParameters.Builder>

mergeFrom
```
public BopParameters.Builder mergeFrom(com.google.protobuf.CodedInputStream input,
                                       com.google.protobuf.ExtensionRegistryLite extensionRegistry)
                                throws java.io.IOException
```
Specified by:

mergeFrom in interface com.google.protobuf.Message.Builder

Specified by:

mergeFrom in interface com.google.protobuf.MessageLite.Builder

Overrides:

mergeFrom in class com.google.protobuf.AbstractMessage.Builder<BopParameters.Builder>

Throws:

java.io.IOException

hasMaxTimeInSeconds
```
public 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];
Specified by:

hasMaxTimeInSeconds in interface BopParametersOrBuilder

Returns:

Whether the maxTimeInSeconds field is set.

getMaxTimeInSeconds
```
public 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];
Specified by:

getMaxTimeInSeconds in interface BopParametersOrBuilder

Returns:

The maxTimeInSeconds.

setMaxTimeInSeconds

public BopParameters.Builder setMaxTimeInSeconds(double value)

 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];

Parameters:: value - The maxTimeInSeconds to set.
Returns:: This builder for chaining.

clearMaxTimeInSeconds

public BopParameters.Builder clearMaxTimeInSeconds()

 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:: This builder for chaining.

hasMaxDeterministicTime

public 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];

Specified by:: hasMaxDeterministicTime in interface BopParametersOrBuilder
Returns:: Whether the maxDeterministicTime field is set.

getMaxDeterministicTime

public 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];

Specified by:: getMaxDeterministicTime in interface BopParametersOrBuilder
Returns:: The maxDeterministicTime.

setMaxDeterministicTime

public BopParameters.Builder setMaxDeterministicTime(double value)

 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];

Parameters:: value - The maxDeterministicTime to set.
Returns:: This builder for chaining.

clearMaxDeterministicTime

public BopParameters.Builder clearMaxDeterministicTime()

 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:: This builder for chaining.

hasLpMaxDeterministicTime

public 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];

Specified by:: hasLpMaxDeterministicTime in interface BopParametersOrBuilder
Returns:: Whether the lpMaxDeterministicTime field is set.

getLpMaxDeterministicTime

public 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];

Specified by:: getLpMaxDeterministicTime in interface BopParametersOrBuilder
Returns:: The lpMaxDeterministicTime.

setLpMaxDeterministicTime

public BopParameters.Builder setLpMaxDeterministicTime(double value)

 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];

Parameters:: value - The lpMaxDeterministicTime to set.
Returns:: This builder for chaining.

clearLpMaxDeterministicTime

public BopParameters.Builder clearLpMaxDeterministicTime()

 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:: This builder for chaining.

hasMaxNumberOfConsecutiveFailingOptimizerCalls

public 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;

Specified by:: hasMaxNumberOfConsecutiveFailingOptimizerCalls in interface BopParametersOrBuilder
Returns:: Whether the maxNumberOfConsecutiveFailingOptimizerCalls field is set.

getMaxNumberOfConsecutiveFailingOptimizerCalls

public 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;

Specified by:: getMaxNumberOfConsecutiveFailingOptimizerCalls in interface BopParametersOrBuilder
Returns:: The maxNumberOfConsecutiveFailingOptimizerCalls.

setMaxNumberOfConsecutiveFailingOptimizerCalls

public BopParameters.Builder setMaxNumberOfConsecutiveFailingOptimizerCalls(int value)

 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;

Parameters:: value - The maxNumberOfConsecutiveFailingOptimizerCalls to set.
Returns:: This builder for chaining.

clearMaxNumberOfConsecutiveFailingOptimizerCalls

public BopParameters.Builder clearMaxNumberOfConsecutiveFailingOptimizerCalls()

 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:: This builder for chaining.

hasRelativeGapLimit

public 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];

Specified by:: hasRelativeGapLimit in interface BopParametersOrBuilder
Returns:: Whether the relativeGapLimit field is set.

getRelativeGapLimit

public 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];

Specified by:: getRelativeGapLimit in interface BopParametersOrBuilder
Returns:: The relativeGapLimit.

setRelativeGapLimit

public BopParameters.Builder setRelativeGapLimit(double value)

 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];

Parameters:: value - The relativeGapLimit to set.
Returns:: This builder for chaining.

clearRelativeGapLimit

public BopParameters.Builder clearRelativeGapLimit()

 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:: This builder for chaining.

hasMaxNumDecisionsInLs
```
public 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];
Specified by:

hasMaxNumDecisionsInLs in interface BopParametersOrBuilder

Returns:

Whether the maxNumDecisionsInLs field is set.

getMaxNumDecisionsInLs
```
public 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];
Specified by:

getMaxNumDecisionsInLs in interface BopParametersOrBuilder

Returns:

The maxNumDecisionsInLs.

setMaxNumDecisionsInLs

public BopParameters.Builder setMaxNumDecisionsInLs(int value)

 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];

Parameters:: value - The maxNumDecisionsInLs to set.
Returns:: This builder for chaining.

clearMaxNumDecisionsInLs

public BopParameters.Builder clearMaxNumDecisionsInLs()

 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:: This builder for chaining.

hasMaxNumBrokenConstraintsInLs
```
public 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];
Specified by:

hasMaxNumBrokenConstraintsInLs in interface BopParametersOrBuilder

Returns:

Whether the maxNumBrokenConstraintsInLs field is set.

getMaxNumBrokenConstraintsInLs
```
public 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];
Specified by:

getMaxNumBrokenConstraintsInLs in interface BopParametersOrBuilder

Returns:

The maxNumBrokenConstraintsInLs.

setMaxNumBrokenConstraintsInLs

public BopParameters.Builder setMaxNumBrokenConstraintsInLs(int value)

 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];

Parameters:: value - The maxNumBrokenConstraintsInLs to set.
Returns:: This builder for chaining.

clearMaxNumBrokenConstraintsInLs

public BopParameters.Builder clearMaxNumBrokenConstraintsInLs()

 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:: This builder for chaining.

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

hasLogSearchProgress in interface BopParametersOrBuilder

Returns:

Whether the logSearchProgress field is set.

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

getLogSearchProgress in interface BopParametersOrBuilder

Returns:

The logSearchProgress.

setLogSearchProgress
```
public BopParameters.Builder setLogSearchProgress(boolean value)
```
```
 Whether the solver should log the search progress to LOG(INFO).
 
```
optional bool log_search_progress = 14 [default = false];
Parameters:

value - The logSearchProgress to set.

Returns:

This builder for chaining.

clearLogSearchProgress

public BopParameters.Builder clearLogSearchProgress()

 Whether the solver should log the search progress to LOG(INFO).

optional bool log_search_progress = 14 [default = false];

Returns:: This builder for chaining.

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

hasComputeEstimatedImpact in interface BopParametersOrBuilder

Returns:

Whether the computeEstimatedImpact field is set.

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

getComputeEstimatedImpact in interface BopParametersOrBuilder

Returns:

The computeEstimatedImpact.

setComputeEstimatedImpact
```
public BopParameters.Builder setComputeEstimatedImpact(boolean value)
```
```
 Compute estimated impact at each iteration when true; only once when false.
 
```
optional bool compute_estimated_impact = 3 [default = true];
Parameters:

value - The computeEstimatedImpact to set.

Returns:

This builder for chaining.

clearComputeEstimatedImpact

public BopParameters.Builder clearComputeEstimatedImpact()

 Compute estimated impact at each iteration when true; only once when false.

optional bool compute_estimated_impact = 3 [default = true];

Returns:: This builder for chaining.

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

hasPruneSearchTree in interface BopParametersOrBuilder

Returns:

Whether the pruneSearchTree field is set.

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

getPruneSearchTree in interface BopParametersOrBuilder

Returns:

The pruneSearchTree.

setPruneSearchTree
```
public BopParameters.Builder setPruneSearchTree(boolean value)
```
```
 Avoid exploring both branches (b, a, ...) and (a, b, ...).
 
```
optional bool prune_search_tree = 4 [default = false];
Parameters:

value - The pruneSearchTree to set.

Returns:

This builder for chaining.

clearPruneSearchTree

public BopParameters.Builder clearPruneSearchTree()

 Avoid exploring both branches (b, a, ...) and (a, b, ...).

optional bool prune_search_tree = 4 [default = false];

Returns:: This builder for chaining.

hasSortConstraintsByNumTerms
```
public 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];
Specified by:

hasSortConstraintsByNumTerms in interface BopParametersOrBuilder

Returns:

Whether the sortConstraintsByNumTerms field is set.

getSortConstraintsByNumTerms
```
public 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];
Specified by:

getSortConstraintsByNumTerms in interface BopParametersOrBuilder

Returns:

The sortConstraintsByNumTerms.

setSortConstraintsByNumTerms
```
public BopParameters.Builder setSortConstraintsByNumTerms(boolean value)
```
```
 Sort constraints by increasing total number of terms instead of number of
 contributing terms.
 
```
optional bool sort_constraints_by_num_terms = 5 [default = false];
Parameters:

value - The sortConstraintsByNumTerms to set.

Returns:

This builder for chaining.

clearSortConstraintsByNumTerms

public BopParameters.Builder clearSortConstraintsByNumTerms()

 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:: This builder for chaining.

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

hasUseRandomLns in interface BopParametersOrBuilder

Returns:

Whether the useRandomLns field is set.

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

getUseRandomLns in interface BopParametersOrBuilder

Returns:

The useRandomLns.

setUseRandomLns

public BopParameters.Builder setUseRandomLns(boolean value)

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

optional bool use_random_lns = 6 [default = true];

Parameters:: value - The useRandomLns to set.
Returns:: This builder for chaining.

clearUseRandomLns

public BopParameters.Builder clearUseRandomLns()

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

optional bool use_random_lns = 6 [default = true];

Returns:: This builder for chaining.

hasRandomSeed

public 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];

Specified by:: hasRandomSeed in interface BopParametersOrBuilder
Returns:: Whether the randomSeed field is set.

getRandomSeed

public 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];

Specified by:: getRandomSeed in interface BopParametersOrBuilder
Returns:: The randomSeed.

setRandomSeed

public BopParameters.Builder setRandomSeed(int value)

 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];

Parameters:: value - The randomSeed to set.
Returns:: This builder for chaining.

clearRandomSeed

public BopParameters.Builder clearRandomSeed()

 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:: This builder for chaining.

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

hasNumRelaxedVars in interface BopParametersOrBuilder

Returns:

Whether the numRelaxedVars field is set.

getNumRelaxedVars
```
public int getNumRelaxedVars()
```
```
 Number of variables to relax in the exhaustive Large Neighborhood Search.
 
```
optional int32 num_relaxed_vars = 8 [default = 10];
Specified by:

getNumRelaxedVars in interface BopParametersOrBuilder

Returns:

The numRelaxedVars.

setNumRelaxedVars
```
public BopParameters.Builder setNumRelaxedVars(int value)
```
```
 Number of variables to relax in the exhaustive Large Neighborhood Search.
 
```
optional int32 num_relaxed_vars = 8 [default = 10];
Parameters:

value - The numRelaxedVars to set.

Returns:

This builder for chaining.

clearNumRelaxedVars

public BopParameters.Builder clearNumRelaxedVars()

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

optional int32 num_relaxed_vars = 8 [default = 10];

Returns:: This builder for chaining.

hasMaxNumberOfConflictsInRandomLns
```
public 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];
Specified by:

hasMaxNumberOfConflictsInRandomLns in interface BopParametersOrBuilder

Returns:

Whether the maxNumberOfConflictsInRandomLns field is set.

getMaxNumberOfConflictsInRandomLns
```
public 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];
Specified by:

getMaxNumberOfConflictsInRandomLns in interface BopParametersOrBuilder

Returns:

The maxNumberOfConflictsInRandomLns.

setMaxNumberOfConflictsInRandomLns
```
public BopParameters.Builder setMaxNumberOfConflictsInRandomLns(int value)
```
```
 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];
Parameters:

value - The maxNumberOfConflictsInRandomLns to set.

Returns:

This builder for chaining.

clearMaxNumberOfConflictsInRandomLns

public BopParameters.Builder clearMaxNumberOfConflictsInRandomLns()

 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:: This builder for chaining.

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

hasNumRandomLnsTries in interface BopParametersOrBuilder

Returns:

Whether the numRandomLnsTries field is set.

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

getNumRandomLnsTries in interface BopParametersOrBuilder

Returns:

The numRandomLnsTries.

setNumRandomLnsTries
```
public BopParameters.Builder setNumRandomLnsTries(int value)
```
```
 Number of tries in the random lns.
 
```
optional int32 num_random_lns_tries = 10 [default = 1];
Parameters:

value - The numRandomLnsTries to set.

Returns:

This builder for chaining.

clearNumRandomLnsTries
```
public BopParameters.Builder clearNumRandomLnsTries()
```
```
 Number of tries in the random lns.
 
```
optional int32 num_random_lns_tries = 10 [default = 1];
Returns:

This builder for chaining.

hasMaxNumberOfBacktracksInLs
```
public 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];
Specified by:

hasMaxNumberOfBacktracksInLs in interface BopParametersOrBuilder

Returns:

Whether the maxNumberOfBacktracksInLs field is set.

getMaxNumberOfBacktracksInLs
```
public 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];
Specified by:

getMaxNumberOfBacktracksInLs in interface BopParametersOrBuilder

Returns:

The maxNumberOfBacktracksInLs.

setMaxNumberOfBacktracksInLs

public BopParameters.Builder setMaxNumberOfBacktracksInLs(long value)

 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];

Parameters:: value - The maxNumberOfBacktracksInLs to set.
Returns:: This builder for chaining.

clearMaxNumberOfBacktracksInLs

public BopParameters.Builder clearMaxNumberOfBacktracksInLs()

 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:: This builder for chaining.

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

hasUseLpLns in interface BopParametersOrBuilder

Returns:

Whether the useLpLns field is set.

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

getUseLpLns in interface BopParametersOrBuilder

Returns:

The useLpLns.

setUseLpLns
```
public BopParameters.Builder setUseLpLns(boolean value)
```
```
 Use Large Neighborhood Search based on the LP relaxation.
 
```
optional bool use_lp_lns = 12 [default = true];
Parameters:

value - The useLpLns to set.

Returns:

This builder for chaining.

clearUseLpLns

public BopParameters.Builder clearUseLpLns()

 Use Large Neighborhood Search based on the LP relaxation.

optional bool use_lp_lns = 12 [default = true];

Returns:: This builder for chaining.

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

hasUseSatToChooseLnsNeighbourhood in interface BopParametersOrBuilder

Returns:

Whether the useSatToChooseLnsNeighbourhood field is set.

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

getUseSatToChooseLnsNeighbourhood in interface BopParametersOrBuilder

Returns:

The useSatToChooseLnsNeighbourhood.

setUseSatToChooseLnsNeighbourhood
```
public BopParameters.Builder setUseSatToChooseLnsNeighbourhood(boolean value)
```
```
 Whether we use sat propagation to choose the lns neighbourhood.
 
```
optional bool use_sat_to_choose_lns_neighbourhood = 15 [default = true];
Parameters:

value - The useSatToChooseLnsNeighbourhood to set.

Returns:

This builder for chaining.

clearUseSatToChooseLnsNeighbourhood

public BopParameters.Builder clearUseSatToChooseLnsNeighbourhood()

 Whether we use sat propagation to choose the lns neighbourhood.

optional bool use_sat_to_choose_lns_neighbourhood = 15 [default = true];

Returns:: This builder for chaining.

hasMaxNumberOfConflictsForQuickCheck
```
public 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];
Specified by:

hasMaxNumberOfConflictsForQuickCheck in interface BopParametersOrBuilder

Returns:

Whether the maxNumberOfConflictsForQuickCheck field is set.

getMaxNumberOfConflictsForQuickCheck
```
public 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];
Specified by:

getMaxNumberOfConflictsForQuickCheck in interface BopParametersOrBuilder

Returns:

The maxNumberOfConflictsForQuickCheck.

setMaxNumberOfConflictsForQuickCheck
```
public BopParameters.Builder setMaxNumberOfConflictsForQuickCheck(int value)
```
```
 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];
Parameters:

value - The maxNumberOfConflictsForQuickCheck to set.

Returns:

This builder for chaining.

clearMaxNumberOfConflictsForQuickCheck

public BopParameters.Builder clearMaxNumberOfConflictsForQuickCheck()

 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:: This builder for chaining.

hasUseSymmetry

public 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];

Specified by:: hasUseSymmetry in interface BopParametersOrBuilder
Returns:: Whether the useSymmetry field is set.

getUseSymmetry

public 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];

Specified by:: getUseSymmetry in interface BopParametersOrBuilder
Returns:: The useSymmetry.

setUseSymmetry

public BopParameters.Builder setUseSymmetry(boolean value)

 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];

Parameters:: value - The useSymmetry to set.
Returns:: This builder for chaining.

clearUseSymmetry

public BopParameters.Builder clearUseSymmetry()

 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:: This builder for chaining.

hasExploitSymmetryInSatFirstSolution

public 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];

Specified by:: hasExploitSymmetryInSatFirstSolution in interface BopParametersOrBuilder
Returns:: Whether the exploitSymmetryInSatFirstSolution field is set.

getExploitSymmetryInSatFirstSolution

public 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];

Specified by:: getExploitSymmetryInSatFirstSolution in interface BopParametersOrBuilder
Returns:: The exploitSymmetryInSatFirstSolution.

setExploitSymmetryInSatFirstSolution

public BopParameters.Builder setExploitSymmetryInSatFirstSolution(boolean value)

 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];

Parameters:: value - The exploitSymmetryInSatFirstSolution to set.
Returns:: This builder for chaining.

clearExploitSymmetryInSatFirstSolution

public BopParameters.Builder clearExploitSymmetryInSatFirstSolution()

 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:: This builder for chaining.

hasMaxNumberOfConflictsInRandomSolutionGeneration
```
public 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];
Specified by:

hasMaxNumberOfConflictsInRandomSolutionGeneration in interface BopParametersOrBuilder

Returns:

Whether the maxNumberOfConflictsInRandomSolutionGeneration field is set.

getMaxNumberOfConflictsInRandomSolutionGeneration
```
public 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];
Specified by:

getMaxNumberOfConflictsInRandomSolutionGeneration in interface BopParametersOrBuilder

Returns:

The maxNumberOfConflictsInRandomSolutionGeneration.

setMaxNumberOfConflictsInRandomSolutionGeneration
```
public BopParameters.Builder setMaxNumberOfConflictsInRandomSolutionGeneration(int value)
```
```
 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];
Parameters:

value - The maxNumberOfConflictsInRandomSolutionGeneration to set.

Returns:

This builder for chaining.

clearMaxNumberOfConflictsInRandomSolutionGeneration
```
public BopParameters.Builder clearMaxNumberOfConflictsInRandomSolutionGeneration()
```
```
 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:

This builder for chaining.

hasMaxNumberOfExploredAssignmentsPerTryInLs

public 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];

Specified by:: hasMaxNumberOfExploredAssignmentsPerTryInLs in interface BopParametersOrBuilder
Returns:: Whether the maxNumberOfExploredAssignmentsPerTryInLs field is set.

getMaxNumberOfExploredAssignmentsPerTryInLs

public 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];

Specified by:: getMaxNumberOfExploredAssignmentsPerTryInLs in interface BopParametersOrBuilder
Returns:: The maxNumberOfExploredAssignmentsPerTryInLs.

setMaxNumberOfExploredAssignmentsPerTryInLs

public BopParameters.Builder setMaxNumberOfExploredAssignmentsPerTryInLs(long value)

 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];

Parameters:: value - The maxNumberOfExploredAssignmentsPerTryInLs to set.
Returns:: This builder for chaining.

clearMaxNumberOfExploredAssignmentsPerTryInLs

public BopParameters.Builder clearMaxNumberOfExploredAssignmentsPerTryInLs()

 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:: This builder for chaining.

hasUseTranspositionTableInLs

public 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];

Specified by:: hasUseTranspositionTableInLs in interface BopParametersOrBuilder
Returns:: Whether the useTranspositionTableInLs field is set.

getUseTranspositionTableInLs

public 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];

Specified by:: getUseTranspositionTableInLs in interface BopParametersOrBuilder
Returns:: The useTranspositionTableInLs.

setUseTranspositionTableInLs

public BopParameters.Builder setUseTranspositionTableInLs(boolean value)

 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];

Parameters:: value - The useTranspositionTableInLs to set.
Returns:: This builder for chaining.

clearUseTranspositionTableInLs

public BopParameters.Builder clearUseTranspositionTableInLs()

 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:: This builder for chaining.

hasUsePotentialOneFlipRepairsInLs

public 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];

Specified by:: hasUsePotentialOneFlipRepairsInLs in interface BopParametersOrBuilder
Returns:: Whether the usePotentialOneFlipRepairsInLs field is set.

getUsePotentialOneFlipRepairsInLs

public 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];

Specified by:: getUsePotentialOneFlipRepairsInLs in interface BopParametersOrBuilder
Returns:: The usePotentialOneFlipRepairsInLs.

setUsePotentialOneFlipRepairsInLs

public BopParameters.Builder setUsePotentialOneFlipRepairsInLs(boolean value)

 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];

Parameters:: value - The usePotentialOneFlipRepairsInLs to set.
Returns:: This builder for chaining.

clearUsePotentialOneFlipRepairsInLs

public BopParameters.Builder clearUsePotentialOneFlipRepairsInLs()

 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:: This builder for chaining.

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

hasUseLearnedBinaryClausesInLp in interface BopParametersOrBuilder

Returns:

Whether the useLearnedBinaryClausesInLp field is set.

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

getUseLearnedBinaryClausesInLp in interface BopParametersOrBuilder

Returns:

The useLearnedBinaryClausesInLp.

setUseLearnedBinaryClausesInLp
```
public BopParameters.Builder setUseLearnedBinaryClausesInLp(boolean value)
```
```
 Whether we use the learned binary clauses in the Linear Relaxation.
 
```
optional bool use_learned_binary_clauses_in_lp = 23 [default = true];
Parameters:

value - The useLearnedBinaryClausesInLp to set.

Returns:

This builder for chaining.

clearUseLearnedBinaryClausesInLp

public BopParameters.Builder clearUseLearnedBinaryClausesInLp()

 Whether we use the learned binary clauses in the Linear Relaxation.

optional bool use_learned_binary_clauses_in_lp = 23 [default = true];

Returns:: This builder for chaining.

hasNumberOfSolvers

public 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];

Specified by:: hasNumberOfSolvers in interface BopParametersOrBuilder
Returns:: Whether the numberOfSolvers field is set.

getNumberOfSolvers

public 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];

Specified by:: getNumberOfSolvers in interface BopParametersOrBuilder
Returns:: The numberOfSolvers.

setNumberOfSolvers

public BopParameters.Builder setNumberOfSolvers(int value)

 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];

Parameters:: value - The numberOfSolvers to set.
Returns:: This builder for chaining.

clearNumberOfSolvers

public BopParameters.Builder clearNumberOfSolvers()

 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:: This builder for chaining.

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

Specified by:

hasSynchronizationType in interface BopParametersOrBuilder

Returns:

Whether the synchronizationType field is set.

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

Specified by:

getSynchronizationType in interface BopParametersOrBuilder

Returns:

The synchronizationType.

setSynchronizationType
```
public BopParameters.Builder setSynchronizationType(BopParameters.ThreadSynchronizationType value)
```
optional .operations_research.bop.BopParameters.ThreadSynchronizationType synchronization_type = 25 [default = NO_SYNCHRONIZATION];

Parameters:

value - The synchronizationType to set.

Returns:

This builder for chaining.

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

Returns:

This builder for chaining.