Interface BopParametersOrBuilder

All Superinterfaces:
com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder
All Known Implementing Classes:
BopParameters, BopParameters.Builder

@Generated public interface BopParametersOrBuilder extends com.google.protobuf.MessageOrBuilder
  • Method Summary

    Modifier and Type
    Method
    Description
    boolean
    Compute estimated impact at each iteration when true; only once when false.
    double
    HACK.
    int
    Only try to decompose the problem when the number of variables is greater than the threshold.
    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
    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
    If true, find and exploit symmetries in proving satisfiability in the first problem.
    int
    The first solutions based on guided SAT will work in chunk of that many conflicts at the time.
    boolean
    Whether the solver should log the search progress to LOG(INFO).
    double
    The max deterministic time given to the LP solver each time it is called.
    double
    Maximum time allowed in deterministic time to solve a problem.
    int
    The maximum number of time the LP solver will run to feasibility for pure feasibility problems (with a constant-valued objective function).
    long
    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
    The number of conflicts the SAT solver has to solve a random LNS subproblem for the quick check of infeasibility.
    int
    The number of conflicts the SAT solver has to solve a random LNS subproblem.
    int
    The number of conflicts the SAT solver has to generate a random solution.
    int
    Maximum number of consecutive optimizer calls without improving the current solution.
    long
    The maximum number of assignments the Local Search iterates on during one try.
    int
    Abort the LS search tree as soon as strictly more than this number of constraints are broken.
    int
    Maximum number of cascading decisions the solver might use to repair the current solution in the LS.
    double
    Maximum time allowed in seconds to solve a problem.
    int
    The number of solvers used to run Bop.
    int
    The number of BopSolver created (thread pool workers) used by the integral solver to solve a decomposed problem.
    int
    Number of tries in the random lns.
    int
    Number of variables to relax in the exhaustive Large Neighborhood Search.
    boolean
    Avoid exploring both branches (b, a, ...) and (a, b, ...).
    int
    The seed used to initialize the random generator.
    double
    Limit used to stop the optimization as soon as the relative gap is smaller than the given value.
    List of set of optimizers to be run by the solvers.
    int
    List of set of optimizers to be run by the solvers.
    List of set of optimizers to be run by the solvers.
    List of set of optimizers to be run by the solvers.
    List of set of optimizers to be run by the solvers.
    boolean
    Sort constraints by increasing total number of terms instead of number of contributing terms.
    optional .operations_research.bop.BopParameters.ThreadSynchronizationType synchronization_type = 25 [default = NO_SYNCHRONIZATION];
    boolean
    Whether we use the learned binary clauses in the Linear Relaxation.
    boolean
    Use Large Neighborhood Search based on the LP relaxation.
    boolean
    Use strong branching in the linear relaxation optimizer.
    boolean
    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
    Use the random Large Neighborhood Search instead of the exhaustive one.
    boolean
    Whether we use sat propagation to choose the lns neighbourhood.
    boolean
    If true, find and exploit the eventual symmetries of the problem.
    boolean
    Whether we use an hash set during the LS to avoid exploring more than once the "same" state.
    boolean
    Compute estimated impact at each iteration when true; only once when false.
    boolean
    HACK.
    boolean
    Only try to decompose the problem when the number of variables is greater than the threshold.
    boolean
    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
    If true, find and exploit symmetries in proving satisfiability in the first problem.
    boolean
    The first solutions based on guided SAT will work in chunk of that many conflicts at the time.
    boolean
    Whether the solver should log the search progress to LOG(INFO).
    boolean
    The max deterministic time given to the LP solver each time it is called.
    boolean
    Maximum time allowed in deterministic time to solve a problem.
    boolean
    The maximum number of time the LP solver will run to feasibility for pure feasibility problems (with a constant-valued objective function).
    boolean
    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
    The number of conflicts the SAT solver has to solve a random LNS subproblem for the quick check of infeasibility.
    boolean
    The number of conflicts the SAT solver has to solve a random LNS subproblem.
    boolean
    The number of conflicts the SAT solver has to generate a random solution.
    boolean
    Maximum number of consecutive optimizer calls without improving the current solution.
    boolean
    The maximum number of assignments the Local Search iterates on during one try.
    boolean
    Abort the LS search tree as soon as strictly more than this number of constraints are broken.
    boolean
    Maximum number of cascading decisions the solver might use to repair the current solution in the LS.
    boolean
    Maximum time allowed in seconds to solve a problem.
    boolean
    The number of solvers used to run Bop.
    boolean
    The number of BopSolver created (thread pool workers) used by the integral solver to solve a decomposed problem.
    boolean
    Number of tries in the random lns.
    boolean
    Number of variables to relax in the exhaustive Large Neighborhood Search.
    boolean
    Avoid exploring both branches (b, a, ...) and (a, b, ...).
    boolean
    The seed used to initialize the random generator.
    boolean
    Limit used to stop the optimization as soon as the relative gap is smaller than the given value.
    boolean
    Sort constraints by increasing total number of terms instead of number of contributing terms.
    boolean
    optional .operations_research.bop.BopParameters.ThreadSynchronizationType synchronization_type = 25 [default = NO_SYNCHRONIZATION];
    boolean
    Whether we use the learned binary clauses in the Linear Relaxation.
    boolean
    Use Large Neighborhood Search based on the LP relaxation.
    boolean
    Use strong branching in the linear relaxation optimizer.
    boolean
    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
    Use the random Large Neighborhood Search instead of the exhaustive one.
    boolean
    Whether we use sat propagation to choose the lns neighbourhood.
    boolean
    If true, find and exploit the eventual symmetries of the problem.
    boolean
    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.MessageLiteOrBuilder

    isInitialized

    Methods inherited from interface com.google.protobuf.MessageOrBuilder

    findInitializationErrors, getAllFields, getDefaultInstanceForType, getDescriptorForType, getField, getInitializationErrorString, getOneofFieldDescriptor, getRepeatedField, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof
  • Method Details

    • 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.
    • getSolverOptimizerSetsList

      List<BopSolverOptimizerSet> getSolverOptimizerSetsList()
       List of set of optimizers to be run by the solvers.
       Note that the i_th solver will run the
       min(i, solver_optimizer_sets_size())_th optimizer set.
       The default is defined by default_solver_optimizer_sets (only one set).
       
      repeated .operations_research.bop.BopSolverOptimizerSet solver_optimizer_sets = 26;
    • getSolverOptimizerSets

      BopSolverOptimizerSet getSolverOptimizerSets(int index)
       List of set of optimizers to be run by the solvers.
       Note that the i_th solver will run the
       min(i, solver_optimizer_sets_size())_th optimizer set.
       The default is defined by default_solver_optimizer_sets (only one set).
       
      repeated .operations_research.bop.BopSolverOptimizerSet solver_optimizer_sets = 26;
    • getSolverOptimizerSetsCount

      int getSolverOptimizerSetsCount()
       List of set of optimizers to be run by the solvers.
       Note that the i_th solver will run the
       min(i, solver_optimizer_sets_size())_th optimizer set.
       The default is defined by default_solver_optimizer_sets (only one set).
       
      repeated .operations_research.bop.BopSolverOptimizerSet solver_optimizer_sets = 26;
    • getSolverOptimizerSetsOrBuilderList

      List<? extends BopSolverOptimizerSetOrBuilder> getSolverOptimizerSetsOrBuilderList()
       List of set of optimizers to be run by the solvers.
       Note that the i_th solver will run the
       min(i, solver_optimizer_sets_size())_th optimizer set.
       The default is defined by default_solver_optimizer_sets (only one set).
       
      repeated .operations_research.bop.BopSolverOptimizerSet solver_optimizer_sets = 26;
    • getSolverOptimizerSetsOrBuilder

      BopSolverOptimizerSetOrBuilder getSolverOptimizerSetsOrBuilder(int index)
       List of set of optimizers to be run by the solvers.
       Note that the i_th solver will run the
       min(i, solver_optimizer_sets_size())_th optimizer set.
       The default is defined by default_solver_optimizer_sets (only one set).
       
      repeated .operations_research.bop.BopSolverOptimizerSet solver_optimizer_sets = 26;
    • hasDefaultSolverOptimizerSets

      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 } "];
      Returns:
      Whether the defaultSolverOptimizerSets field is set.
    • getDefaultSolverOptimizerSets

      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 } "];
      Returns:
      The defaultSolverOptimizerSets.
    • getDefaultSolverOptimizerSetsBytes

      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 } "];
      Returns:
      The bytes for defaultSolverOptimizerSets.
    • hasUseLpStrongBranching

      boolean hasUseLpStrongBranching()
       Use strong branching in the linear relaxation optimizer.
       The strong branching is a what-if analysis on each variable v, i.e.
       compute the best bound when v is assigned to true, compute the best bound
       when v is assigned to false, and then use those best bounds to improve the
       overall best bound.
       This is useful to improve the best_bound, but also to fix some variables
       during search.
       Note that using probing might be time consuming as it runs the LP solver
       2 * num_variables times.
       
      optional bool use_lp_strong_branching = 29 [default = false];
      Returns:
      Whether the useLpStrongBranching field is set.
    • getUseLpStrongBranching

      boolean getUseLpStrongBranching()
       Use strong branching in the linear relaxation optimizer.
       The strong branching is a what-if analysis on each variable v, i.e.
       compute the best bound when v is assigned to true, compute the best bound
       when v is assigned to false, and then use those best bounds to improve the
       overall best bound.
       This is useful to improve the best_bound, but also to fix some variables
       during search.
       Note that using probing might be time consuming as it runs the LP solver
       2 * num_variables times.
       
      optional bool use_lp_strong_branching = 29 [default = false];
      Returns:
      The useLpStrongBranching.
    • hasDecomposerNumVariablesThreshold

      boolean hasDecomposerNumVariablesThreshold()
       Only try to decompose the problem when the number of variables is greater
       than the threshold.
       
      optional int32 decomposer_num_variables_threshold = 30 [default = 50];
      Returns:
      Whether the decomposerNumVariablesThreshold field is set.
    • getDecomposerNumVariablesThreshold

      int getDecomposerNumVariablesThreshold()
       Only try to decompose the problem when the number of variables is greater
       than the threshold.
       
      optional int32 decomposer_num_variables_threshold = 30 [default = 50];
      Returns:
      The decomposerNumVariablesThreshold.
    • hasNumBopSolversUsedByDecomposition

      boolean hasNumBopSolversUsedByDecomposition()
       The number of BopSolver created (thread pool workers) used by the integral
       solver to solve a decomposed problem.
       TODO(user): Merge this with the number_of_solvers parameter.
       
      optional int32 num_bop_solvers_used_by_decomposition = 31 [default = 1];
      Returns:
      Whether the numBopSolversUsedByDecomposition field is set.
    • getNumBopSolversUsedByDecomposition

      int getNumBopSolversUsedByDecomposition()
       The number of BopSolver created (thread pool workers) used by the integral
       solver to solve a decomposed problem.
       TODO(user): Merge this with the number_of_solvers parameter.
       
      optional int32 num_bop_solvers_used_by_decomposition = 31 [default = 1];
      Returns:
      The numBopSolversUsedByDecomposition.
    • hasDecomposedProblemMinTimeInSeconds

      boolean hasDecomposedProblemMinTimeInSeconds()
       HACK. To avoid spending too little time on small problems, spend at least
       this time solving each of the decomposed sub-problem. This only make sense
       if num_bop_solvers_used_by_decomposition is greater than 1 so that the
       overhead can be "absorbed" by the other threads.
       
      optional double decomposed_problem_min_time_in_seconds = 36 [default = 0];
      Returns:
      Whether the decomposedProblemMinTimeInSeconds field is set.
    • getDecomposedProblemMinTimeInSeconds

      double getDecomposedProblemMinTimeInSeconds()
       HACK. To avoid spending too little time on small problems, spend at least
       this time solving each of the decomposed sub-problem. This only make sense
       if num_bop_solvers_used_by_decomposition is greater than 1 so that the
       overhead can be "absorbed" by the other threads.
       
      optional double decomposed_problem_min_time_in_seconds = 36 [default = 0];
      Returns:
      The decomposedProblemMinTimeInSeconds.
    • hasGuidedSatConflictsChunk

      boolean hasGuidedSatConflictsChunk()
       The first solutions based on guided SAT will work in chunk of that many
       conflicts at the time. This allows to simulate parallelism between the
       different guiding strategy on a single core.
       
      optional int32 guided_sat_conflicts_chunk = 34 [default = 1000];
      Returns:
      Whether the guidedSatConflictsChunk field is set.
    • getGuidedSatConflictsChunk

      int getGuidedSatConflictsChunk()
       The first solutions based on guided SAT will work in chunk of that many
       conflicts at the time. This allows to simulate parallelism between the
       different guiding strategy on a single core.
       
      optional int32 guided_sat_conflicts_chunk = 34 [default = 1000];
      Returns:
      The guidedSatConflictsChunk.
    • hasMaxLpSolveForFeasibilityProblems

      boolean hasMaxLpSolveForFeasibilityProblems()
       The maximum number of time the LP solver will run to feasibility for pure
       feasibility problems (with a constant-valued objective function). Set this
       to a small value, e.g., 1, if fractional solutions offer useful guidance to
       other solvers in the portfolio. A negative value means no limit.
       
      optional int32 max_lp_solve_for_feasibility_problems = 41 [default = 0];
      Returns:
      Whether the maxLpSolveForFeasibilityProblems field is set.
    • getMaxLpSolveForFeasibilityProblems

      int getMaxLpSolveForFeasibilityProblems()
       The maximum number of time the LP solver will run to feasibility for pure
       feasibility problems (with a constant-valued objective function). Set this
       to a small value, e.g., 1, if fractional solutions offer useful guidance to
       other solvers in the portfolio. A negative value means no limit.
       
      optional int32 max_lp_solve_for_feasibility_problems = 41 [default = 0];
      Returns:
      The maxLpSolveForFeasibilityProblems.