java.lang.Object

com.google.protobuf.AbstractMessageLite

com.google.protobuf.AbstractMessage

com.google.protobuf.GeneratedMessageV3

com.google.ortools.sat.SatParameters

All Implemented Interfaces:: SatParametersOrBuilder, com.google.protobuf.Message, com.google.protobuf.MessageLite, com.google.protobuf.MessageLiteOrBuilder, com.google.protobuf.MessageOrBuilder, java.io.Serializable

public final class SatParameters
extends com.google.protobuf.GeneratedMessageV3
implements SatParametersOrBuilder

 Contains the definitions for all the sat algorithm parameters and their
 default values.
 NEXT TAG: 188

Protobuf type operations_research.sat.SatParameters

See Also:: Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`SatParameters.BinaryMinizationAlgorithm`	Whether to expoit the binary clause to minimize learned clauses further.
`static class`	`SatParameters.Builder`	Contains the definitions for all the sat algorithm parameters and their default values.
`static class`	`SatParameters.ClauseOrdering`	The clauses that will be kept during a cleanup are the ones that come first under this order.
`static class`	`SatParameters.ClauseProtection`	Each time a clause activity is bumped, the clause has a chance to be protected during the next cleanup phase.
`static class`	`SatParameters.ConflictMinimizationAlgorithm`	Do we try to minimize conflicts (greedily) when creating them.
`static class`	`SatParameters.FPRoundingMethod`	Rounding method to use for feasibility pump.
`static class`	`SatParameters.MaxSatAssumptionOrder`	In what order do we add the assumptions in a core-based max-sat algorithm
`static class`	`SatParameters.MaxSatStratificationAlgorithm`	What stratification algorithm we use in the presence of weight.
`static class`	`SatParameters.Polarity`	Specifies the initial polarity (true/false) when the solver branches on a variable.
`static class`	`SatParameters.RestartAlgorithm`	Restart algorithms.
`static class`	`SatParameters.SearchBranching`	The search branching will be used to decide how to branch on unfixed nodes.
`static class`	`SatParameters.VariableOrder`	Variables without activity (i.e.

Nested classes/interfaces inherited from class com.google.protobuf.GeneratedMessageV3

com.google.protobuf.GeneratedMessageV3.BuilderParent, com.google.protobuf.GeneratedMessageV3.ExtendableBuilder<MessageType extends com.google.protobuf.GeneratedMessageV3.ExtendableMessage,BuilderType extends com.google.protobuf.GeneratedMessageV3.ExtendableBuilder<MessageType,BuilderType>>, com.google.protobuf.GeneratedMessageV3.ExtendableMessage<MessageType extends com.google.protobuf.GeneratedMessageV3.ExtendableMessage>, com.google.protobuf.GeneratedMessageV3.ExtendableMessageOrBuilder<MessageType extends com.google.protobuf.GeneratedMessageV3.ExtendableMessage>, com.google.protobuf.GeneratedMessageV3.FieldAccessorTable, com.google.protobuf.GeneratedMessageV3.UnusedPrivateParameter

Nested classes/interfaces inherited from class com.google.protobuf.AbstractMessageLite

com.google.protobuf.AbstractMessageLite.InternalOneOfEnum

Field Summary

Fields
Modifier and Type	Field	Description
`static int`	`ABSOLUTE_GAP_LIMIT_FIELD_NUMBER`
`static int`	`ADD_CG_CUTS_FIELD_NUMBER`
`static int`	`ADD_CLIQUE_CUTS_FIELD_NUMBER`
`static int`	`ADD_KNAPSACK_CUTS_FIELD_NUMBER`
`static int`	`ADD_LIN_MAX_CUTS_FIELD_NUMBER`
`static int`	`ADD_LP_CONSTRAINTS_LAZILY_FIELD_NUMBER`
`static int`	`ADD_MIR_CUTS_FIELD_NUMBER`
`static int`	`ADD_ZERO_HALF_CUTS_FIELD_NUMBER`
`static int`	`ALSO_BUMP_VARIABLES_IN_CONFLICT_REASONS_FIELD_NUMBER`
`static int`	`AUTO_DETECT_GREATER_THAN_AT_LEAST_ONE_OF_FIELD_NUMBER`
`static int`	`BINARY_MINIMIZATION_ALGORITHM_FIELD_NUMBER`
`static int`	`BINARY_SEARCH_NUM_CONFLICTS_FIELD_NUMBER`
`static int`	`BLOCKING_RESTART_MULTIPLIER_FIELD_NUMBER`
`static int`	`BLOCKING_RESTART_WINDOW_SIZE_FIELD_NUMBER`
`static int`	`BOOLEAN_ENCODING_LEVEL_FIELD_NUMBER`
`static int`	`CATCH_SIGINT_SIGNAL_FIELD_NUMBER`
`static int`	`CLAUSE_ACTIVITY_DECAY_FIELD_NUMBER`
`static int`	`CLAUSE_CLEANUP_LBD_BOUND_FIELD_NUMBER`
`static int`	`CLAUSE_CLEANUP_ORDERING_FIELD_NUMBER`
`static int`	`CLAUSE_CLEANUP_PERIOD_FIELD_NUMBER`
`static int`	`CLAUSE_CLEANUP_PROTECTION_FIELD_NUMBER`
`static int`	`CLAUSE_CLEANUP_TARGET_FIELD_NUMBER`
`static int`	`CONVERT_INTERVALS_FIELD_NUMBER`
`static int`	`COUNT_ASSUMPTION_LEVELS_IN_LBD_FIELD_NUMBER`
`static int`	`COVER_OPTIMIZATION_FIELD_NUMBER`
`static int`	`CP_MODEL_MAX_NUM_PRESOLVE_OPERATIONS_FIELD_NUMBER`
`static int`	`CP_MODEL_POSTSOLVE_WITH_FULL_SOLVER_FIELD_NUMBER`
`static int`	`CP_MODEL_PRESOLVE_FIELD_NUMBER`
`static int`	`CP_MODEL_PROBING_LEVEL_FIELD_NUMBER`
`static int`	`CP_MODEL_USE_SAT_PRESOLVE_FIELD_NUMBER`
`static int`	`CUT_ACTIVE_COUNT_DECAY_FIELD_NUMBER`
`static int`	`CUT_CLEANUP_TARGET_FIELD_NUMBER`
`static int`	`CUT_MAX_ACTIVE_COUNT_VALUE_FIELD_NUMBER`
`static int`	`DEFAULT_RESTART_ALGORITHMS_FIELD_NUMBER`
`static int`	`DISABLE_CONSTRAINT_EXPANSION_FIELD_NUMBER`
`static int`	`DIVERSIFY_LNS_PARAMS_FIELD_NUMBER`
`static int`	`ENUMERATE_ALL_SOLUTIONS_FIELD_NUMBER`
`static int`	`EXPAND_ALLDIFF_CONSTRAINTS_FIELD_NUMBER`
`static int`	`EXPAND_AUTOMATON_CONSTRAINTS_FIELD_NUMBER`
`static int`	`EXPAND_ELEMENT_CONSTRAINTS_FIELD_NUMBER`
`static int`	`EXPAND_RESERVOIR_CONSTRAINTS_FIELD_NUMBER`
`static int`	`EXPAND_TABLE_CONSTRAINTS_FIELD_NUMBER`
`static int`	`EXPLOIT_ALL_LP_SOLUTION_FIELD_NUMBER`
`static int`	`EXPLOIT_BEST_SOLUTION_FIELD_NUMBER`
`static int`	`EXPLOIT_INTEGER_LP_SOLUTION_FIELD_NUMBER`
`static int`	`EXPLOIT_OBJECTIVE_FIELD_NUMBER`
`static int`	`EXPLOIT_RELAXATION_SOLUTION_FIELD_NUMBER`
`static int`	`FILL_TIGHTENED_DOMAINS_IN_RESPONSE_FIELD_NUMBER`
`static int`	`FIND_MULTIPLE_CORES_FIELD_NUMBER`
`static int`	`FP_ROUNDING_FIELD_NUMBER`
`static int`	`GLUCOSE_DECAY_INCREMENT_FIELD_NUMBER`
`static int`	`GLUCOSE_DECAY_INCREMENT_PERIOD_FIELD_NUMBER`
`static int`	`GLUCOSE_MAX_DECAY_FIELD_NUMBER`
`static int`	`HINT_CONFLICT_LIMIT_FIELD_NUMBER`
`static int`	`INITIAL_POLARITY_FIELD_NUMBER`
`static int`	`INITIAL_VARIABLES_ACTIVITY_FIELD_NUMBER`
`static int`	`INSTANTIATE_ALL_VARIABLES_FIELD_NUMBER`
`static int`	`INTERLEAVE_BATCH_SIZE_FIELD_NUMBER`
`static int`	`INTERLEAVE_SEARCH_FIELD_NUMBER`
`static int`	`KEEP_ALL_FEASIBLE_SOLUTIONS_IN_PRESOLVE_FIELD_NUMBER`
`static int`	`LINEARIZATION_LEVEL_FIELD_NUMBER`
`static int`	`LNS_EXPAND_INTERVALS_IN_CONSTRAINT_GRAPH_FIELD_NUMBER`
`static int`	`LNS_FOCUS_ON_DECISION_VARIABLES_FIELD_NUMBER`
`static int`	`LOG_PREFIX_FIELD_NUMBER`
`static int`	`LOG_SEARCH_PROGRESS_FIELD_NUMBER`
`static int`	`LOG_TO_RESPONSE_FIELD_NUMBER`
`static int`	`LOG_TO_STDOUT_FIELD_NUMBER`
`static int`	`MAX_ALL_DIFF_CUT_SIZE_FIELD_NUMBER`
`static int`	`MAX_CLAUSE_ACTIVITY_VALUE_FIELD_NUMBER`
`static int`	`MAX_CONSECUTIVE_INACTIVE_COUNT_FIELD_NUMBER`
`static int`	`MAX_CUT_ROUNDS_AT_LEVEL_ZERO_FIELD_NUMBER`
`static int`	`MAX_DETERMINISTIC_TIME_FIELD_NUMBER`
`static int`	`MAX_INTEGER_ROUNDING_SCALING_FIELD_NUMBER`
`static int`	`MAX_MEMORY_IN_MB_FIELD_NUMBER`
`static int`	`MAX_NUM_CUTS_FIELD_NUMBER`
`static int`	`MAX_NUMBER_OF_CONFLICTS_FIELD_NUMBER`
`static int`	`MAX_PRESOLVE_ITERATIONS_FIELD_NUMBER`
`static int`	`MAX_SAT_ASSUMPTION_ORDER_FIELD_NUMBER`
`static int`	`MAX_SAT_REVERSE_ASSUMPTION_ORDER_FIELD_NUMBER`
`static int`	`MAX_SAT_STRATIFICATION_FIELD_NUMBER`
`static int`	`MAX_TIME_IN_SECONDS_FIELD_NUMBER`
`static int`	`MAX_VARIABLE_ACTIVITY_VALUE_FIELD_NUMBER`
`static int`	`MERGE_AT_MOST_ONE_WORK_LIMIT_FIELD_NUMBER`
`static int`	`MERGE_NO_OVERLAP_WORK_LIMIT_FIELD_NUMBER`
`static int`	`MIN_ORTHOGONALITY_FOR_LP_CONSTRAINTS_FIELD_NUMBER`
`static int`	`MINIMIZATION_ALGORITHM_FIELD_NUMBER`
`static int`	`MINIMIZE_CORE_FIELD_NUMBER`
`static int`	`MINIMIZE_REDUCTION_DURING_PB_RESOLUTION_FIELD_NUMBER`
`static int`	`MINIMIZE_WITH_PROPAGATION_NUM_DECISIONS_FIELD_NUMBER`
`static int`	`MINIMIZE_WITH_PROPAGATION_RESTART_PERIOD_FIELD_NUMBER`
`static int`	`MIP_AUTOMATICALLY_SCALE_VARIABLES_FIELD_NUMBER`
`static int`	`MIP_CHECK_PRECISION_FIELD_NUMBER`
`static int`	`MIP_MAX_ACTIVITY_EXPONENT_FIELD_NUMBER`
`static int`	`MIP_MAX_BOUND_FIELD_NUMBER`
`static int`	`MIP_VAR_SCALING_FIELD_NUMBER`
`static int`	`MIP_WANTED_PRECISION_FIELD_NUMBER`
`static int`	`NAME_FIELD_NUMBER`
`static int`	`NEW_CONSTRAINTS_BATCH_SIZE_FIELD_NUMBER`
`static int`	`NUM_CONFLICTS_BEFORE_STRATEGY_CHANGES_FIELD_NUMBER`
`static int`	`NUM_SEARCH_WORKERS_FIELD_NUMBER`
`static int`	`ONLY_ADD_CUTS_AT_LEVEL_ZERO_FIELD_NUMBER`
`static int`	`OPTIMIZE_WITH_CORE_FIELD_NUMBER`
`static int`	`OPTIMIZE_WITH_MAX_HS_FIELD_NUMBER`
`static com.google.protobuf.Parser<SatParameters>`	`PARSER`	Deprecated.
`static int`	`PB_CLEANUP_INCREMENT_FIELD_NUMBER`
`static int`	`PB_CLEANUP_RATIO_FIELD_NUMBER`
`static int`	`PERMUTE_PRESOLVE_CONSTRAINT_ORDER_FIELD_NUMBER`
`static int`	`PERMUTE_VARIABLE_RANDOMLY_FIELD_NUMBER`
`static int`	`POLARITY_REPHASE_INCREMENT_FIELD_NUMBER`
`static int`	`POLISH_LP_SOLUTION_FIELD_NUMBER`
`static int`	`PREFERRED_VARIABLE_ORDER_FIELD_NUMBER`
`static int`	`PRESOLVE_BLOCKED_CLAUSE_FIELD_NUMBER`
`static int`	`PRESOLVE_BVA_THRESHOLD_FIELD_NUMBER`
`static int`	`PRESOLVE_BVE_CLAUSE_WEIGHT_FIELD_NUMBER`
`static int`	`PRESOLVE_BVE_THRESHOLD_FIELD_NUMBER`
`static int`	`PRESOLVE_EXTRACT_INTEGER_ENFORCEMENT_FIELD_NUMBER`
`static int`	`PRESOLVE_PROBING_DETERMINISTIC_TIME_LIMIT_FIELD_NUMBER`
`static int`	`PRESOLVE_SUBSTITUTION_LEVEL_FIELD_NUMBER`
`static int`	`PRESOLVE_USE_BVA_FIELD_NUMBER`
`static int`	`PROBING_PERIOD_AT_ROOT_FIELD_NUMBER`
`static int`	`PSEUDO_COST_RELIABILITY_THRESHOLD_FIELD_NUMBER`
`static int`	`RANDOM_BRANCHES_RATIO_FIELD_NUMBER`
`static int`	`RANDOM_POLARITY_RATIO_FIELD_NUMBER`
`static int`	`RANDOM_SEED_FIELD_NUMBER`
`static int`	`RANDOMIZE_SEARCH_FIELD_NUMBER`
`static int`	`REDUCE_MEMORY_USAGE_IN_INTERLEAVE_MODE_FIELD_NUMBER`
`static int`	`RELATIVE_GAP_LIMIT_FIELD_NUMBER`
`static int`	`REPAIR_HINT_FIELD_NUMBER`
`static int`	`RESTART_ALGORITHMS_FIELD_NUMBER`
`static int`	`RESTART_DL_AVERAGE_RATIO_FIELD_NUMBER`
`static int`	`RESTART_LBD_AVERAGE_RATIO_FIELD_NUMBER`
`static int`	`RESTART_PERIOD_FIELD_NUMBER`
`static int`	`RESTART_RUNNING_WINDOW_SIZE_FIELD_NUMBER`
`static int`	`SEARCH_BRANCHING_FIELD_NUMBER`
`static int`	`SEARCH_RANDOMIZATION_TOLERANCE_FIELD_NUMBER`
`static int`	`SHARE_LEVEL_ZERO_BOUNDS_FIELD_NUMBER`
`static int`	`SHARE_OBJECTIVE_BOUNDS_FIELD_NUMBER`
`static int`	`STOP_AFTER_FIRST_SOLUTION_FIELD_NUMBER`
`static int`	`STOP_AFTER_PRESOLVE_FIELD_NUMBER`
`static int`	`STRATEGY_CHANGE_INCREASE_RATIO_FIELD_NUMBER`
`static int`	`SUBSUMPTION_DURING_CONFLICT_ANALYSIS_FIELD_NUMBER`
`static int`	`SYMMETRY_LEVEL_FIELD_NUMBER`
`static int`	`TREAT_BINARY_CLAUSES_SEPARATELY_FIELD_NUMBER`
`static int`	`USE_ABSL_RANDOM_FIELD_NUMBER`
`static int`	`USE_BLOCKING_RESTART_FIELD_NUMBER`
`static int`	`USE_BRANCHING_IN_LP_FIELD_NUMBER`
`static int`	`USE_COMBINED_NO_OVERLAP_FIELD_NUMBER`
`static int`	`USE_DISJUNCTIVE_CONSTRAINT_IN_CUMULATIVE_CONSTRAINT_FIELD_NUMBER`
`static int`	`USE_ERWA_HEURISTIC_FIELD_NUMBER`
`static int`	`USE_EXACT_LP_REASON_FIELD_NUMBER`
`static int`	`USE_FEASIBILITY_PUMP_FIELD_NUMBER`
`static int`	`USE_IMPLIED_BOUNDS_FIELD_NUMBER`
`static int`	`USE_LNS_ONLY_FIELD_NUMBER`
`static int`	`USE_OPTIMIZATION_HINTS_FIELD_NUMBER`
`static int`	`USE_OPTIONAL_VARIABLES_FIELD_NUMBER`
`static int`	`USE_OVERLOAD_CHECKER_IN_CUMULATIVE_CONSTRAINT_FIELD_NUMBER`
`static int`	`USE_PB_RESOLUTION_FIELD_NUMBER`
`static int`	`USE_PHASE_SAVING_FIELD_NUMBER`
`static int`	`USE_PRECEDENCES_IN_DISJUNCTIVE_CONSTRAINT_FIELD_NUMBER`
`static int`	`USE_PROBING_SEARCH_FIELD_NUMBER`
`static int`	`USE_RELAXATION_LNS_FIELD_NUMBER`
`static int`	`USE_RINS_LNS_FIELD_NUMBER`
`static int`	`USE_SAT_INPROCESSING_FIELD_NUMBER`
`static int`	`USE_TIMETABLE_EDGE_FINDING_IN_CUMULATIVE_CONSTRAINT_FIELD_NUMBER`
`static int`	`VARIABLE_ACTIVITY_DECAY_FIELD_NUMBER`

Fields inherited from class com.google.protobuf.GeneratedMessageV3

alwaysUseFieldBuilders, unknownFields

Fields inherited from class com.google.protobuf.AbstractMessage

memoizedSize

Fields inherited from class com.google.protobuf.AbstractMessageLite

memoizedHashCode

Method Summary

Modifier and Type	Method	Description
`boolean`	`equals(java.lang.Object obj)`
`double`	`getAbsoluteGapLimit()`	Stop the search when the gap between the best feasible objective (O) and our best objective bound (B) is smaller than a limit.
`boolean`	`getAddCgCuts()`	Whether we generate and add Chvatal-Gomory cuts to the LP at root node.
`boolean`	`getAddCliqueCuts()`	Whether we generate clique cuts from the binary implication graph.
`boolean`	`getAddKnapsackCuts()`	Whether we generate knapsack cuts.
`boolean`	`getAddLinMaxCuts()`	For the lin max constraints, generates the cuts described in "Strong mixed-integer programming formulations for trained neural networks" by Ross Anderson et.
`boolean`	`getAddLpConstraintsLazily()`	If true, we start by an empty LP, and only add constraints not satisfied by the current LP solution batch by batch.
`boolean`	`getAddMirCuts()`	Whether we generate MIR cuts at root node.
`boolean`	`getAddZeroHalfCuts()`	Whether we generate Zero-Half cuts at root node.
`boolean`	`getAlsoBumpVariablesInConflictReasons()`	When this is true, then the variables that appear in any of the reason of the variables in a conflict have their activity bumped.
`boolean`	`getAutoDetectGreaterThanAtLeastOneOf()`	If true, then the precedences propagator try to detect for each variable if it has a set of "optional incoming arc" for which at least one of them is present.
`SatParameters.BinaryMinizationAlgorithm`	`getBinaryMinimizationAlgorithm()`	`optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];`
`int`	`getBinarySearchNumConflicts()`	If non-negative, perform a binary search on the objective variable in order to find an [min, max] interval outside of which the solver proved unsat/sat under this amount of conflict.
`double`	`getBlockingRestartMultiplier()`	`optional double blocking_restart_multiplier = 66 [default = 1.4];`
`int`	`getBlockingRestartWindowSize()`	`optional int32 blocking_restart_window_size = 65 [default = 5000];`
`int`	`getBooleanEncodingLevel()`	A non-negative level indicating how much we should try to fully encode Integer variables as Boolean.
`boolean`	`getCatchSigintSignal()`	Indicates if the CP-SAT layer should catch Control-C (SIGINT) signals when calling solve.
`double`	`getClauseActivityDecay()`	Clause activity parameters (same effect as the one on the variables).
`int`	`getClauseCleanupLbdBound()`	All the clauses with a LBD (literal blocks distance) lower or equal to this parameters will always be kept.
`SatParameters.ClauseOrdering`	`getClauseCleanupOrdering()`	`optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];`
`int`	`getClauseCleanupPeriod()`	Trigger a cleanup when this number of "deletable" clauses is learned.
`SatParameters.ClauseProtection`	`getClauseCleanupProtection()`	`optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];`
`int`	`getClauseCleanupTarget()`	During a cleanup, we will always keep that number of "deletable" clauses.
`boolean`	`getConvertIntervals()`	Temporary flag util the feature is more mature.
`boolean`	`getCountAssumptionLevelsInLbd()`	Whether or not the assumption levels are taken into account during the LBD computation.
`boolean`	`getCoverOptimization()`	If true, when the max-sat algo find a core, we compute the minimal number of literals in the core that needs to be true to have a feasible solution.
`int`	`getCpModelMaxNumPresolveOperations()`	If positive, try to stop just after that many presolve rules have been applied.
`boolean`	`getCpModelPostsolveWithFullSolver()`	Advanced usage.
`boolean`	`getCpModelPresolve()`	Whether we presolve the cp_model before solving it.
`int`	`getCpModelProbingLevel()`	How much effort do we spend on probing.
`boolean`	`getCpModelUseSatPresolve()`	Whether we also use the sat presolve when cp_model_presolve is true.
`double`	`getCutActiveCountDecay()`	`optional double cut_active_count_decay = 156 [default = 0.8];`
`int`	`getCutCleanupTarget()`	Target number of constraints to remove during cleanup.
`double`	`getCutMaxActiveCountValue()`	These parameters are similar to sat clause management activity parameters.
`static SatParameters`	`getDefaultInstance()`
`SatParameters`	`getDefaultInstanceForType()`
`java.lang.String`	`getDefaultRestartAlgorithms()`	`optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];`
`com.google.protobuf.ByteString`	`getDefaultRestartAlgorithmsBytes()`	`optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];`
`static com.google.protobuf.Descriptors.Descriptor`	`getDescriptor()`
`boolean`	`getDisableConstraintExpansion()`	If true, it disable all constraint expansion.
`boolean`	`getDiversifyLnsParams()`	If true, registers more lns subsolvers with different parameters.
`boolean`	`getEnumerateAllSolutions()`	Whether we enumerate all solutions of a problem without objective.
`boolean`	`getExpandAlldiffConstraints()`	If true, expand all_different constraints that are not permutations.
`boolean`	`getExpandAutomatonConstraints()`	If true, the automaton constraints are expanded.
`boolean`	`getExpandElementConstraints()`	If true, the element constraints are expanded into many linear constraints of the form (index == i) => (element[i] == target).
`boolean`	`getExpandReservoirConstraints()`	If true, expand the reservoir constraints by creating booleans for all possible precedences between event and encoding the constraint.
`boolean`	`getExpandTableConstraints()`	If true, the positive table constraints are expanded.
`boolean`	`getExploitAllLpSolution()`	If true and the Lp relaxation of the problem has a solution, try to exploit it.
`boolean`	`getExploitBestSolution()`	When branching on a variable, follow the last best solution value.
`boolean`	`getExploitIntegerLpSolution()`	If true and the Lp relaxation of the problem has an integer optimal solution, try to exploit it.
`boolean`	`getExploitObjective()`	When branching an a variable that directly affect the objective, branch on the value that lead to the best objective first.
`boolean`	`getExploitRelaxationSolution()`	When branching on a variable, follow the last best relaxation solution value.
`boolean`	`getFillTightenedDomainsInResponse()`	If true, add information about the derived variable domains to the CpSolverResponse.
`boolean`	`getFindMultipleCores()`	Whether we try to find more independent cores for a given set of assumptions in the core based max-SAT algorithms.
`SatParameters.FPRoundingMethod`	`getFpRounding()`	`optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];`
`double`	`getGlucoseDecayIncrement()`	`optional double glucose_decay_increment = 23 [default = 0.01];`
`int`	`getGlucoseDecayIncrementPeriod()`	`optional int32 glucose_decay_increment_period = 24 [default = 5000];`
`double`	`getGlucoseMaxDecay()`	The activity starts at 0.8 and increment by 0.01 every 5000 conflicts until 0.95.
`int`	`getHintConflictLimit()`	Conflict limit used in the phase that exploit the solution hint.
`SatParameters.Polarity`	`getInitialPolarity()`	`optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];`
`double`	`getInitialVariablesActivity()`	The initial value of the variables activity.
`boolean`	`getInstantiateAllVariables()`	If true, the solver will add a default integer branching strategy to the already defined search strategy.
`int`	`getInterleaveBatchSize()`	`optional int32 interleave_batch_size = 134 [default = 1];`
`boolean`	`getInterleaveSearch()`	Experimental.
`boolean`	`getKeepAllFeasibleSolutionsInPresolve()`	If true, we disable the presolve reductions that remove feasible solutions from the search space.
`int`	`getLinearizationLevel()`	A non-negative level indicating the type of constraints we consider in the LP relaxation.
`boolean`	`getLnsExpandIntervalsInConstraintGraph()`	`optional bool lns_expand_intervals_in_constraint_graph = 184 [default = true];`
`boolean`	`getLnsFocusOnDecisionVariables()`	`optional bool lns_focus_on_decision_variables = 105 [default = false];`
`java.lang.String`	`getLogPrefix()`	Add a prefix to all logs.
`com.google.protobuf.ByteString`	`getLogPrefixBytes()`	Add a prefix to all logs.
`boolean`	`getLogSearchProgress()`	Whether the solver should log the search progress.
`boolean`	`getLogToResponse()`	Log to response proto.
`boolean`	`getLogToStdout()`	Log to stdout.
`int`	`getMaxAllDiffCutSize()`	Cut generator for all diffs can add too many cuts for large all_diff constraints.
`double`	`getMaxClauseActivityValue()`	`optional double max_clause_activity_value = 18 [default = 1e+20];`
`int`	`getMaxConsecutiveInactiveCount()`	If a constraint/cut in LP is not active for that many consecutive OPTIMAL solves, remove it from the LP.
`int`	`getMaxCutRoundsAtLevelZero()`	Max number of time we perform cut generation and resolve the LP at level 0.
`double`	`getMaxDeterministicTime()`	Maximum time allowed in deterministic time to solve a problem.
`int`	`getMaxIntegerRoundingScaling()`	In the integer rounding procedure used for MIR and Gomory cut, the maximum "scaling" we use (must be positive).
`long`	`getMaxMemoryInMb()`	Maximum memory allowed for the whole thread containing the solver.
`long`	`getMaxNumberOfConflicts()`	Maximum number of conflicts allowed to solve a problem.
`int`	`getMaxNumCuts()`	The limit on the number of cuts in our cut pool.
`int`	`getMaxPresolveIterations()`	In case of large reduction in a presolve iteration, we perform multiple presolve iterations.
`SatParameters.MaxSatAssumptionOrder`	`getMaxSatAssumptionOrder()`	`optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];`
`boolean`	`getMaxSatReverseAssumptionOrder()`	If true, adds the assumption in the reverse order of the one defined by max_sat_assumption_order.
`SatParameters.MaxSatStratificationAlgorithm`	`getMaxSatStratification()`	`optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];`
`double`	`getMaxTimeInSeconds()`	Maximum time allowed in seconds to solve a problem.
`double`	`getMaxVariableActivityValue()`	`optional double max_variable_activity_value = 16 [default = 1e+100];`
`double`	`getMergeAtMostOneWorkLimit()`	`optional double merge_at_most_one_work_limit = 146 [default = 100000000];`
`double`	`getMergeNoOverlapWorkLimit()`	During presolve, we use a maximum clique heuristic to merge together no-overlap constraints or at most one constraints.
`SatParameters.ConflictMinimizationAlgorithm`	`getMinimizationAlgorithm()`	`optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];`
`boolean`	`getMinimizeCore()`	Whether we use a simple heuristic to try to minimize an UNSAT core.
`boolean`	`getMinimizeReductionDuringPbResolution()`	A different algorithm during PB resolution.
`int`	`getMinimizeWithPropagationNumDecisions()`	`optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];`
`int`	`getMinimizeWithPropagationRestartPeriod()`	Parameters for an heuristic similar to the one descibed in "An effective learnt clause minimization approach for CDCL Sat Solvers", https://www.ijcai.org/proceedings/2017/0098.pdf For now, we have a somewhat simpler implementation where every x restart we spend y decisions on clause minimization.
`double`	`getMinOrthogonalityForLpConstraints()`	While adding constraints, skip the constraints which have orthogonality less than 'min_orthogonality_for_lp_constraints' with already added constraints during current call.
`boolean`	`getMipAutomaticallyScaleVariables()`	If true, some continuous variable might be automatially scaled.
`double`	`getMipCheckPrecision()`	As explained in mip_precision and mip_max_activity_exponent, we cannot always reach the wanted precision during scaling.
`int`	`getMipMaxActivityExponent()`	To avoid integer overflow, we always force the maximum possible constraint activity (and objective value) according to the initial variable domain to be smaller than 2 to this given power.
`double`	`getMipMaxBound()`	We need to bound the maximum magnitude of the variables for CP-SAT, and that is the bound we use.
`double`	`getMipVarScaling()`	All continuous variable of the problem will be multiplied by this factor.
`double`	`getMipWantedPrecision()`	When scaling constraint with double coefficients to integer coefficients, we will multiply by a power of 2 and round the coefficients.
`java.lang.String`	`getName()`	In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
`com.google.protobuf.ByteString`	`getNameBytes()`	In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
`int`	`getNewConstraintsBatchSize()`	Add that many lazy constraints (or cuts) at once in the LP.
`int`	`getNumConflictsBeforeStrategyChanges()`	After each restart, if the number of conflict since the last strategy change is greater that this, then we increment a "strategy_counter" that can be use to change the search strategy used by the following restarts.
`int`	`getNumSearchWorkers()`	Specify the number of parallel workers to use during search.
`boolean`	`getOnlyAddCutsAtLevelZero()`	For the cut that can be generated at any level, this control if we only try to generate them at the root node.
`boolean`	`getOptimizeWithCore()`	The default optimization method is a simple "linear scan", each time trying to find a better solution than the previous one.
`boolean`	`getOptimizeWithMaxHs()`	This has no effect if optimize_with_core is false.
`com.google.protobuf.Parser<SatParameters>`	`getParserForType()`
`int`	`getPbCleanupIncrement()`	Same as for the clauses, but for the learned pseudo-Boolean constraints.
`double`	`getPbCleanupRatio()`	`optional double pb_cleanup_ratio = 47 [default = 0.5];`
`boolean`	`getPermutePresolveConstraintOrder()`	`optional bool permute_presolve_constraint_order = 179 [default = false];`
`boolean`	`getPermuteVariableRandomly()`	This is mainly here to test the solver variability.
`int`	`getPolarityRephaseIncrement()`	If non-zero, then we change the polarity heuristic after that many number of conflicts in an arithmetically increasing fashion.
`boolean`	`getPolishLpSolution()`	Whether we try to do a few degenerate iteration at the end of an LP solve to minimize the fractionality of the integer variable in the basis.
`SatParameters.VariableOrder`	`getPreferredVariableOrder()`	`optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];`
`boolean`	`getPresolveBlockedClause()`	Whether we use an heuristic to detect some basic case of blocked clause in the SAT presolve.
`int`	`getPresolveBvaThreshold()`	Apply Bounded Variable Addition (BVA) if the number of clauses is reduced by stricly more than this threshold.
`int`	`getPresolveBveClauseWeight()`	During presolve, we apply BVE only if this weight times the number of clauses plus the number of clause literals is not increased.
`int`	`getPresolveBveThreshold()`	During presolve, only try to perform the bounded variable elimination (BVE) of a variable x if the number of occurrences of x times the number of occurrences of not(x) is not greater than this parameter.
`boolean`	`getPresolveExtractIntegerEnforcement()`	If true, we will extract from linear constraints, enforcement literals of the form "integer variable at bound => simplified constraint".
`double`	`getPresolveProbingDeterministicTimeLimit()`	The maximum "deterministic" time limit to spend in probing.
`int`	`getPresolveSubstitutionLevel()`	How much substitution (also called free variable aggregation in MIP litterature) should we perform at presolve.
`boolean`	`getPresolveUseBva()`	Whether or not we use Bounded Variable Addition (BVA) in the presolve.
`long`	`getProbingPeriodAtRoot()`	If set at zero (the default), it is disabled.
`long`	`getPseudoCostReliabilityThreshold()`	The solver ignores the pseudo costs of variables with number of recordings less than this threshold.
`double`	`getRandomBranchesRatio()`	A number between 0 and 1 that indicates the proportion of branching variables that are selected randomly instead of choosing the first variable from the given variable_ordering strategy.
`boolean`	`getRandomizeSearch()`	Randomize fixed search.
`double`	`getRandomPolarityRatio()`	The proportion of polarity chosen at random.
`int`	`getRandomSeed()`	At the beginning of each solve, the random number generator used in some part of the solver is reinitialized to this seed.
`boolean`	`getReduceMemoryUsageInInterleaveMode()`	Temporary parameter until the memory usage is more optimized.
`double`	`getRelativeGapLimit()`	`optional double relative_gap_limit = 160 [default = 0];`
`boolean`	`getRepairHint()`	If true, the solver tries to repair the solution given in the hint.
`SatParameters.RestartAlgorithm`	`getRestartAlgorithms(int index)`	The restart strategies will change each time the strategy_counter is increased.
`int`	`getRestartAlgorithmsCount()`	The restart strategies will change each time the strategy_counter is increased.
`java.util.List<SatParameters.RestartAlgorithm>`	`getRestartAlgorithmsList()`	The restart strategies will change each time the strategy_counter is increased.
`double`	`getRestartDlAverageRatio()`	In the moving average restart algorithms, a restart is triggered if the window average times this ratio is greater that the global average.
`double`	`getRestartLbdAverageRatio()`	`optional double restart_lbd_average_ratio = 71 [default = 1];`
`int`	`getRestartPeriod()`	Restart period for the FIXED_RESTART strategy.
`int`	`getRestartRunningWindowSize()`	Size of the window for the moving average restarts.
`SatParameters.SearchBranching`	`getSearchBranching()`	`optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];`
`long`	`getSearchRandomizationTolerance()`	Search randomization will collect equivalent 'max valued' variables, and pick one randomly.
`int`	`getSerializedSize()`
`boolean`	`getShareLevelZeroBounds()`	Allows sharing of the bounds of modified variables at level 0.
`boolean`	`getShareObjectiveBounds()`	Allows objective sharing between workers.
`boolean`	`getStopAfterFirstSolution()`	For an optimization problem, stop the solver as soon as we have a solution.
`boolean`	`getStopAfterPresolve()`	Mainly used when improving the presolver.
`double`	`getStrategyChangeIncreaseRatio()`	The parameter num_conflicts_before_strategy_changes is increased by that much after each strategy change.
`boolean`	`getSubsumptionDuringConflictAnalysis()`	At a really low cost, during the 1-UIP conflict computation, it is easy to detect if some of the involved reasons are subsumed by the current conflict.
`int`	`getSymmetryLevel()`	Whether we try to automatically detect the symmetries in a model and exploit them.
`boolean`	`getTreatBinaryClausesSeparately()`	If true, the binary clauses are treated separately from the others.
`com.google.protobuf.UnknownFieldSet`	`getUnknownFields()`
`boolean`	`getUseAbslRandom()`	`optional bool use_absl_random = 180 [default = false];`
`boolean`	`getUseBlockingRestart()`	Block a moving restart algorithm if the trail size of the current conflict is greater than the multiplier times the moving average of the trail size at the previous conflicts.
`boolean`	`getUseBranchingInLp()`	If true, the solver attemts to generate more info inside lp propagator by branching on some variables if certain criteria are met during the search tree exploration.
`boolean`	`getUseCombinedNoOverlap()`	This can be beneficial if there is a lot of no-overlap constraints but a relatively low number of different intervals in the problem.
`boolean`	`getUseDisjunctiveConstraintInCumulativeConstraint()`	When this is true, the cumulative constraint is reinforced with propagators from the disjunctive constraint to improve the inference on a set of tasks that are disjunctive at the root of the problem.
`boolean`	`getUseErwaHeuristic()`	Whether we use the ERWA (Exponential Recency Weighted Average) heuristic as described in "Learning Rate Based Branching Heuristic for SAT solvers", J.H.Liang, V.
`boolean`	`getUseExactLpReason()`	The solver usually exploit the LP relaxation of a model.
`boolean`	`getUseFeasibilityPump()`	Adds a feasibility pump subsolver along with lns subsolvers.
`boolean`	`getUseImpliedBounds()`	Stores and exploits "implied-bounds" in the solver.
`boolean`	`getUseLnsOnly()`	LNS parameters.
`boolean`	`getUseOptimizationHints()`	For an optimization problem, whether we follow some hints in order to find a better first solution.
`boolean`	`getUseOptionalVariables()`	If true, we automatically detect variables whose constraint are always enforced by the same literal and we mark them as optional.
`boolean`	`getUseOverloadCheckerInCumulativeConstraint()`	When this is true, the cumulative constraint is reinforced with overload checking, i.e., an additional level of reasoning based on energy.
`boolean`	`getUsePbResolution()`	Whether to use pseudo-Boolean resolution to analyze a conflict.
`boolean`	`getUsePhaseSaving()`	If this is true, then the polarity of a variable will be the last value it was assigned to, or its default polarity if it was never assigned since the call to ResetDecisionHeuristic().
`boolean`	`getUsePrecedencesInDisjunctiveConstraint()`	When this is true, then a disjunctive constraint will try to use the precedence relations between time intervals to propagate their bounds further.
`boolean`	`getUseProbingSearch()`	If true, search will continuously probe Boolean variables, and integer variable bounds.
`boolean`	`getUseRelaxationLns()`	Turns on a lns worker which solves relaxed version of the original problem by removing constraints from the problem in order to get better bounds.
`boolean`	`getUseRinsLns()`	Turns on relaxation induced neighborhood generator.
`boolean`	`getUseSatInprocessing()`	`optional bool use_sat_inprocessing = 163 [default = false];`
`boolean`	`getUseTimetableEdgeFindingInCumulativeConstraint()`	When this is true, the cumulative constraint is reinforced with timetable edge finding, i.e., an additional level of reasoning based on the conjunction of energy and mandatory parts.
`double`	`getVariableActivityDecay()`	Each time a conflict is found, the activities of some variables are increased by one.
`boolean`	`hasAbsoluteGapLimit()`	Stop the search when the gap between the best feasible objective (O) and our best objective bound (B) is smaller than a limit.
`boolean`	`hasAddCgCuts()`	Whether we generate and add Chvatal-Gomory cuts to the LP at root node.
`boolean`	`hasAddCliqueCuts()`	Whether we generate clique cuts from the binary implication graph.
`boolean`	`hasAddKnapsackCuts()`	Whether we generate knapsack cuts.
`boolean`	`hasAddLinMaxCuts()`	For the lin max constraints, generates the cuts described in "Strong mixed-integer programming formulations for trained neural networks" by Ross Anderson et.
`boolean`	`hasAddLpConstraintsLazily()`	If true, we start by an empty LP, and only add constraints not satisfied by the current LP solution batch by batch.
`boolean`	`hasAddMirCuts()`	Whether we generate MIR cuts at root node.
`boolean`	`hasAddZeroHalfCuts()`	Whether we generate Zero-Half cuts at root node.
`boolean`	`hasAlsoBumpVariablesInConflictReasons()`	When this is true, then the variables that appear in any of the reason of the variables in a conflict have their activity bumped.
`boolean`	`hasAutoDetectGreaterThanAtLeastOneOf()`	If true, then the precedences propagator try to detect for each variable if it has a set of "optional incoming arc" for which at least one of them is present.
`boolean`	`hasBinaryMinimizationAlgorithm()`	`optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];`
`boolean`	`hasBinarySearchNumConflicts()`	If non-negative, perform a binary search on the objective variable in order to find an [min, max] interval outside of which the solver proved unsat/sat under this amount of conflict.
`boolean`	`hasBlockingRestartMultiplier()`	`optional double blocking_restart_multiplier = 66 [default = 1.4];`
`boolean`	`hasBlockingRestartWindowSize()`	`optional int32 blocking_restart_window_size = 65 [default = 5000];`
`boolean`	`hasBooleanEncodingLevel()`	A non-negative level indicating how much we should try to fully encode Integer variables as Boolean.
`boolean`	`hasCatchSigintSignal()`	Indicates if the CP-SAT layer should catch Control-C (SIGINT) signals when calling solve.
`boolean`	`hasClauseActivityDecay()`	Clause activity parameters (same effect as the one on the variables).
`boolean`	`hasClauseCleanupLbdBound()`	All the clauses with a LBD (literal blocks distance) lower or equal to this parameters will always be kept.
`boolean`	`hasClauseCleanupOrdering()`	`optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];`
`boolean`	`hasClauseCleanupPeriod()`	Trigger a cleanup when this number of "deletable" clauses is learned.
`boolean`	`hasClauseCleanupProtection()`	`optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];`
`boolean`	`hasClauseCleanupTarget()`	During a cleanup, we will always keep that number of "deletable" clauses.
`boolean`	`hasConvertIntervals()`	Temporary flag util the feature is more mature.
`boolean`	`hasCountAssumptionLevelsInLbd()`	Whether or not the assumption levels are taken into account during the LBD computation.
`boolean`	`hasCoverOptimization()`	If true, when the max-sat algo find a core, we compute the minimal number of literals in the core that needs to be true to have a feasible solution.
`boolean`	`hasCpModelMaxNumPresolveOperations()`	If positive, try to stop just after that many presolve rules have been applied.
`boolean`	`hasCpModelPostsolveWithFullSolver()`	Advanced usage.
`boolean`	`hasCpModelPresolve()`	Whether we presolve the cp_model before solving it.
`boolean`	`hasCpModelProbingLevel()`	How much effort do we spend on probing.
`boolean`	`hasCpModelUseSatPresolve()`	Whether we also use the sat presolve when cp_model_presolve is true.
`boolean`	`hasCutActiveCountDecay()`	`optional double cut_active_count_decay = 156 [default = 0.8];`
`boolean`	`hasCutCleanupTarget()`	Target number of constraints to remove during cleanup.
`boolean`	`hasCutMaxActiveCountValue()`	These parameters are similar to sat clause management activity parameters.
`boolean`	`hasDefaultRestartAlgorithms()`	`optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];`
`boolean`	`hasDisableConstraintExpansion()`	If true, it disable all constraint expansion.
`boolean`	`hasDiversifyLnsParams()`	If true, registers more lns subsolvers with different parameters.
`boolean`	`hasEnumerateAllSolutions()`	Whether we enumerate all solutions of a problem without objective.
`boolean`	`hasExpandAlldiffConstraints()`	If true, expand all_different constraints that are not permutations.
`boolean`	`hasExpandAutomatonConstraints()`	If true, the automaton constraints are expanded.
`boolean`	`hasExpandElementConstraints()`	If true, the element constraints are expanded into many linear constraints of the form (index == i) => (element[i] == target).
`boolean`	`hasExpandReservoirConstraints()`	If true, expand the reservoir constraints by creating booleans for all possible precedences between event and encoding the constraint.
`boolean`	`hasExpandTableConstraints()`	If true, the positive table constraints are expanded.
`boolean`	`hasExploitAllLpSolution()`	If true and the Lp relaxation of the problem has a solution, try to exploit it.
`boolean`	`hasExploitBestSolution()`	When branching on a variable, follow the last best solution value.
`boolean`	`hasExploitIntegerLpSolution()`	If true and the Lp relaxation of the problem has an integer optimal solution, try to exploit it.
`boolean`	`hasExploitObjective()`	When branching an a variable that directly affect the objective, branch on the value that lead to the best objective first.
`boolean`	`hasExploitRelaxationSolution()`	When branching on a variable, follow the last best relaxation solution value.
`boolean`	`hasFillTightenedDomainsInResponse()`	If true, add information about the derived variable domains to the CpSolverResponse.
`boolean`	`hasFindMultipleCores()`	Whether we try to find more independent cores for a given set of assumptions in the core based max-SAT algorithms.
`boolean`	`hasFpRounding()`	`optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];`
`boolean`	`hasGlucoseDecayIncrement()`	`optional double glucose_decay_increment = 23 [default = 0.01];`
`boolean`	`hasGlucoseDecayIncrementPeriod()`	`optional int32 glucose_decay_increment_period = 24 [default = 5000];`
`boolean`	`hasGlucoseMaxDecay()`	The activity starts at 0.8 and increment by 0.01 every 5000 conflicts until 0.95.
`int`	`hashCode()`
`boolean`	`hasHintConflictLimit()`	Conflict limit used in the phase that exploit the solution hint.
`boolean`	`hasInitialPolarity()`	`optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];`
`boolean`	`hasInitialVariablesActivity()`	The initial value of the variables activity.
`boolean`	`hasInstantiateAllVariables()`	If true, the solver will add a default integer branching strategy to the already defined search strategy.
`boolean`	`hasInterleaveBatchSize()`	`optional int32 interleave_batch_size = 134 [default = 1];`
`boolean`	`hasInterleaveSearch()`	Experimental.
`boolean`	`hasKeepAllFeasibleSolutionsInPresolve()`	If true, we disable the presolve reductions that remove feasible solutions from the search space.
`boolean`	`hasLinearizationLevel()`	A non-negative level indicating the type of constraints we consider in the LP relaxation.
`boolean`	`hasLnsExpandIntervalsInConstraintGraph()`	`optional bool lns_expand_intervals_in_constraint_graph = 184 [default = true];`
`boolean`	`hasLnsFocusOnDecisionVariables()`	`optional bool lns_focus_on_decision_variables = 105 [default = false];`
`boolean`	`hasLogPrefix()`	Add a prefix to all logs.
`boolean`	`hasLogSearchProgress()`	Whether the solver should log the search progress.
`boolean`	`hasLogToResponse()`	Log to response proto.
`boolean`	`hasLogToStdout()`	Log to stdout.
`boolean`	`hasMaxAllDiffCutSize()`	Cut generator for all diffs can add too many cuts for large all_diff constraints.
`boolean`	`hasMaxClauseActivityValue()`	`optional double max_clause_activity_value = 18 [default = 1e+20];`
`boolean`	`hasMaxConsecutiveInactiveCount()`	If a constraint/cut in LP is not active for that many consecutive OPTIMAL solves, remove it from the LP.
`boolean`	`hasMaxCutRoundsAtLevelZero()`	Max number of time we perform cut generation and resolve the LP at level 0.
`boolean`	`hasMaxDeterministicTime()`	Maximum time allowed in deterministic time to solve a problem.
`boolean`	`hasMaxIntegerRoundingScaling()`	In the integer rounding procedure used for MIR and Gomory cut, the maximum "scaling" we use (must be positive).
`boolean`	`hasMaxMemoryInMb()`	Maximum memory allowed for the whole thread containing the solver.
`boolean`	`hasMaxNumberOfConflicts()`	Maximum number of conflicts allowed to solve a problem.
`boolean`	`hasMaxNumCuts()`	The limit on the number of cuts in our cut pool.
`boolean`	`hasMaxPresolveIterations()`	In case of large reduction in a presolve iteration, we perform multiple presolve iterations.
`boolean`	`hasMaxSatAssumptionOrder()`	`optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];`
`boolean`	`hasMaxSatReverseAssumptionOrder()`	If true, adds the assumption in the reverse order of the one defined by max_sat_assumption_order.
`boolean`	`hasMaxSatStratification()`	`optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];`
`boolean`	`hasMaxTimeInSeconds()`	Maximum time allowed in seconds to solve a problem.
`boolean`	`hasMaxVariableActivityValue()`	`optional double max_variable_activity_value = 16 [default = 1e+100];`
`boolean`	`hasMergeAtMostOneWorkLimit()`	`optional double merge_at_most_one_work_limit = 146 [default = 100000000];`
`boolean`	`hasMergeNoOverlapWorkLimit()`	During presolve, we use a maximum clique heuristic to merge together no-overlap constraints or at most one constraints.
`boolean`	`hasMinimizationAlgorithm()`	`optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];`
`boolean`	`hasMinimizeCore()`	Whether we use a simple heuristic to try to minimize an UNSAT core.
`boolean`	`hasMinimizeReductionDuringPbResolution()`	A different algorithm during PB resolution.
`boolean`	`hasMinimizeWithPropagationNumDecisions()`	`optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];`
`boolean`	`hasMinimizeWithPropagationRestartPeriod()`	Parameters for an heuristic similar to the one descibed in "An effective learnt clause minimization approach for CDCL Sat Solvers", https://www.ijcai.org/proceedings/2017/0098.pdf For now, we have a somewhat simpler implementation where every x restart we spend y decisions on clause minimization.
`boolean`	`hasMinOrthogonalityForLpConstraints()`	While adding constraints, skip the constraints which have orthogonality less than 'min_orthogonality_for_lp_constraints' with already added constraints during current call.
`boolean`	`hasMipAutomaticallyScaleVariables()`	If true, some continuous variable might be automatially scaled.
`boolean`	`hasMipCheckPrecision()`	As explained in mip_precision and mip_max_activity_exponent, we cannot always reach the wanted precision during scaling.
`boolean`	`hasMipMaxActivityExponent()`	To avoid integer overflow, we always force the maximum possible constraint activity (and objective value) according to the initial variable domain to be smaller than 2 to this given power.
`boolean`	`hasMipMaxBound()`	We need to bound the maximum magnitude of the variables for CP-SAT, and that is the bound we use.
`boolean`	`hasMipVarScaling()`	All continuous variable of the problem will be multiplied by this factor.
`boolean`	`hasMipWantedPrecision()`	When scaling constraint with double coefficients to integer coefficients, we will multiply by a power of 2 and round the coefficients.
`boolean`	`hasName()`	In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
`boolean`	`hasNewConstraintsBatchSize()`	Add that many lazy constraints (or cuts) at once in the LP.
`boolean`	`hasNumConflictsBeforeStrategyChanges()`	After each restart, if the number of conflict since the last strategy change is greater that this, then we increment a "strategy_counter" that can be use to change the search strategy used by the following restarts.
`boolean`	`hasNumSearchWorkers()`	Specify the number of parallel workers to use during search.
`boolean`	`hasOnlyAddCutsAtLevelZero()`	For the cut that can be generated at any level, this control if we only try to generate them at the root node.
`boolean`	`hasOptimizeWithCore()`	The default optimization method is a simple "linear scan", each time trying to find a better solution than the previous one.
`boolean`	`hasOptimizeWithMaxHs()`	This has no effect if optimize_with_core is false.
`boolean`	`hasPbCleanupIncrement()`	Same as for the clauses, but for the learned pseudo-Boolean constraints.
`boolean`	`hasPbCleanupRatio()`	`optional double pb_cleanup_ratio = 47 [default = 0.5];`
`boolean`	`hasPermutePresolveConstraintOrder()`	`optional bool permute_presolve_constraint_order = 179 [default = false];`
`boolean`	`hasPermuteVariableRandomly()`	This is mainly here to test the solver variability.
`boolean`	`hasPolarityRephaseIncrement()`	If non-zero, then we change the polarity heuristic after that many number of conflicts in an arithmetically increasing fashion.
`boolean`	`hasPolishLpSolution()`	Whether we try to do a few degenerate iteration at the end of an LP solve to minimize the fractionality of the integer variable in the basis.
`boolean`	`hasPreferredVariableOrder()`	`optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];`
`boolean`	`hasPresolveBlockedClause()`	Whether we use an heuristic to detect some basic case of blocked clause in the SAT presolve.
`boolean`	`hasPresolveBvaThreshold()`	Apply Bounded Variable Addition (BVA) if the number of clauses is reduced by stricly more than this threshold.
`boolean`	`hasPresolveBveClauseWeight()`	During presolve, we apply BVE only if this weight times the number of clauses plus the number of clause literals is not increased.
`boolean`	`hasPresolveBveThreshold()`	During presolve, only try to perform the bounded variable elimination (BVE) of a variable x if the number of occurrences of x times the number of occurrences of not(x) is not greater than this parameter.
`boolean`	`hasPresolveExtractIntegerEnforcement()`	If true, we will extract from linear constraints, enforcement literals of the form "integer variable at bound => simplified constraint".
`boolean`	`hasPresolveProbingDeterministicTimeLimit()`	The maximum "deterministic" time limit to spend in probing.
`boolean`	`hasPresolveSubstitutionLevel()`	How much substitution (also called free variable aggregation in MIP litterature) should we perform at presolve.
`boolean`	`hasPresolveUseBva()`	Whether or not we use Bounded Variable Addition (BVA) in the presolve.
`boolean`	`hasProbingPeriodAtRoot()`	If set at zero (the default), it is disabled.
`boolean`	`hasPseudoCostReliabilityThreshold()`	The solver ignores the pseudo costs of variables with number of recordings less than this threshold.
`boolean`	`hasRandomBranchesRatio()`	A number between 0 and 1 that indicates the proportion of branching variables that are selected randomly instead of choosing the first variable from the given variable_ordering strategy.
`boolean`	`hasRandomizeSearch()`	Randomize fixed search.
`boolean`	`hasRandomPolarityRatio()`	The proportion of polarity chosen at random.
`boolean`	`hasRandomSeed()`	At the beginning of each solve, the random number generator used in some part of the solver is reinitialized to this seed.
`boolean`	`hasReduceMemoryUsageInInterleaveMode()`	Temporary parameter until the memory usage is more optimized.
`boolean`	`hasRelativeGapLimit()`	`optional double relative_gap_limit = 160 [default = 0];`
`boolean`	`hasRepairHint()`	If true, the solver tries to repair the solution given in the hint.
`boolean`	`hasRestartDlAverageRatio()`	In the moving average restart algorithms, a restart is triggered if the window average times this ratio is greater that the global average.
`boolean`	`hasRestartLbdAverageRatio()`	`optional double restart_lbd_average_ratio = 71 [default = 1];`
`boolean`	`hasRestartPeriod()`	Restart period for the FIXED_RESTART strategy.
`boolean`	`hasRestartRunningWindowSize()`	Size of the window for the moving average restarts.
`boolean`	`hasSearchBranching()`	`optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];`
`boolean`	`hasSearchRandomizationTolerance()`	Search randomization will collect equivalent 'max valued' variables, and pick one randomly.
`boolean`	`hasShareLevelZeroBounds()`	Allows sharing of the bounds of modified variables at level 0.
`boolean`	`hasShareObjectiveBounds()`	Allows objective sharing between workers.
`boolean`	`hasStopAfterFirstSolution()`	For an optimization problem, stop the solver as soon as we have a solution.
`boolean`	`hasStopAfterPresolve()`	Mainly used when improving the presolver.
`boolean`	`hasStrategyChangeIncreaseRatio()`	The parameter num_conflicts_before_strategy_changes is increased by that much after each strategy change.
`boolean`	`hasSubsumptionDuringConflictAnalysis()`	At a really low cost, during the 1-UIP conflict computation, it is easy to detect if some of the involved reasons are subsumed by the current conflict.
`boolean`	`hasSymmetryLevel()`	Whether we try to automatically detect the symmetries in a model and exploit them.
`boolean`	`hasTreatBinaryClausesSeparately()`	If true, the binary clauses are treated separately from the others.
`boolean`	`hasUseAbslRandom()`	`optional bool use_absl_random = 180 [default = false];`
`boolean`	`hasUseBlockingRestart()`	Block a moving restart algorithm if the trail size of the current conflict is greater than the multiplier times the moving average of the trail size at the previous conflicts.
`boolean`	`hasUseBranchingInLp()`	If true, the solver attemts to generate more info inside lp propagator by branching on some variables if certain criteria are met during the search tree exploration.
`boolean`	`hasUseCombinedNoOverlap()`	This can be beneficial if there is a lot of no-overlap constraints but a relatively low number of different intervals in the problem.
`boolean`	`hasUseDisjunctiveConstraintInCumulativeConstraint()`	When this is true, the cumulative constraint is reinforced with propagators from the disjunctive constraint to improve the inference on a set of tasks that are disjunctive at the root of the problem.
`boolean`	`hasUseErwaHeuristic()`	Whether we use the ERWA (Exponential Recency Weighted Average) heuristic as described in "Learning Rate Based Branching Heuristic for SAT solvers", J.H.Liang, V.
`boolean`	`hasUseExactLpReason()`	The solver usually exploit the LP relaxation of a model.
`boolean`	`hasUseFeasibilityPump()`	Adds a feasibility pump subsolver along with lns subsolvers.
`boolean`	`hasUseImpliedBounds()`	Stores and exploits "implied-bounds" in the solver.
`boolean`	`hasUseLnsOnly()`	LNS parameters.
`boolean`	`hasUseOptimizationHints()`	For an optimization problem, whether we follow some hints in order to find a better first solution.
`boolean`	`hasUseOptionalVariables()`	If true, we automatically detect variables whose constraint are always enforced by the same literal and we mark them as optional.
`boolean`	`hasUseOverloadCheckerInCumulativeConstraint()`	When this is true, the cumulative constraint is reinforced with overload checking, i.e., an additional level of reasoning based on energy.
`boolean`	`hasUsePbResolution()`	Whether to use pseudo-Boolean resolution to analyze a conflict.
`boolean`	`hasUsePhaseSaving()`	If this is true, then the polarity of a variable will be the last value it was assigned to, or its default polarity if it was never assigned since the call to ResetDecisionHeuristic().
`boolean`	`hasUsePrecedencesInDisjunctiveConstraint()`	When this is true, then a disjunctive constraint will try to use the precedence relations between time intervals to propagate their bounds further.
`boolean`	`hasUseProbingSearch()`	If true, search will continuously probe Boolean variables, and integer variable bounds.
`boolean`	`hasUseRelaxationLns()`	Turns on a lns worker which solves relaxed version of the original problem by removing constraints from the problem in order to get better bounds.
`boolean`	`hasUseRinsLns()`	Turns on relaxation induced neighborhood generator.
`boolean`	`hasUseSatInprocessing()`	`optional bool use_sat_inprocessing = 163 [default = false];`
`boolean`	`hasUseTimetableEdgeFindingInCumulativeConstraint()`	When this is true, the cumulative constraint is reinforced with timetable edge finding, i.e., an additional level of reasoning based on the conjunction of energy and mandatory parts.
`boolean`	`hasVariableActivityDecay()`	Each time a conflict is found, the activities of some variables are increased by one.
`protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable`	`internalGetFieldAccessorTable()`
`boolean`	`isInitialized()`
`static SatParameters.Builder`	`newBuilder()`
`static SatParameters.Builder`	`newBuilder(SatParameters prototype)`
`SatParameters.Builder`	`newBuilderForType()`
`protected SatParameters.Builder`	`newBuilderForType(com.google.protobuf.GeneratedMessageV3.BuilderParent parent)`
`protected java.lang.Object`	`newInstance(com.google.protobuf.GeneratedMessageV3.UnusedPrivateParameter unused)`
`static SatParameters`	`parseDelimitedFrom(java.io.InputStream input)`
`static SatParameters`	`parseDelimitedFrom(java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`
`static SatParameters`	`parseFrom(byte[] data)`
`static SatParameters`	`parseFrom(byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`
`static SatParameters`	`parseFrom(com.google.protobuf.ByteString data)`
`static SatParameters`	`parseFrom(com.google.protobuf.ByteString data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`
`static SatParameters`	`parseFrom(com.google.protobuf.CodedInputStream input)`
`static SatParameters`	`parseFrom(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`
`static SatParameters`	`parseFrom(java.io.InputStream input)`
`static SatParameters`	`parseFrom(java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`
`static SatParameters`	`parseFrom(java.nio.ByteBuffer data)`
`static SatParameters`	`parseFrom(java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)`
`static com.google.protobuf.Parser<SatParameters>`	`parser()`
`SatParameters.Builder`	`toBuilder()`
`void`	`writeTo(com.google.protobuf.CodedOutputStream output)`

Methods inherited from class com.google.protobuf.GeneratedMessageV3

canUseUnsafe, computeStringSize, computeStringSizeNoTag, emptyBooleanList, emptyDoubleList, emptyFloatList, emptyIntList, emptyLongList, getAllFields, getDescriptorForType, getField, getOneofFieldDescriptor, getRepeatedField, getRepeatedFieldCount, hasField, hasOneof, internalGetMapField, makeExtensionsImmutable, mergeFromAndMakeImmutableInternal, mutableCopy, mutableCopy, mutableCopy, mutableCopy, mutableCopy, newBooleanList, newBuilderForType, newDoubleList, newFloatList, newIntList, newLongList, parseDelimitedWithIOException, parseDelimitedWithIOException, parseUnknownField, parseUnknownFieldProto3, parseWithIOException, parseWithIOException, parseWithIOException, parseWithIOException, serializeBooleanMapTo, serializeIntegerMapTo, serializeLongMapTo, serializeStringMapTo, writeReplace, writeString, writeStringNoTag

Methods inherited from class com.google.protobuf.AbstractMessage

findInitializationErrors, getInitializationErrorString, hashBoolean, hashEnum, hashEnumList, hashFields, hashLong, toString

Methods inherited from class com.google.protobuf.AbstractMessageLite

addAll, addAll, checkByteStringIsUtf8, toByteArray, toByteString, writeDelimitedTo, writeTo

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.google.protobuf.MessageLite

toByteArray, toByteString, writeDelimitedTo, writeTo

Methods inherited from interface com.google.protobuf.MessageOrBuilder

findInitializationErrors, getAllFields, getDescriptorForType, getField, getInitializationErrorString, getOneofFieldDescriptor, getRepeatedField, getRepeatedFieldCount, hasField, hasOneof

Field Details
- NAME_FIELD_NUMBER
  
  public static final int NAME_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- PREFERRED_VARIABLE_ORDER_FIELD_NUMBER
  
  public static final int PREFERRED_VARIABLE_ORDER_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- INITIAL_POLARITY_FIELD_NUMBER
  
  public static final int INITIAL_POLARITY_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_PHASE_SAVING_FIELD_NUMBER
  
  public static final int USE_PHASE_SAVING_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- POLARITY_REPHASE_INCREMENT_FIELD_NUMBER
  
  public static final int POLARITY_REPHASE_INCREMENT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- RANDOM_POLARITY_RATIO_FIELD_NUMBER
  
  public static final int RANDOM_POLARITY_RATIO_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- RANDOM_BRANCHES_RATIO_FIELD_NUMBER
  
  public static final int RANDOM_BRANCHES_RATIO_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_ERWA_HEURISTIC_FIELD_NUMBER
  
  public static final int USE_ERWA_HEURISTIC_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- INITIAL_VARIABLES_ACTIVITY_FIELD_NUMBER
  
  public static final int INITIAL_VARIABLES_ACTIVITY_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- ALSO_BUMP_VARIABLES_IN_CONFLICT_REASONS_FIELD_NUMBER
  
  public static final int ALSO_BUMP_VARIABLES_IN_CONFLICT_REASONS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MINIMIZATION_ALGORITHM_FIELD_NUMBER
  
  public static final int MINIMIZATION_ALGORITHM_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- BINARY_MINIMIZATION_ALGORITHM_FIELD_NUMBER
  
  public static final int BINARY_MINIMIZATION_ALGORITHM_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- SUBSUMPTION_DURING_CONFLICT_ANALYSIS_FIELD_NUMBER
  
  public static final int SUBSUMPTION_DURING_CONFLICT_ANALYSIS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- CLAUSE_CLEANUP_PERIOD_FIELD_NUMBER
  
  public static final int CLAUSE_CLEANUP_PERIOD_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- CLAUSE_CLEANUP_TARGET_FIELD_NUMBER
  
  public static final int CLAUSE_CLEANUP_TARGET_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- CLAUSE_CLEANUP_PROTECTION_FIELD_NUMBER
  
  public static final int CLAUSE_CLEANUP_PROTECTION_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- CLAUSE_CLEANUP_LBD_BOUND_FIELD_NUMBER
  
  public static final int CLAUSE_CLEANUP_LBD_BOUND_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- CLAUSE_CLEANUP_ORDERING_FIELD_NUMBER
  
  public static final int CLAUSE_CLEANUP_ORDERING_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- PB_CLEANUP_INCREMENT_FIELD_NUMBER
  
  public static final int PB_CLEANUP_INCREMENT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- PB_CLEANUP_RATIO_FIELD_NUMBER
  
  public static final int PB_CLEANUP_RATIO_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MINIMIZE_WITH_PROPAGATION_RESTART_PERIOD_FIELD_NUMBER
  
  public static final int MINIMIZE_WITH_PROPAGATION_RESTART_PERIOD_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MINIMIZE_WITH_PROPAGATION_NUM_DECISIONS_FIELD_NUMBER
  
  public static final int MINIMIZE_WITH_PROPAGATION_NUM_DECISIONS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- VARIABLE_ACTIVITY_DECAY_FIELD_NUMBER
  
  public static final int VARIABLE_ACTIVITY_DECAY_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MAX_VARIABLE_ACTIVITY_VALUE_FIELD_NUMBER
  
  public static final int MAX_VARIABLE_ACTIVITY_VALUE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- GLUCOSE_MAX_DECAY_FIELD_NUMBER
  
  public static final int GLUCOSE_MAX_DECAY_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- GLUCOSE_DECAY_INCREMENT_FIELD_NUMBER
  
  public static final int GLUCOSE_DECAY_INCREMENT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- GLUCOSE_DECAY_INCREMENT_PERIOD_FIELD_NUMBER
  
  public static final int GLUCOSE_DECAY_INCREMENT_PERIOD_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- CLAUSE_ACTIVITY_DECAY_FIELD_NUMBER
  
  public static final int CLAUSE_ACTIVITY_DECAY_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MAX_CLAUSE_ACTIVITY_VALUE_FIELD_NUMBER
  
  public static final int MAX_CLAUSE_ACTIVITY_VALUE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- RESTART_ALGORITHMS_FIELD_NUMBER
  
  public static final int RESTART_ALGORITHMS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- DEFAULT_RESTART_ALGORITHMS_FIELD_NUMBER
  
  public static final int DEFAULT_RESTART_ALGORITHMS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- RESTART_PERIOD_FIELD_NUMBER
  
  public static final int RESTART_PERIOD_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- RESTART_RUNNING_WINDOW_SIZE_FIELD_NUMBER
  
  public static final int RESTART_RUNNING_WINDOW_SIZE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- RESTART_DL_AVERAGE_RATIO_FIELD_NUMBER
  
  public static final int RESTART_DL_AVERAGE_RATIO_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- RESTART_LBD_AVERAGE_RATIO_FIELD_NUMBER
  
  public static final int RESTART_LBD_AVERAGE_RATIO_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_BLOCKING_RESTART_FIELD_NUMBER
  
  public static final int USE_BLOCKING_RESTART_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- BLOCKING_RESTART_WINDOW_SIZE_FIELD_NUMBER
  
  public static final int BLOCKING_RESTART_WINDOW_SIZE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- BLOCKING_RESTART_MULTIPLIER_FIELD_NUMBER
  
  public static final int BLOCKING_RESTART_MULTIPLIER_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- NUM_CONFLICTS_BEFORE_STRATEGY_CHANGES_FIELD_NUMBER
  
  public static final int NUM_CONFLICTS_BEFORE_STRATEGY_CHANGES_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- STRATEGY_CHANGE_INCREASE_RATIO_FIELD_NUMBER
  
  public static final int STRATEGY_CHANGE_INCREASE_RATIO_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MAX_TIME_IN_SECONDS_FIELD_NUMBER
  
  public static final int MAX_TIME_IN_SECONDS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MAX_DETERMINISTIC_TIME_FIELD_NUMBER
  
  public static final int MAX_DETERMINISTIC_TIME_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MAX_NUMBER_OF_CONFLICTS_FIELD_NUMBER
  
  public static final int MAX_NUMBER_OF_CONFLICTS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MAX_MEMORY_IN_MB_FIELD_NUMBER
  
  public static final int MAX_MEMORY_IN_MB_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- ABSOLUTE_GAP_LIMIT_FIELD_NUMBER
  
  public static final int ABSOLUTE_GAP_LIMIT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- RELATIVE_GAP_LIMIT_FIELD_NUMBER
  
  public static final int RELATIVE_GAP_LIMIT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- TREAT_BINARY_CLAUSES_SEPARATELY_FIELD_NUMBER
  
  public static final int TREAT_BINARY_CLAUSES_SEPARATELY_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- RANDOM_SEED_FIELD_NUMBER
  
  public static final int RANDOM_SEED_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- PERMUTE_VARIABLE_RANDOMLY_FIELD_NUMBER
  
  public static final int PERMUTE_VARIABLE_RANDOMLY_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- PERMUTE_PRESOLVE_CONSTRAINT_ORDER_FIELD_NUMBER
  
  public static final int PERMUTE_PRESOLVE_CONSTRAINT_ORDER_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_ABSL_RANDOM_FIELD_NUMBER
  
  public static final int USE_ABSL_RANDOM_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- LOG_SEARCH_PROGRESS_FIELD_NUMBER
  
  public static final int LOG_SEARCH_PROGRESS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- LOG_PREFIX_FIELD_NUMBER
  
  public static final int LOG_PREFIX_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- LOG_TO_STDOUT_FIELD_NUMBER
  
  public static final int LOG_TO_STDOUT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- LOG_TO_RESPONSE_FIELD_NUMBER
  
  public static final int LOG_TO_RESPONSE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_PB_RESOLUTION_FIELD_NUMBER
  
  public static final int USE_PB_RESOLUTION_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MINIMIZE_REDUCTION_DURING_PB_RESOLUTION_FIELD_NUMBER
  
  public static final int MINIMIZE_REDUCTION_DURING_PB_RESOLUTION_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- COUNT_ASSUMPTION_LEVELS_IN_LBD_FIELD_NUMBER
  
  public static final int COUNT_ASSUMPTION_LEVELS_IN_LBD_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- PRESOLVE_BVE_THRESHOLD_FIELD_NUMBER
  
  public static final int PRESOLVE_BVE_THRESHOLD_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- PRESOLVE_BVE_CLAUSE_WEIGHT_FIELD_NUMBER
  
  public static final int PRESOLVE_BVE_CLAUSE_WEIGHT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- PRESOLVE_PROBING_DETERMINISTIC_TIME_LIMIT_FIELD_NUMBER
  
  public static final int PRESOLVE_PROBING_DETERMINISTIC_TIME_LIMIT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- PRESOLVE_BLOCKED_CLAUSE_FIELD_NUMBER
  
  public static final int PRESOLVE_BLOCKED_CLAUSE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- PRESOLVE_USE_BVA_FIELD_NUMBER
  
  public static final int PRESOLVE_USE_BVA_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- PRESOLVE_BVA_THRESHOLD_FIELD_NUMBER
  
  public static final int PRESOLVE_BVA_THRESHOLD_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MAX_PRESOLVE_ITERATIONS_FIELD_NUMBER
  
  public static final int MAX_PRESOLVE_ITERATIONS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- CP_MODEL_PRESOLVE_FIELD_NUMBER
  
  public static final int CP_MODEL_PRESOLVE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- CP_MODEL_POSTSOLVE_WITH_FULL_SOLVER_FIELD_NUMBER
  
  public static final int CP_MODEL_POSTSOLVE_WITH_FULL_SOLVER_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- CP_MODEL_MAX_NUM_PRESOLVE_OPERATIONS_FIELD_NUMBER
  
  public static final int CP_MODEL_MAX_NUM_PRESOLVE_OPERATIONS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- CP_MODEL_PROBING_LEVEL_FIELD_NUMBER
  
  public static final int CP_MODEL_PROBING_LEVEL_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- CP_MODEL_USE_SAT_PRESOLVE_FIELD_NUMBER
  
  public static final int CP_MODEL_USE_SAT_PRESOLVE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_SAT_INPROCESSING_FIELD_NUMBER
  
  public static final int USE_SAT_INPROCESSING_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- EXPAND_ELEMENT_CONSTRAINTS_FIELD_NUMBER
  
  public static final int EXPAND_ELEMENT_CONSTRAINTS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- EXPAND_AUTOMATON_CONSTRAINTS_FIELD_NUMBER
  
  public static final int EXPAND_AUTOMATON_CONSTRAINTS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- EXPAND_TABLE_CONSTRAINTS_FIELD_NUMBER
  
  public static final int EXPAND_TABLE_CONSTRAINTS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- EXPAND_ALLDIFF_CONSTRAINTS_FIELD_NUMBER
  
  public static final int EXPAND_ALLDIFF_CONSTRAINTS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- EXPAND_RESERVOIR_CONSTRAINTS_FIELD_NUMBER
  
  public static final int EXPAND_RESERVOIR_CONSTRAINTS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- DISABLE_CONSTRAINT_EXPANSION_FIELD_NUMBER
  
  public static final int DISABLE_CONSTRAINT_EXPANSION_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MERGE_NO_OVERLAP_WORK_LIMIT_FIELD_NUMBER
  
  public static final int MERGE_NO_OVERLAP_WORK_LIMIT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MERGE_AT_MOST_ONE_WORK_LIMIT_FIELD_NUMBER
  
  public static final int MERGE_AT_MOST_ONE_WORK_LIMIT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- PRESOLVE_SUBSTITUTION_LEVEL_FIELD_NUMBER
  
  public static final int PRESOLVE_SUBSTITUTION_LEVEL_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- PRESOLVE_EXTRACT_INTEGER_ENFORCEMENT_FIELD_NUMBER
  
  public static final int PRESOLVE_EXTRACT_INTEGER_ENFORCEMENT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_OPTIMIZATION_HINTS_FIELD_NUMBER
  
  public static final int USE_OPTIMIZATION_HINTS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MINIMIZE_CORE_FIELD_NUMBER
  
  public static final int MINIMIZE_CORE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- FIND_MULTIPLE_CORES_FIELD_NUMBER
  
  public static final int FIND_MULTIPLE_CORES_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- COVER_OPTIMIZATION_FIELD_NUMBER
  
  public static final int COVER_OPTIMIZATION_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MAX_SAT_ASSUMPTION_ORDER_FIELD_NUMBER
  
  public static final int MAX_SAT_ASSUMPTION_ORDER_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MAX_SAT_REVERSE_ASSUMPTION_ORDER_FIELD_NUMBER
  
  public static final int MAX_SAT_REVERSE_ASSUMPTION_ORDER_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MAX_SAT_STRATIFICATION_FIELD_NUMBER
  
  public static final int MAX_SAT_STRATIFICATION_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_PRECEDENCES_IN_DISJUNCTIVE_CONSTRAINT_FIELD_NUMBER
  
  public static final int USE_PRECEDENCES_IN_DISJUNCTIVE_CONSTRAINT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_OVERLOAD_CHECKER_IN_CUMULATIVE_CONSTRAINT_FIELD_NUMBER
  
  public static final int USE_OVERLOAD_CHECKER_IN_CUMULATIVE_CONSTRAINT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_TIMETABLE_EDGE_FINDING_IN_CUMULATIVE_CONSTRAINT_FIELD_NUMBER
  
  public static final int USE_TIMETABLE_EDGE_FINDING_IN_CUMULATIVE_CONSTRAINT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_DISJUNCTIVE_CONSTRAINT_IN_CUMULATIVE_CONSTRAINT_FIELD_NUMBER
  
  public static final int USE_DISJUNCTIVE_CONSTRAINT_IN_CUMULATIVE_CONSTRAINT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- LINEARIZATION_LEVEL_FIELD_NUMBER
  
  public static final int LINEARIZATION_LEVEL_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- BOOLEAN_ENCODING_LEVEL_FIELD_NUMBER
  
  public static final int BOOLEAN_ENCODING_LEVEL_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MAX_NUM_CUTS_FIELD_NUMBER
  
  public static final int MAX_NUM_CUTS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- ONLY_ADD_CUTS_AT_LEVEL_ZERO_FIELD_NUMBER
  
  public static final int ONLY_ADD_CUTS_AT_LEVEL_ZERO_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- ADD_KNAPSACK_CUTS_FIELD_NUMBER
  
  public static final int ADD_KNAPSACK_CUTS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- ADD_CG_CUTS_FIELD_NUMBER
  
  public static final int ADD_CG_CUTS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- ADD_MIR_CUTS_FIELD_NUMBER
  
  public static final int ADD_MIR_CUTS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- ADD_ZERO_HALF_CUTS_FIELD_NUMBER
  
  public static final int ADD_ZERO_HALF_CUTS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- ADD_CLIQUE_CUTS_FIELD_NUMBER
  
  public static final int ADD_CLIQUE_CUTS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MAX_ALL_DIFF_CUT_SIZE_FIELD_NUMBER
  
  public static final int MAX_ALL_DIFF_CUT_SIZE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- ADD_LIN_MAX_CUTS_FIELD_NUMBER
  
  public static final int ADD_LIN_MAX_CUTS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MAX_INTEGER_ROUNDING_SCALING_FIELD_NUMBER
  
  public static final int MAX_INTEGER_ROUNDING_SCALING_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- ADD_LP_CONSTRAINTS_LAZILY_FIELD_NUMBER
  
  public static final int ADD_LP_CONSTRAINTS_LAZILY_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MIN_ORTHOGONALITY_FOR_LP_CONSTRAINTS_FIELD_NUMBER
  
  public static final int MIN_ORTHOGONALITY_FOR_LP_CONSTRAINTS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MAX_CUT_ROUNDS_AT_LEVEL_ZERO_FIELD_NUMBER
  
  public static final int MAX_CUT_ROUNDS_AT_LEVEL_ZERO_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MAX_CONSECUTIVE_INACTIVE_COUNT_FIELD_NUMBER
  
  public static final int MAX_CONSECUTIVE_INACTIVE_COUNT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- CUT_MAX_ACTIVE_COUNT_VALUE_FIELD_NUMBER
  
  public static final int CUT_MAX_ACTIVE_COUNT_VALUE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- CUT_ACTIVE_COUNT_DECAY_FIELD_NUMBER
  
  public static final int CUT_ACTIVE_COUNT_DECAY_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- CUT_CLEANUP_TARGET_FIELD_NUMBER
  
  public static final int CUT_CLEANUP_TARGET_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- NEW_CONSTRAINTS_BATCH_SIZE_FIELD_NUMBER
  
  public static final int NEW_CONSTRAINTS_BATCH_SIZE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- SEARCH_BRANCHING_FIELD_NUMBER
  
  public static final int SEARCH_BRANCHING_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- HINT_CONFLICT_LIMIT_FIELD_NUMBER
  
  public static final int HINT_CONFLICT_LIMIT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- REPAIR_HINT_FIELD_NUMBER
  
  public static final int REPAIR_HINT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- EXPLOIT_INTEGER_LP_SOLUTION_FIELD_NUMBER
  
  public static final int EXPLOIT_INTEGER_LP_SOLUTION_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- EXPLOIT_ALL_LP_SOLUTION_FIELD_NUMBER
  
  public static final int EXPLOIT_ALL_LP_SOLUTION_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- EXPLOIT_BEST_SOLUTION_FIELD_NUMBER
  
  public static final int EXPLOIT_BEST_SOLUTION_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- EXPLOIT_RELAXATION_SOLUTION_FIELD_NUMBER
  
  public static final int EXPLOIT_RELAXATION_SOLUTION_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- EXPLOIT_OBJECTIVE_FIELD_NUMBER
  
  public static final int EXPLOIT_OBJECTIVE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- PROBING_PERIOD_AT_ROOT_FIELD_NUMBER
  
  public static final int PROBING_PERIOD_AT_ROOT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_PROBING_SEARCH_FIELD_NUMBER
  
  public static final int USE_PROBING_SEARCH_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- PSEUDO_COST_RELIABILITY_THRESHOLD_FIELD_NUMBER
  
  public static final int PSEUDO_COST_RELIABILITY_THRESHOLD_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- OPTIMIZE_WITH_CORE_FIELD_NUMBER
  
  public static final int OPTIMIZE_WITH_CORE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- BINARY_SEARCH_NUM_CONFLICTS_FIELD_NUMBER
  
  public static final int BINARY_SEARCH_NUM_CONFLICTS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- OPTIMIZE_WITH_MAX_HS_FIELD_NUMBER
  
  public static final int OPTIMIZE_WITH_MAX_HS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- ENUMERATE_ALL_SOLUTIONS_FIELD_NUMBER
  
  public static final int ENUMERATE_ALL_SOLUTIONS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- KEEP_ALL_FEASIBLE_SOLUTIONS_IN_PRESOLVE_FIELD_NUMBER
  
  public static final int KEEP_ALL_FEASIBLE_SOLUTIONS_IN_PRESOLVE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- FILL_TIGHTENED_DOMAINS_IN_RESPONSE_FIELD_NUMBER
  
  public static final int FILL_TIGHTENED_DOMAINS_IN_RESPONSE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- INSTANTIATE_ALL_VARIABLES_FIELD_NUMBER
  
  public static final int INSTANTIATE_ALL_VARIABLES_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- AUTO_DETECT_GREATER_THAN_AT_LEAST_ONE_OF_FIELD_NUMBER
  
  public static final int AUTO_DETECT_GREATER_THAN_AT_LEAST_ONE_OF_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- STOP_AFTER_FIRST_SOLUTION_FIELD_NUMBER
  
  public static final int STOP_AFTER_FIRST_SOLUTION_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- STOP_AFTER_PRESOLVE_FIELD_NUMBER
  
  public static final int STOP_AFTER_PRESOLVE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- NUM_SEARCH_WORKERS_FIELD_NUMBER
  
  public static final int NUM_SEARCH_WORKERS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- INTERLEAVE_SEARCH_FIELD_NUMBER
  
  public static final int INTERLEAVE_SEARCH_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- INTERLEAVE_BATCH_SIZE_FIELD_NUMBER
  
  public static final int INTERLEAVE_BATCH_SIZE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- REDUCE_MEMORY_USAGE_IN_INTERLEAVE_MODE_FIELD_NUMBER
  
  public static final int REDUCE_MEMORY_USAGE_IN_INTERLEAVE_MODE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- SHARE_OBJECTIVE_BOUNDS_FIELD_NUMBER
  
  public static final int SHARE_OBJECTIVE_BOUNDS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- SHARE_LEVEL_ZERO_BOUNDS_FIELD_NUMBER
  
  public static final int SHARE_LEVEL_ZERO_BOUNDS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_LNS_ONLY_FIELD_NUMBER
  
  public static final int USE_LNS_ONLY_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- LNS_FOCUS_ON_DECISION_VARIABLES_FIELD_NUMBER
  
  public static final int LNS_FOCUS_ON_DECISION_VARIABLES_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- LNS_EXPAND_INTERVALS_IN_CONSTRAINT_GRAPH_FIELD_NUMBER
  
  public static final int LNS_EXPAND_INTERVALS_IN_CONSTRAINT_GRAPH_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_RINS_LNS_FIELD_NUMBER
  
  public static final int USE_RINS_LNS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_FEASIBILITY_PUMP_FIELD_NUMBER
  
  public static final int USE_FEASIBILITY_PUMP_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- FP_ROUNDING_FIELD_NUMBER
  
  public static final int FP_ROUNDING_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_RELAXATION_LNS_FIELD_NUMBER
  
  public static final int USE_RELAXATION_LNS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- DIVERSIFY_LNS_PARAMS_FIELD_NUMBER
  
  public static final int DIVERSIFY_LNS_PARAMS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- RANDOMIZE_SEARCH_FIELD_NUMBER
  
  public static final int RANDOMIZE_SEARCH_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- SEARCH_RANDOMIZATION_TOLERANCE_FIELD_NUMBER
  
  public static final int SEARCH_RANDOMIZATION_TOLERANCE_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_OPTIONAL_VARIABLES_FIELD_NUMBER
  
  public static final int USE_OPTIONAL_VARIABLES_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_EXACT_LP_REASON_FIELD_NUMBER
  
  public static final int USE_EXACT_LP_REASON_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_BRANCHING_IN_LP_FIELD_NUMBER
  
  public static final int USE_BRANCHING_IN_LP_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_COMBINED_NO_OVERLAP_FIELD_NUMBER
  
  public static final int USE_COMBINED_NO_OVERLAP_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- CATCH_SIGINT_SIGNAL_FIELD_NUMBER
  
  public static final int CATCH_SIGINT_SIGNAL_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- USE_IMPLIED_BOUNDS_FIELD_NUMBER
  
  public static final int USE_IMPLIED_BOUNDS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- POLISH_LP_SOLUTION_FIELD_NUMBER
  
  public static final int POLISH_LP_SOLUTION_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- CONVERT_INTERVALS_FIELD_NUMBER
  
  public static final int CONVERT_INTERVALS_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- SYMMETRY_LEVEL_FIELD_NUMBER
  
  public static final int SYMMETRY_LEVEL_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MIP_MAX_BOUND_FIELD_NUMBER
  
  public static final int MIP_MAX_BOUND_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MIP_VAR_SCALING_FIELD_NUMBER
  
  public static final int MIP_VAR_SCALING_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MIP_AUTOMATICALLY_SCALE_VARIABLES_FIELD_NUMBER
  
  public static final int MIP_AUTOMATICALLY_SCALE_VARIABLES_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MIP_WANTED_PRECISION_FIELD_NUMBER
  
  public static final int MIP_WANTED_PRECISION_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MIP_MAX_ACTIVITY_EXPONENT_FIELD_NUMBER
  
  public static final int MIP_MAX_ACTIVITY_EXPONENT_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- MIP_CHECK_PRECISION_FIELD_NUMBER
  
  public static final int MIP_CHECK_PRECISION_FIELD_NUMBER
  
  See Also:
  
  Constant Field Values
- PARSER
  
  @Deprecated public static final com.google.protobuf.Parser<SatParameters> PARSER
  
  Deprecated.
Method Details
- newInstance
  
  protected java.lang.Object newInstance(com.google.protobuf.GeneratedMessageV3.UnusedPrivateParameter unused)
  
  Overrides:
  
  newInstance in class com.google.protobuf.GeneratedMessageV3
- getUnknownFields
  
  public final com.google.protobuf.UnknownFieldSet getUnknownFields()
  
  Specified by:
  
  getUnknownFields in interface com.google.protobuf.MessageOrBuilder
  
  Overrides:
  
  getUnknownFields in class com.google.protobuf.GeneratedMessageV3
- getDescriptor
  
  public static final com.google.protobuf.Descriptors.Descriptor getDescriptor()
- internalGetFieldAccessorTable
  
  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()
  
  Specified by:
  
  internalGetFieldAccessorTable in class com.google.protobuf.GeneratedMessageV3
- hasName
  
  public boolean hasName()
  In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
  optional string name = 171 [default = ""];
  Specified by:
  
  hasName in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the name field is set.
- getName
  
  public java.lang.String getName()
  In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
  optional string name = 171 [default = ""];
  Specified by:
  
  getName in interface SatParametersOrBuilder
  
  Returns:
  
  The name.
- getNameBytes
  
  public com.google.protobuf.ByteString getNameBytes()
  In some context, like in a portfolio of search, it makes sense to name a given parameters set for logging purpose.
  optional string name = 171 [default = ""];
  Specified by:
  
  getNameBytes in interface SatParametersOrBuilder
  
  Returns:
  
  The bytes for name.
- hasPreferredVariableOrder
  
  public boolean hasPreferredVariableOrder()
  
  optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
  
  Specified by:
  
  hasPreferredVariableOrder in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the preferredVariableOrder field is set.
- getPreferredVariableOrder
  
  public SatParameters.VariableOrder getPreferredVariableOrder()
  
  optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
  
  Specified by:
  
  getPreferredVariableOrder in interface SatParametersOrBuilder
  
  Returns:
  
  The preferredVariableOrder.
- hasInitialPolarity
  
  public boolean hasInitialPolarity()
  
  optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
  
  Specified by:
  
  hasInitialPolarity in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the initialPolarity field is set.
- getInitialPolarity
  
  public SatParameters.Polarity getInitialPolarity()
  
  optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
  
  Specified by:
  
  getInitialPolarity in interface SatParametersOrBuilder
  
  Returns:
  
  The initialPolarity.
- hasUsePhaseSaving
  
  public boolean hasUsePhaseSaving()
  If this is true, then the polarity of a variable will be the last value it was assigned to, or its default polarity if it was never assigned since the call to ResetDecisionHeuristic(). Actually, we use a newer version where we follow the last value in the longest non-conflicting partial assignment in the current phase. This is called 'literal phase saving'. For details see 'A Lightweight Component Caching Scheme for Satisfiability Solvers' K. Pipatsrisawat and A.Darwiche, In 10th International Conference on Theory and Applications of Satisfiability Testing, 2007.
  optional bool use_phase_saving = 44 [default = true];
  Specified by:
  
  hasUsePhaseSaving in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the usePhaseSaving field is set.
- getUsePhaseSaving
  
  public boolean getUsePhaseSaving()
  If this is true, then the polarity of a variable will be the last value it was assigned to, or its default polarity if it was never assigned since the call to ResetDecisionHeuristic(). Actually, we use a newer version where we follow the last value in the longest non-conflicting partial assignment in the current phase. This is called 'literal phase saving'. For details see 'A Lightweight Component Caching Scheme for Satisfiability Solvers' K. Pipatsrisawat and A.Darwiche, In 10th International Conference on Theory and Applications of Satisfiability Testing, 2007.
  optional bool use_phase_saving = 44 [default = true];
  Specified by:
  
  getUsePhaseSaving in interface SatParametersOrBuilder
  
  Returns:
  
  The usePhaseSaving.
- hasPolarityRephaseIncrement
  
  public boolean hasPolarityRephaseIncrement()
  If non-zero, then we change the polarity heuristic after that many number of conflicts in an arithmetically increasing fashion. So x the first time, 2 * x the second time, etc...
  optional int32 polarity_rephase_increment = 168 [default = 1000];
  Specified by:
  
  hasPolarityRephaseIncrement in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the polarityRephaseIncrement field is set.
- getPolarityRephaseIncrement
  
  public int getPolarityRephaseIncrement()
  If non-zero, then we change the polarity heuristic after that many number of conflicts in an arithmetically increasing fashion. So x the first time, 2 * x the second time, etc...
  optional int32 polarity_rephase_increment = 168 [default = 1000];
  Specified by:
  
  getPolarityRephaseIncrement in interface SatParametersOrBuilder
  
  Returns:
  
  The polarityRephaseIncrement.
- hasRandomPolarityRatio
  
  public boolean hasRandomPolarityRatio()
  The proportion of polarity chosen at random. Note that this take precedence over the phase saving heuristic. This is different from initial_polarity:POLARITY_RANDOM because it will select a new random polarity each time the variable is branched upon instead of selecting one initially and then always taking this choice.
  optional double random_polarity_ratio = 45 [default = 0];
  Specified by:
  
  hasRandomPolarityRatio in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the randomPolarityRatio field is set.
- getRandomPolarityRatio
  
  public double getRandomPolarityRatio()
  The proportion of polarity chosen at random. Note that this take precedence over the phase saving heuristic. This is different from initial_polarity:POLARITY_RANDOM because it will select a new random polarity each time the variable is branched upon instead of selecting one initially and then always taking this choice.
  optional double random_polarity_ratio = 45 [default = 0];
  Specified by:
  
  getRandomPolarityRatio in interface SatParametersOrBuilder
  
  Returns:
  
  The randomPolarityRatio.
- hasRandomBranchesRatio
  
  public boolean hasRandomBranchesRatio()
  A number between 0 and 1 that indicates the proportion of branching variables that are selected randomly instead of choosing the first variable from the given variable_ordering strategy.
  optional double random_branches_ratio = 32 [default = 0];
  Specified by:
  
  hasRandomBranchesRatio in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the randomBranchesRatio field is set.
- getRandomBranchesRatio
  
  public double getRandomBranchesRatio()
  A number between 0 and 1 that indicates the proportion of branching variables that are selected randomly instead of choosing the first variable from the given variable_ordering strategy.
  optional double random_branches_ratio = 32 [default = 0];
  Specified by:
  
  getRandomBranchesRatio in interface SatParametersOrBuilder
  
  Returns:
  
  The randomBranchesRatio.
- hasUseErwaHeuristic
  
  public boolean hasUseErwaHeuristic()
  Whether we use the ERWA (Exponential Recency Weighted Average) heuristic as described in "Learning Rate Based Branching Heuristic for SAT solvers", J.H.Liang, V. Ganesh, P. Poupart, K.Czarnecki, SAT 2016.
  optional bool use_erwa_heuristic = 75 [default = false];
  Specified by:
  
  hasUseErwaHeuristic in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useErwaHeuristic field is set.
- getUseErwaHeuristic
  
  public boolean getUseErwaHeuristic()
  Whether we use the ERWA (Exponential Recency Weighted Average) heuristic as described in "Learning Rate Based Branching Heuristic for SAT solvers", J.H.Liang, V. Ganesh, P. Poupart, K.Czarnecki, SAT 2016.
  optional bool use_erwa_heuristic = 75 [default = false];
  Specified by:
  
  getUseErwaHeuristic in interface SatParametersOrBuilder
  
  Returns:
  
  The useErwaHeuristic.
- hasInitialVariablesActivity
  
  public boolean hasInitialVariablesActivity()
  The initial value of the variables activity. A non-zero value only make sense when use_erwa_heuristic is true. Experiments with a value of 1e-2 together with the ERWA heuristic showed slighthly better result than simply using zero. The idea is that when the "learning rate" of a variable becomes lower than this value, then we prefer to branch on never explored before variables. This is not in the ERWA paper.
  optional double initial_variables_activity = 76 [default = 0];
  Specified by:
  
  hasInitialVariablesActivity in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the initialVariablesActivity field is set.
- getInitialVariablesActivity
  
  public double getInitialVariablesActivity()
  The initial value of the variables activity. A non-zero value only make sense when use_erwa_heuristic is true. Experiments with a value of 1e-2 together with the ERWA heuristic showed slighthly better result than simply using zero. The idea is that when the "learning rate" of a variable becomes lower than this value, then we prefer to branch on never explored before variables. This is not in the ERWA paper.
  optional double initial_variables_activity = 76 [default = 0];
  Specified by:
  
  getInitialVariablesActivity in interface SatParametersOrBuilder
  
  Returns:
  
  The initialVariablesActivity.
- hasAlsoBumpVariablesInConflictReasons
  
  public boolean hasAlsoBumpVariablesInConflictReasons()
  When this is true, then the variables that appear in any of the reason of the variables in a conflict have their activity bumped. This is addition to the variables in the conflict, and the one that were used during conflict resolution.
  optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
  Specified by:
  
  hasAlsoBumpVariablesInConflictReasons in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the alsoBumpVariablesInConflictReasons field is set.
- getAlsoBumpVariablesInConflictReasons
  
  public boolean getAlsoBumpVariablesInConflictReasons()
  When this is true, then the variables that appear in any of the reason of the variables in a conflict have their activity bumped. This is addition to the variables in the conflict, and the one that were used during conflict resolution.
  optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
  Specified by:
  
  getAlsoBumpVariablesInConflictReasons in interface SatParametersOrBuilder
  
  Returns:
  
  The alsoBumpVariablesInConflictReasons.
- hasMinimizationAlgorithm
  
  public boolean hasMinimizationAlgorithm()
  
  optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
  
  Specified by:
  
  hasMinimizationAlgorithm in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the minimizationAlgorithm field is set.
- getMinimizationAlgorithm
  
  public SatParameters.ConflictMinimizationAlgorithm getMinimizationAlgorithm()
  
  optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
  
  Specified by:
  
  getMinimizationAlgorithm in interface SatParametersOrBuilder
  
  Returns:
  
  The minimizationAlgorithm.
- hasBinaryMinimizationAlgorithm
  
  public boolean hasBinaryMinimizationAlgorithm()
  
  optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];
  
  Specified by:
  
  hasBinaryMinimizationAlgorithm in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the binaryMinimizationAlgorithm field is set.
- getBinaryMinimizationAlgorithm
  
  public SatParameters.BinaryMinizationAlgorithm getBinaryMinimizationAlgorithm()
  
  optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];
  
  Specified by:
  
  getBinaryMinimizationAlgorithm in interface SatParametersOrBuilder
  
  Returns:
  
  The binaryMinimizationAlgorithm.
- hasSubsumptionDuringConflictAnalysis
  
  public boolean hasSubsumptionDuringConflictAnalysis()
  At a really low cost, during the 1-UIP conflict computation, it is easy to detect if some of the involved reasons are subsumed by the current conflict. When this is true, such clauses are detached and later removed from the problem.
  optional bool subsumption_during_conflict_analysis = 56 [default = true];
  Specified by:
  
  hasSubsumptionDuringConflictAnalysis in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the subsumptionDuringConflictAnalysis field is set.
- getSubsumptionDuringConflictAnalysis
  
  public boolean getSubsumptionDuringConflictAnalysis()
  At a really low cost, during the 1-UIP conflict computation, it is easy to detect if some of the involved reasons are subsumed by the current conflict. When this is true, such clauses are detached and later removed from the problem.
  optional bool subsumption_during_conflict_analysis = 56 [default = true];
  Specified by:
  
  getSubsumptionDuringConflictAnalysis in interface SatParametersOrBuilder
  
  Returns:
  
  The subsumptionDuringConflictAnalysis.
- hasClauseCleanupPeriod
  
  public boolean hasClauseCleanupPeriod()
  Trigger a cleanup when this number of "deletable" clauses is learned.
  optional int32 clause_cleanup_period = 11 [default = 10000];
  Specified by:
  
  hasClauseCleanupPeriod in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the clauseCleanupPeriod field is set.
- getClauseCleanupPeriod
  
  public int getClauseCleanupPeriod()
  Trigger a cleanup when this number of "deletable" clauses is learned.
  optional int32 clause_cleanup_period = 11 [default = 10000];
  Specified by:
  
  getClauseCleanupPeriod in interface SatParametersOrBuilder
  
  Returns:
  
  The clauseCleanupPeriod.
- hasClauseCleanupTarget
  
  public boolean hasClauseCleanupTarget()
  During a cleanup, we will always keep that number of "deletable" clauses. Note that this doesn't include the "protected" clauses.
  optional int32 clause_cleanup_target = 13 [default = 10000];
  Specified by:
  
  hasClauseCleanupTarget in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the clauseCleanupTarget field is set.
- getClauseCleanupTarget
  
  public int getClauseCleanupTarget()
  During a cleanup, we will always keep that number of "deletable" clauses. Note that this doesn't include the "protected" clauses.
  optional int32 clause_cleanup_target = 13 [default = 10000];
  Specified by:
  
  getClauseCleanupTarget in interface SatParametersOrBuilder
  
  Returns:
  
  The clauseCleanupTarget.
- hasClauseCleanupProtection
  
  public boolean hasClauseCleanupProtection()
  
  optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];
  
  Specified by:
  
  hasClauseCleanupProtection in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the clauseCleanupProtection field is set.
- getClauseCleanupProtection
  
  public SatParameters.ClauseProtection getClauseCleanupProtection()
  
  optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];
  
  Specified by:
  
  getClauseCleanupProtection in interface SatParametersOrBuilder
  
  Returns:
  
  The clauseCleanupProtection.
- hasClauseCleanupLbdBound
  
  public boolean hasClauseCleanupLbdBound()
  All the clauses with a LBD (literal blocks distance) lower or equal to this parameters will always be kept.
  optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
  Specified by:
  
  hasClauseCleanupLbdBound in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the clauseCleanupLbdBound field is set.
- getClauseCleanupLbdBound
  
  public int getClauseCleanupLbdBound()
  All the clauses with a LBD (literal blocks distance) lower or equal to this parameters will always be kept.
  optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
  Specified by:
  
  getClauseCleanupLbdBound in interface SatParametersOrBuilder
  
  Returns:
  
  The clauseCleanupLbdBound.
- hasClauseCleanupOrdering
  
  public boolean hasClauseCleanupOrdering()
  
  optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
  
  Specified by:
  
  hasClauseCleanupOrdering in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the clauseCleanupOrdering field is set.
- getClauseCleanupOrdering
  
  public SatParameters.ClauseOrdering getClauseCleanupOrdering()
  
  optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
  
  Specified by:
  
  getClauseCleanupOrdering in interface SatParametersOrBuilder
  
  Returns:
  
  The clauseCleanupOrdering.
- hasPbCleanupIncrement
  
  public boolean hasPbCleanupIncrement()
  Same as for the clauses, but for the learned pseudo-Boolean constraints.
  optional int32 pb_cleanup_increment = 46 [default = 200];
  Specified by:
  
  hasPbCleanupIncrement in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the pbCleanupIncrement field is set.
- getPbCleanupIncrement
  
  public int getPbCleanupIncrement()
  Same as for the clauses, but for the learned pseudo-Boolean constraints.
  optional int32 pb_cleanup_increment = 46 [default = 200];
  Specified by:
  
  getPbCleanupIncrement in interface SatParametersOrBuilder
  
  Returns:
  
  The pbCleanupIncrement.
- hasPbCleanupRatio
  
  public boolean hasPbCleanupRatio()
  
  optional double pb_cleanup_ratio = 47 [default = 0.5];
  
  Specified by:
  
  hasPbCleanupRatio in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the pbCleanupRatio field is set.
- getPbCleanupRatio
  
  public double getPbCleanupRatio()
  
  optional double pb_cleanup_ratio = 47 [default = 0.5];
  
  Specified by:
  
  getPbCleanupRatio in interface SatParametersOrBuilder
  
  Returns:
  
  The pbCleanupRatio.
- hasMinimizeWithPropagationRestartPeriod
  
  public boolean hasMinimizeWithPropagationRestartPeriod()
  Parameters for an heuristic similar to the one descibed in "An effective learnt clause minimization approach for CDCL Sat Solvers", https://www.ijcai.org/proceedings/2017/0098.pdf For now, we have a somewhat simpler implementation where every x restart we spend y decisions on clause minimization. The minimization technique is the same as the one used to minimize core in max-sat. We also minimize problem clauses and not just the learned clause that we keep forever like in the paper. Changing these parameters or the kind of clause we minimize seems to have a big impact on the overall perf on our benchmarks. So this technique seems definitely useful, but it is hard to tune properly.
  optional int32 minimize_with_propagation_restart_period = 96 [default = 10];
  Specified by:
  
  hasMinimizeWithPropagationRestartPeriod in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the minimizeWithPropagationRestartPeriod field is set.
- getMinimizeWithPropagationRestartPeriod
  
  public int getMinimizeWithPropagationRestartPeriod()
  Parameters for an heuristic similar to the one descibed in "An effective learnt clause minimization approach for CDCL Sat Solvers", https://www.ijcai.org/proceedings/2017/0098.pdf For now, we have a somewhat simpler implementation where every x restart we spend y decisions on clause minimization. The minimization technique is the same as the one used to minimize core in max-sat. We also minimize problem clauses and not just the learned clause that we keep forever like in the paper. Changing these parameters or the kind of clause we minimize seems to have a big impact on the overall perf on our benchmarks. So this technique seems definitely useful, but it is hard to tune properly.
  optional int32 minimize_with_propagation_restart_period = 96 [default = 10];
  Specified by:
  
  getMinimizeWithPropagationRestartPeriod in interface SatParametersOrBuilder
  
  Returns:
  
  The minimizeWithPropagationRestartPeriod.
- hasMinimizeWithPropagationNumDecisions
  
  public boolean hasMinimizeWithPropagationNumDecisions()
  
  optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];
  
  Specified by:
  
  hasMinimizeWithPropagationNumDecisions in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the minimizeWithPropagationNumDecisions field is set.
- getMinimizeWithPropagationNumDecisions
  
  public int getMinimizeWithPropagationNumDecisions()
  
  optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];
  
  Specified by:
  
  getMinimizeWithPropagationNumDecisions in interface SatParametersOrBuilder
  
  Returns:
  
  The minimizeWithPropagationNumDecisions.
- hasVariableActivityDecay
  
  public boolean hasVariableActivityDecay()
  Each time a conflict is found, the activities of some variables are increased by one. Then, the activity of all variables are multiplied by variable_activity_decay. To implement this efficiently, the activity of all the variables is not decayed at each conflict. Instead, the activity increment is multiplied by 1 / decay. When an activity reach max_variable_activity_value, all the activity are multiplied by 1 / max_variable_activity_value.
  optional double variable_activity_decay = 15 [default = 0.8];
  Specified by:
  
  hasVariableActivityDecay in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the variableActivityDecay field is set.
- getVariableActivityDecay
  
  public double getVariableActivityDecay()
  Each time a conflict is found, the activities of some variables are increased by one. Then, the activity of all variables are multiplied by variable_activity_decay. To implement this efficiently, the activity of all the variables is not decayed at each conflict. Instead, the activity increment is multiplied by 1 / decay. When an activity reach max_variable_activity_value, all the activity are multiplied by 1 / max_variable_activity_value.
  optional double variable_activity_decay = 15 [default = 0.8];
  Specified by:
  
  getVariableActivityDecay in interface SatParametersOrBuilder
  
  Returns:
  
  The variableActivityDecay.
- hasMaxVariableActivityValue
  
  public boolean hasMaxVariableActivityValue()
  
  optional double max_variable_activity_value = 16 [default = 1e+100];
  
  Specified by:
  
  hasMaxVariableActivityValue in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxVariableActivityValue field is set.
- getMaxVariableActivityValue
  
  public double getMaxVariableActivityValue()
  
  optional double max_variable_activity_value = 16 [default = 1e+100];
  
  Specified by:
  
  getMaxVariableActivityValue in interface SatParametersOrBuilder
  
  Returns:
  
  The maxVariableActivityValue.
- hasGlucoseMaxDecay
  
  public boolean hasGlucoseMaxDecay()
  The activity starts at 0.8 and increment by 0.01 every 5000 conflicts until 0.95. This "hack" seems to work well and comes from: Glucose 2.3 in the SAT 2013 Competition - SAT Competition 2013 http://edacc4.informatik.uni-ulm.de/SC13/solver-description-download/136
  optional double glucose_max_decay = 22 [default = 0.95];
  Specified by:
  
  hasGlucoseMaxDecay in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the glucoseMaxDecay field is set.
- getGlucoseMaxDecay
  
  public double getGlucoseMaxDecay()
  The activity starts at 0.8 and increment by 0.01 every 5000 conflicts until 0.95. This "hack" seems to work well and comes from: Glucose 2.3 in the SAT 2013 Competition - SAT Competition 2013 http://edacc4.informatik.uni-ulm.de/SC13/solver-description-download/136
  optional double glucose_max_decay = 22 [default = 0.95];
  Specified by:
  
  getGlucoseMaxDecay in interface SatParametersOrBuilder
  
  Returns:
  
  The glucoseMaxDecay.
- hasGlucoseDecayIncrement
  
  public boolean hasGlucoseDecayIncrement()
  
  optional double glucose_decay_increment = 23 [default = 0.01];
  
  Specified by:
  
  hasGlucoseDecayIncrement in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the glucoseDecayIncrement field is set.
- getGlucoseDecayIncrement
  
  public double getGlucoseDecayIncrement()
  
  optional double glucose_decay_increment = 23 [default = 0.01];
  
  Specified by:
  
  getGlucoseDecayIncrement in interface SatParametersOrBuilder
  
  Returns:
  
  The glucoseDecayIncrement.
- hasGlucoseDecayIncrementPeriod
  
  public boolean hasGlucoseDecayIncrementPeriod()
  
  optional int32 glucose_decay_increment_period = 24 [default = 5000];
  
  Specified by:
  
  hasGlucoseDecayIncrementPeriod in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the glucoseDecayIncrementPeriod field is set.
- getGlucoseDecayIncrementPeriod
  
  public int getGlucoseDecayIncrementPeriod()
  
  optional int32 glucose_decay_increment_period = 24 [default = 5000];
  
  Specified by:
  
  getGlucoseDecayIncrementPeriod in interface SatParametersOrBuilder
  
  Returns:
  
  The glucoseDecayIncrementPeriod.
- hasClauseActivityDecay
  
  public boolean hasClauseActivityDecay()
  Clause activity parameters (same effect as the one on the variables).
  optional double clause_activity_decay = 17 [default = 0.999];
  Specified by:
  
  hasClauseActivityDecay in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the clauseActivityDecay field is set.
- getClauseActivityDecay
  
  public double getClauseActivityDecay()
  Clause activity parameters (same effect as the one on the variables).
  optional double clause_activity_decay = 17 [default = 0.999];
  Specified by:
  
  getClauseActivityDecay in interface SatParametersOrBuilder
  
  Returns:
  
  The clauseActivityDecay.
- hasMaxClauseActivityValue
  
  public boolean hasMaxClauseActivityValue()
  
  optional double max_clause_activity_value = 18 [default = 1e+20];
  
  Specified by:
  
  hasMaxClauseActivityValue in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxClauseActivityValue field is set.
- getMaxClauseActivityValue
  
  public double getMaxClauseActivityValue()
  
  optional double max_clause_activity_value = 18 [default = 1e+20];
  
  Specified by:
  
  getMaxClauseActivityValue in interface SatParametersOrBuilder
  
  Returns:
  
  The maxClauseActivityValue.
- getRestartAlgorithmsList
  
  public java.util.List<SatParameters.RestartAlgorithm> getRestartAlgorithmsList()
  The restart strategies will change each time the strategy_counter is increased. The current strategy will simply be the one at index strategy_counter modulo the number of strategy. Note that if this list includes a NO_RESTART, nothing will change when it is reached because the strategy_counter will only increment after a restart. The idea of switching of search strategy tailored for SAT/UNSAT comes from Chanseok Oh with his COMiniSatPS solver, see http://cs.nyu.edu/~chanseok/. But more generally, it seems REALLY beneficial to try different strategy.
  repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
  Specified by:
  
  getRestartAlgorithmsList in interface SatParametersOrBuilder
  
  Returns:
  
  A list containing the restartAlgorithms.
- getRestartAlgorithmsCount
  
  public int getRestartAlgorithmsCount()
  The restart strategies will change each time the strategy_counter is increased. The current strategy will simply be the one at index strategy_counter modulo the number of strategy. Note that if this list includes a NO_RESTART, nothing will change when it is reached because the strategy_counter will only increment after a restart. The idea of switching of search strategy tailored for SAT/UNSAT comes from Chanseok Oh with his COMiniSatPS solver, see http://cs.nyu.edu/~chanseok/. But more generally, it seems REALLY beneficial to try different strategy.
  repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
  Specified by:
  
  getRestartAlgorithmsCount in interface SatParametersOrBuilder
  
  Returns:
  
  The count of restartAlgorithms.
- getRestartAlgorithms
  
  public SatParameters.RestartAlgorithm getRestartAlgorithms(int index)
  The restart strategies will change each time the strategy_counter is increased. The current strategy will simply be the one at index strategy_counter modulo the number of strategy. Note that if this list includes a NO_RESTART, nothing will change when it is reached because the strategy_counter will only increment after a restart. The idea of switching of search strategy tailored for SAT/UNSAT comes from Chanseok Oh with his COMiniSatPS solver, see http://cs.nyu.edu/~chanseok/. But more generally, it seems REALLY beneficial to try different strategy.
  repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
  Specified by:
  
  getRestartAlgorithms in interface SatParametersOrBuilder
  
  Parameters:
  
  index - The index of the element to return.
  
  Returns:
  
  The restartAlgorithms at the given index.
- hasDefaultRestartAlgorithms
  
  public boolean hasDefaultRestartAlgorithms()
  
  optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
  
  Specified by:
  
  hasDefaultRestartAlgorithms in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the defaultRestartAlgorithms field is set.
- getDefaultRestartAlgorithms
  
  public java.lang.String getDefaultRestartAlgorithms()
  
  optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
  
  Specified by:
  
  getDefaultRestartAlgorithms in interface SatParametersOrBuilder
  
  Returns:
  
  The defaultRestartAlgorithms.
- getDefaultRestartAlgorithmsBytes
  
  public com.google.protobuf.ByteString getDefaultRestartAlgorithmsBytes()
  
  optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
  
  Specified by:
  
  getDefaultRestartAlgorithmsBytes in interface SatParametersOrBuilder
  
  Returns:
  
  The bytes for defaultRestartAlgorithms.
- hasRestartPeriod
  
  public boolean hasRestartPeriod()
  Restart period for the FIXED_RESTART strategy. This is also the multiplier used by the LUBY_RESTART strategy.
  optional int32 restart_period = 30 [default = 50];
  Specified by:
  
  hasRestartPeriod in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the restartPeriod field is set.
- getRestartPeriod
  
  public int getRestartPeriod()
  Restart period for the FIXED_RESTART strategy. This is also the multiplier used by the LUBY_RESTART strategy.
  optional int32 restart_period = 30 [default = 50];
  Specified by:
  
  getRestartPeriod in interface SatParametersOrBuilder
  
  Returns:
  
  The restartPeriod.
- hasRestartRunningWindowSize
  
  public boolean hasRestartRunningWindowSize()
  Size of the window for the moving average restarts.
  optional int32 restart_running_window_size = 62 [default = 50];
  Specified by:
  
  hasRestartRunningWindowSize in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the restartRunningWindowSize field is set.
- getRestartRunningWindowSize
  
  public int getRestartRunningWindowSize()
  Size of the window for the moving average restarts.
  optional int32 restart_running_window_size = 62 [default = 50];
  Specified by:
  
  getRestartRunningWindowSize in interface SatParametersOrBuilder
  
  Returns:
  
  The restartRunningWindowSize.
- hasRestartDlAverageRatio
  
  public boolean hasRestartDlAverageRatio()
  In the moving average restart algorithms, a restart is triggered if the window average times this ratio is greater that the global average.
  optional double restart_dl_average_ratio = 63 [default = 1];
  Specified by:
  
  hasRestartDlAverageRatio in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the restartDlAverageRatio field is set.
- getRestartDlAverageRatio
  
  public double getRestartDlAverageRatio()
  In the moving average restart algorithms, a restart is triggered if the window average times this ratio is greater that the global average.
  optional double restart_dl_average_ratio = 63 [default = 1];
  Specified by:
  
  getRestartDlAverageRatio in interface SatParametersOrBuilder
  
  Returns:
  
  The restartDlAverageRatio.
- hasRestartLbdAverageRatio
  
  public boolean hasRestartLbdAverageRatio()
  
  optional double restart_lbd_average_ratio = 71 [default = 1];
  
  Specified by:
  
  hasRestartLbdAverageRatio in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the restartLbdAverageRatio field is set.
- getRestartLbdAverageRatio
  
  public double getRestartLbdAverageRatio()
  
  optional double restart_lbd_average_ratio = 71 [default = 1];
  
  Specified by:
  
  getRestartLbdAverageRatio in interface SatParametersOrBuilder
  
  Returns:
  
  The restartLbdAverageRatio.
- hasUseBlockingRestart
  
  public boolean hasUseBlockingRestart()
  Block a moving restart algorithm if the trail size of the current conflict is greater than the multiplier times the moving average of the trail size at the previous conflicts.
  optional bool use_blocking_restart = 64 [default = false];
  Specified by:
  
  hasUseBlockingRestart in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useBlockingRestart field is set.
- getUseBlockingRestart
  
  public boolean getUseBlockingRestart()
  Block a moving restart algorithm if the trail size of the current conflict is greater than the multiplier times the moving average of the trail size at the previous conflicts.
  optional bool use_blocking_restart = 64 [default = false];
  Specified by:
  
  getUseBlockingRestart in interface SatParametersOrBuilder
  
  Returns:
  
  The useBlockingRestart.
- hasBlockingRestartWindowSize
  
  public boolean hasBlockingRestartWindowSize()
  
  optional int32 blocking_restart_window_size = 65 [default = 5000];
  
  Specified by:
  
  hasBlockingRestartWindowSize in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the blockingRestartWindowSize field is set.
- getBlockingRestartWindowSize
  
  public int getBlockingRestartWindowSize()
  
  optional int32 blocking_restart_window_size = 65 [default = 5000];
  
  Specified by:
  
  getBlockingRestartWindowSize in interface SatParametersOrBuilder
  
  Returns:
  
  The blockingRestartWindowSize.
- hasBlockingRestartMultiplier
  
  public boolean hasBlockingRestartMultiplier()
  
  optional double blocking_restart_multiplier = 66 [default = 1.4];
  
  Specified by:
  
  hasBlockingRestartMultiplier in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the blockingRestartMultiplier field is set.
- getBlockingRestartMultiplier
  
  public double getBlockingRestartMultiplier()
  
  optional double blocking_restart_multiplier = 66 [default = 1.4];
  
  Specified by:
  
  getBlockingRestartMultiplier in interface SatParametersOrBuilder
  
  Returns:
  
  The blockingRestartMultiplier.
- hasNumConflictsBeforeStrategyChanges
  
  public boolean hasNumConflictsBeforeStrategyChanges()
  After each restart, if the number of conflict since the last strategy change is greater that this, then we increment a "strategy_counter" that can be use to change the search strategy used by the following restarts.
  optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
  Specified by:
  
  hasNumConflictsBeforeStrategyChanges in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the numConflictsBeforeStrategyChanges field is set.
- getNumConflictsBeforeStrategyChanges
  
  public int getNumConflictsBeforeStrategyChanges()
  After each restart, if the number of conflict since the last strategy change is greater that this, then we increment a "strategy_counter" that can be use to change the search strategy used by the following restarts.
  optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
  Specified by:
  
  getNumConflictsBeforeStrategyChanges in interface SatParametersOrBuilder
  
  Returns:
  
  The numConflictsBeforeStrategyChanges.
- hasStrategyChangeIncreaseRatio
  
  public boolean hasStrategyChangeIncreaseRatio()
  The parameter num_conflicts_before_strategy_changes is increased by that much after each strategy change.
  optional double strategy_change_increase_ratio = 69 [default = 0];
  Specified by:
  
  hasStrategyChangeIncreaseRatio in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the strategyChangeIncreaseRatio field is set.
- getStrategyChangeIncreaseRatio
  
  public double getStrategyChangeIncreaseRatio()
  The parameter num_conflicts_before_strategy_changes is increased by that much after each strategy change.
  optional double strategy_change_increase_ratio = 69 [default = 0];
  Specified by:
  
  getStrategyChangeIncreaseRatio in interface SatParametersOrBuilder
  
  Returns:
  
  The strategyChangeIncreaseRatio.
- hasMaxTimeInSeconds
  
  public boolean hasMaxTimeInSeconds()
  Maximum time allowed in seconds to solve a problem. The counter will starts at the beginning of the Solve() call.
  optional double max_time_in_seconds = 36 [default = inf];
  Specified by:
  
  hasMaxTimeInSeconds in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxTimeInSeconds field is set.
- getMaxTimeInSeconds
  
  public double getMaxTimeInSeconds()
  Maximum time allowed in seconds to solve a problem. The counter will starts at the beginning of the Solve() call.
  optional double max_time_in_seconds = 36 [default = inf];
  Specified by:
  
  getMaxTimeInSeconds in interface SatParametersOrBuilder
  
  Returns:
  
  The maxTimeInSeconds.
- 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 as close as possible to a second.
  optional double max_deterministic_time = 67 [default = inf];
  Specified by:
  
  hasMaxDeterministicTime in interface SatParametersOrBuilder
  
  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 as close as possible to a second.
  optional double max_deterministic_time = 67 [default = inf];
  Specified by:
  
  getMaxDeterministicTime in interface SatParametersOrBuilder
  
  Returns:
  
  The maxDeterministicTime.
- hasMaxNumberOfConflicts
  
  public boolean hasMaxNumberOfConflicts()
  Maximum number of conflicts allowed to solve a problem. TODO(user,user): Maybe change the way the conflict limit is enforced? currently it is enforced on each independent internal SAT solve, rather than on the overall number of conflicts across all solves. So in the context of an optimization problem, this is not really usable directly by a client.
  optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
  Specified by:
  
  hasMaxNumberOfConflicts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxNumberOfConflicts field is set.
- getMaxNumberOfConflicts
  
  public long getMaxNumberOfConflicts()
  Maximum number of conflicts allowed to solve a problem. TODO(user,user): Maybe change the way the conflict limit is enforced? currently it is enforced on each independent internal SAT solve, rather than on the overall number of conflicts across all solves. So in the context of an optimization problem, this is not really usable directly by a client.
  optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
  Specified by:
  
  getMaxNumberOfConflicts in interface SatParametersOrBuilder
  
  Returns:
  
  The maxNumberOfConflicts.
- hasMaxMemoryInMb
  
  public boolean hasMaxMemoryInMb()
  Maximum memory allowed for the whole thread containing the solver. The solver will abort as soon as it detects that this limit is crossed. As a result, this limit is approximative, but usually the solver will not go too much over.
  optional int64 max_memory_in_mb = 40 [default = 10000];
  Specified by:
  
  hasMaxMemoryInMb in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxMemoryInMb field is set.
- getMaxMemoryInMb
  
  public long getMaxMemoryInMb()
  Maximum memory allowed for the whole thread containing the solver. The solver will abort as soon as it detects that this limit is crossed. As a result, this limit is approximative, but usually the solver will not go too much over.
  optional int64 max_memory_in_mb = 40 [default = 10000];
  Specified by:
  
  getMaxMemoryInMb in interface SatParametersOrBuilder
  
  Returns:
  
  The maxMemoryInMb.
- hasAbsoluteGapLimit
  
  public boolean hasAbsoluteGapLimit()
  Stop the search when the gap between the best feasible objective (O) and our best objective bound (B) is smaller than a limit. The exact definition is: - Absolute: abs(O - B) - Relative: abs(O - B) / max(1, abs(O)). Important: The relative gap depends on the objective offset! If you artificially shift the objective, you will get widely different value of the relative gap. Note that if the gap is reached, the search status will be OPTIMAL. But one can check the best objective bound to see the actual gap.
  optional double absolute_gap_limit = 159 [default = 0];
  Specified by:
  
  hasAbsoluteGapLimit in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the absoluteGapLimit field is set.
- getAbsoluteGapLimit
  
  public double getAbsoluteGapLimit()
  Stop the search when the gap between the best feasible objective (O) and our best objective bound (B) is smaller than a limit. The exact definition is: - Absolute: abs(O - B) - Relative: abs(O - B) / max(1, abs(O)). Important: The relative gap depends on the objective offset! If you artificially shift the objective, you will get widely different value of the relative gap. Note that if the gap is reached, the search status will be OPTIMAL. But one can check the best objective bound to see the actual gap.
  optional double absolute_gap_limit = 159 [default = 0];
  Specified by:
  
  getAbsoluteGapLimit in interface SatParametersOrBuilder
  
  Returns:
  
  The absoluteGapLimit.
- hasRelativeGapLimit
  
  public boolean hasRelativeGapLimit()
  
  optional double relative_gap_limit = 160 [default = 0];
  
  Specified by:
  
  hasRelativeGapLimit in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the relativeGapLimit field is set.
- getRelativeGapLimit
  
  public double getRelativeGapLimit()
  
  optional double relative_gap_limit = 160 [default = 0];
  
  Specified by:
  
  getRelativeGapLimit in interface SatParametersOrBuilder
  
  Returns:
  
  The relativeGapLimit.
- hasTreatBinaryClausesSeparately
  
  public boolean hasTreatBinaryClausesSeparately()
  If true, the binary clauses are treated separately from the others. This should be faster and uses less memory. However it changes the propagation order.
  optional bool treat_binary_clauses_separately = 33 [default = true];
  Specified by:
  
  hasTreatBinaryClausesSeparately in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the treatBinaryClausesSeparately field is set.
- getTreatBinaryClausesSeparately
  
  public boolean getTreatBinaryClausesSeparately()
  If true, the binary clauses are treated separately from the others. This should be faster and uses less memory. However it changes the propagation order.
  optional bool treat_binary_clauses_separately = 33 [default = true];
  Specified by:
  
  getTreatBinaryClausesSeparately in interface SatParametersOrBuilder
  
  Returns:
  
  The treatBinaryClausesSeparately.
- hasRandomSeed
  
  public boolean hasRandomSeed()
  At the beginning of each solve, the random number generator used in some part of the solver is reinitialized to this seed. If you change the random seed, the solver may make different choices during the solving process. For some problems, the running time may vary a lot depending on small change in the solving algorithm. Running the solver with different seeds enables to have more robust benchmarks when evaluating new features.
  optional int32 random_seed = 31 [default = 1];
  Specified by:
  
  hasRandomSeed in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the randomSeed field is set.
- getRandomSeed
  
  public int getRandomSeed()
  At the beginning of each solve, the random number generator used in some part of the solver is reinitialized to this seed. If you change the random seed, the solver may make different choices during the solving process. For some problems, the running time may vary a lot depending on small change in the solving algorithm. Running the solver with different seeds enables to have more robust benchmarks when evaluating new features.
  optional int32 random_seed = 31 [default = 1];
  Specified by:
  
  getRandomSeed in interface SatParametersOrBuilder
  
  Returns:
  
  The randomSeed.
- hasPermuteVariableRandomly
  
  public boolean hasPermuteVariableRandomly()
  This is mainly here to test the solver variability. Note that in tests, if not explicitly set to false, all 3 options will be set to true so that clients do not rely on the solver returning a specific solution if they are many equivalent optimal solutions.
  optional bool permute_variable_randomly = 178 [default = false];
  Specified by:
  
  hasPermuteVariableRandomly in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the permuteVariableRandomly field is set.
- getPermuteVariableRandomly
  
  public boolean getPermuteVariableRandomly()
  This is mainly here to test the solver variability. Note that in tests, if not explicitly set to false, all 3 options will be set to true so that clients do not rely on the solver returning a specific solution if they are many equivalent optimal solutions.
  optional bool permute_variable_randomly = 178 [default = false];
  Specified by:
  
  getPermuteVariableRandomly in interface SatParametersOrBuilder
  
  Returns:
  
  The permuteVariableRandomly.
- hasPermutePresolveConstraintOrder
  
  public boolean hasPermutePresolveConstraintOrder()
  
  optional bool permute_presolve_constraint_order = 179 [default = false];
  
  Specified by:
  
  hasPermutePresolveConstraintOrder in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the permutePresolveConstraintOrder field is set.
- getPermutePresolveConstraintOrder
  
  public boolean getPermutePresolveConstraintOrder()
  
  optional bool permute_presolve_constraint_order = 179 [default = false];
  
  Specified by:
  
  getPermutePresolveConstraintOrder in interface SatParametersOrBuilder
  
  Returns:
  
  The permutePresolveConstraintOrder.
- hasUseAbslRandom
  
  public boolean hasUseAbslRandom()
  
  optional bool use_absl_random = 180 [default = false];
  
  Specified by:
  
  hasUseAbslRandom in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useAbslRandom field is set.
- getUseAbslRandom
  
  public boolean getUseAbslRandom()
  
  optional bool use_absl_random = 180 [default = false];
  
  Specified by:
  
  getUseAbslRandom in interface SatParametersOrBuilder
  
  Returns:
  
  The useAbslRandom.
- hasLogSearchProgress
  
  public boolean hasLogSearchProgress()
  Whether the solver should log the search progress. By default, it logs to LOG(INFO). This can be overwritten by the log_destination parameter.
  optional bool log_search_progress = 41 [default = false];
  Specified by:
  
  hasLogSearchProgress in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the logSearchProgress field is set.
- getLogSearchProgress
  
  public boolean getLogSearchProgress()
  Whether the solver should log the search progress. By default, it logs to LOG(INFO). This can be overwritten by the log_destination parameter.
  optional bool log_search_progress = 41 [default = false];
  Specified by:
  
  getLogSearchProgress in interface SatParametersOrBuilder
  
  Returns:
  
  The logSearchProgress.
- hasLogPrefix
  
  public boolean hasLogPrefix()
  Add a prefix to all logs.
  optional string log_prefix = 185 [default = ""];
  Specified by:
  
  hasLogPrefix in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the logPrefix field is set.
- getLogPrefix
  
  public java.lang.String getLogPrefix()
  Add a prefix to all logs.
  optional string log_prefix = 185 [default = ""];
  Specified by:
  
  getLogPrefix in interface SatParametersOrBuilder
  
  Returns:
  
  The logPrefix.
- getLogPrefixBytes
  
  public com.google.protobuf.ByteString getLogPrefixBytes()
  Add a prefix to all logs.
  optional string log_prefix = 185 [default = ""];
  Specified by:
  
  getLogPrefixBytes in interface SatParametersOrBuilder
  
  Returns:
  
  The bytes for logPrefix.
- hasLogToStdout
  
  public boolean hasLogToStdout()
  Log to stdout.
  optional bool log_to_stdout = 186 [default = true];
  Specified by:
  
  hasLogToStdout in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the logToStdout field is set.
- getLogToStdout
  
  public boolean getLogToStdout()
  Log to stdout.
  optional bool log_to_stdout = 186 [default = true];
  Specified by:
  
  getLogToStdout in interface SatParametersOrBuilder
  
  Returns:
  
  The logToStdout.
- hasLogToResponse
  
  public boolean hasLogToResponse()
  Log to response proto.
  optional bool log_to_response = 187 [default = false];
  Specified by:
  
  hasLogToResponse in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the logToResponse field is set.
- getLogToResponse
  
  public boolean getLogToResponse()
  Log to response proto.
  optional bool log_to_response = 187 [default = false];
  Specified by:
  
  getLogToResponse in interface SatParametersOrBuilder
  
  Returns:
  
  The logToResponse.
- hasUsePbResolution
  
  public boolean hasUsePbResolution()
  Whether to use pseudo-Boolean resolution to analyze a conflict. Note that this option only make sense if your problem is modelized using pseudo-Boolean constraints. If you only have clauses, this shouldn't change anything (except slow the solver down).
  optional bool use_pb_resolution = 43 [default = false];
  Specified by:
  
  hasUsePbResolution in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the usePbResolution field is set.
- getUsePbResolution
  
  public boolean getUsePbResolution()
  Whether to use pseudo-Boolean resolution to analyze a conflict. Note that this option only make sense if your problem is modelized using pseudo-Boolean constraints. If you only have clauses, this shouldn't change anything (except slow the solver down).
  optional bool use_pb_resolution = 43 [default = false];
  Specified by:
  
  getUsePbResolution in interface SatParametersOrBuilder
  
  Returns:
  
  The usePbResolution.
- hasMinimizeReductionDuringPbResolution
  
  public boolean hasMinimizeReductionDuringPbResolution()
  A different algorithm during PB resolution. It minimizes the number of calls to ReduceCoefficients() which can be time consuming. However, the search space will be different and if the coefficients are large, this may lead to integer overflows that could otherwise be prevented.
  optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
  Specified by:
  
  hasMinimizeReductionDuringPbResolution in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the minimizeReductionDuringPbResolution field is set.
- getMinimizeReductionDuringPbResolution
  
  public boolean getMinimizeReductionDuringPbResolution()
  A different algorithm during PB resolution. It minimizes the number of calls to ReduceCoefficients() which can be time consuming. However, the search space will be different and if the coefficients are large, this may lead to integer overflows that could otherwise be prevented.
  optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
  Specified by:
  
  getMinimizeReductionDuringPbResolution in interface SatParametersOrBuilder
  
  Returns:
  
  The minimizeReductionDuringPbResolution.
- hasCountAssumptionLevelsInLbd
  
  public boolean hasCountAssumptionLevelsInLbd()
  Whether or not the assumption levels are taken into account during the LBD computation. According to the reference below, not counting them improves the solver in some situation. Note that this only impact solves under assumptions. Gilles Audemard, Jean-Marie Lagniez, Laurent Simon, "Improving Glucose for Incremental SAT Solving with Assumptions: Application to MUS Extraction" Theory and Applications of Satisfiability Testing - SAT 2013, Lecture Notes in Computer Science Volume 7962, 2013, pp 309-317.
  optional bool count_assumption_levels_in_lbd = 49 [default = true];
  Specified by:
  
  hasCountAssumptionLevelsInLbd in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the countAssumptionLevelsInLbd field is set.
- getCountAssumptionLevelsInLbd
  
  public boolean getCountAssumptionLevelsInLbd()
  Whether or not the assumption levels are taken into account during the LBD computation. According to the reference below, not counting them improves the solver in some situation. Note that this only impact solves under assumptions. Gilles Audemard, Jean-Marie Lagniez, Laurent Simon, "Improving Glucose for Incremental SAT Solving with Assumptions: Application to MUS Extraction" Theory and Applications of Satisfiability Testing - SAT 2013, Lecture Notes in Computer Science Volume 7962, 2013, pp 309-317.
  optional bool count_assumption_levels_in_lbd = 49 [default = true];
  Specified by:
  
  getCountAssumptionLevelsInLbd in interface SatParametersOrBuilder
  
  Returns:
  
  The countAssumptionLevelsInLbd.
- hasPresolveBveThreshold
  
  public boolean hasPresolveBveThreshold()
  During presolve, only try to perform the bounded variable elimination (BVE) of a variable x if the number of occurrences of x times the number of occurrences of not(x) is not greater than this parameter.
  optional int32 presolve_bve_threshold = 54 [default = 500];
  Specified by:
  
  hasPresolveBveThreshold in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the presolveBveThreshold field is set.
- getPresolveBveThreshold
  
  public int getPresolveBveThreshold()
  During presolve, only try to perform the bounded variable elimination (BVE) of a variable x if the number of occurrences of x times the number of occurrences of not(x) is not greater than this parameter.
  optional int32 presolve_bve_threshold = 54 [default = 500];
  Specified by:
  
  getPresolveBveThreshold in interface SatParametersOrBuilder
  
  Returns:
  
  The presolveBveThreshold.
- hasPresolveBveClauseWeight
  
  public boolean hasPresolveBveClauseWeight()
  During presolve, we apply BVE only if this weight times the number of clauses plus the number of clause literals is not increased.
  optional int32 presolve_bve_clause_weight = 55 [default = 3];
  Specified by:
  
  hasPresolveBveClauseWeight in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the presolveBveClauseWeight field is set.
- getPresolveBveClauseWeight
  
  public int getPresolveBveClauseWeight()
  During presolve, we apply BVE only if this weight times the number of clauses plus the number of clause literals is not increased.
  optional int32 presolve_bve_clause_weight = 55 [default = 3];
  Specified by:
  
  getPresolveBveClauseWeight in interface SatParametersOrBuilder
  
  Returns:
  
  The presolveBveClauseWeight.
- hasPresolveProbingDeterministicTimeLimit
  
  public boolean hasPresolveProbingDeterministicTimeLimit()
  The maximum "deterministic" time limit to spend in probing. A value of zero will disable the probing.
  optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
  Specified by:
  
  hasPresolveProbingDeterministicTimeLimit in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the presolveProbingDeterministicTimeLimit field is set.
- getPresolveProbingDeterministicTimeLimit
  
  public double getPresolveProbingDeterministicTimeLimit()
  The maximum "deterministic" time limit to spend in probing. A value of zero will disable the probing.
  optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
  Specified by:
  
  getPresolveProbingDeterministicTimeLimit in interface SatParametersOrBuilder
  
  Returns:
  
  The presolveProbingDeterministicTimeLimit.
- hasPresolveBlockedClause
  
  public boolean hasPresolveBlockedClause()
  Whether we use an heuristic to detect some basic case of blocked clause in the SAT presolve.
  optional bool presolve_blocked_clause = 88 [default = true];
  Specified by:
  
  hasPresolveBlockedClause in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the presolveBlockedClause field is set.
- getPresolveBlockedClause
  
  public boolean getPresolveBlockedClause()
  Whether we use an heuristic to detect some basic case of blocked clause in the SAT presolve.
  optional bool presolve_blocked_clause = 88 [default = true];
  Specified by:
  
  getPresolveBlockedClause in interface SatParametersOrBuilder
  
  Returns:
  
  The presolveBlockedClause.
- hasPresolveUseBva
  
  public boolean hasPresolveUseBva()
  Whether or not we use Bounded Variable Addition (BVA) in the presolve.
  optional bool presolve_use_bva = 72 [default = true];
  Specified by:
  
  hasPresolveUseBva in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the presolveUseBva field is set.
- getPresolveUseBva
  
  public boolean getPresolveUseBva()
  Whether or not we use Bounded Variable Addition (BVA) in the presolve.
  optional bool presolve_use_bva = 72 [default = true];
  Specified by:
  
  getPresolveUseBva in interface SatParametersOrBuilder
  
  Returns:
  
  The presolveUseBva.
- hasPresolveBvaThreshold
  
  public boolean hasPresolveBvaThreshold()
  Apply Bounded Variable Addition (BVA) if the number of clauses is reduced by stricly more than this threshold. The algorithm described in the paper uses 0, but quick experiments showed that 1 is a good value. It may not be worth it to add a new variable just to remove one clause.
  optional int32 presolve_bva_threshold = 73 [default = 1];
  Specified by:
  
  hasPresolveBvaThreshold in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the presolveBvaThreshold field is set.
- getPresolveBvaThreshold
  
  public int getPresolveBvaThreshold()
  Apply Bounded Variable Addition (BVA) if the number of clauses is reduced by stricly more than this threshold. The algorithm described in the paper uses 0, but quick experiments showed that 1 is a good value. It may not be worth it to add a new variable just to remove one clause.
  optional int32 presolve_bva_threshold = 73 [default = 1];
  Specified by:
  
  getPresolveBvaThreshold in interface SatParametersOrBuilder
  
  Returns:
  
  The presolveBvaThreshold.
- hasMaxPresolveIterations
  
  public boolean hasMaxPresolveIterations()
  In case of large reduction in a presolve iteration, we perform multiple presolve iterations. This parameter controls the maximum number of such presolve iterations.
  optional int32 max_presolve_iterations = 138 [default = 3];
  Specified by:
  
  hasMaxPresolveIterations in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxPresolveIterations field is set.
- getMaxPresolveIterations
  
  public int getMaxPresolveIterations()
  In case of large reduction in a presolve iteration, we perform multiple presolve iterations. This parameter controls the maximum number of such presolve iterations.
  optional int32 max_presolve_iterations = 138 [default = 3];
  Specified by:
  
  getMaxPresolveIterations in interface SatParametersOrBuilder
  
  Returns:
  
  The maxPresolveIterations.
- hasCpModelPresolve
  
  public boolean hasCpModelPresolve()
  Whether we presolve the cp_model before solving it.
  optional bool cp_model_presolve = 86 [default = true];
  Specified by:
  
  hasCpModelPresolve in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the cpModelPresolve field is set.
- getCpModelPresolve
  
  public boolean getCpModelPresolve()
  Whether we presolve the cp_model before solving it.
  optional bool cp_model_presolve = 86 [default = true];
  Specified by:
  
  getCpModelPresolve in interface SatParametersOrBuilder
  
  Returns:
  
  The cpModelPresolve.
- hasCpModelPostsolveWithFullSolver
  
  public boolean hasCpModelPostsolveWithFullSolver()
  Advanced usage. We have two different postsolve code. The default one should be better and it allows for a more powerful presolve, but some rarely used features like not fully assigning all variables require the other one.
  optional bool cp_model_postsolve_with_full_solver = 162 [default = false];
  Specified by:
  
  hasCpModelPostsolveWithFullSolver in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the cpModelPostsolveWithFullSolver field is set.
- getCpModelPostsolveWithFullSolver
  
  public boolean getCpModelPostsolveWithFullSolver()
  Advanced usage. We have two different postsolve code. The default one should be better and it allows for a more powerful presolve, but some rarely used features like not fully assigning all variables require the other one.
  optional bool cp_model_postsolve_with_full_solver = 162 [default = false];
  Specified by:
  
  getCpModelPostsolveWithFullSolver in interface SatParametersOrBuilder
  
  Returns:
  
  The cpModelPostsolveWithFullSolver.
- hasCpModelMaxNumPresolveOperations
  
  public boolean hasCpModelMaxNumPresolveOperations()
  If positive, try to stop just after that many presolve rules have been applied. This is mainly useful for debugging presolve.
  optional int32 cp_model_max_num_presolve_operations = 151 [default = 0];
  Specified by:
  
  hasCpModelMaxNumPresolveOperations in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the cpModelMaxNumPresolveOperations field is set.
- getCpModelMaxNumPresolveOperations
  
  public int getCpModelMaxNumPresolveOperations()
  If positive, try to stop just after that many presolve rules have been applied. This is mainly useful for debugging presolve.
  optional int32 cp_model_max_num_presolve_operations = 151 [default = 0];
  Specified by:
  
  getCpModelMaxNumPresolveOperations in interface SatParametersOrBuilder
  
  Returns:
  
  The cpModelMaxNumPresolveOperations.
- hasCpModelProbingLevel
  
  public boolean hasCpModelProbingLevel()
  How much effort do we spend on probing. 0 disables it completely.
  optional int32 cp_model_probing_level = 110 [default = 2];
  Specified by:
  
  hasCpModelProbingLevel in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the cpModelProbingLevel field is set.
- getCpModelProbingLevel
  
  public int getCpModelProbingLevel()
  How much effort do we spend on probing. 0 disables it completely.
  optional int32 cp_model_probing_level = 110 [default = 2];
  Specified by:
  
  getCpModelProbingLevel in interface SatParametersOrBuilder
  
  Returns:
  
  The cpModelProbingLevel.
- hasCpModelUseSatPresolve
  
  public boolean hasCpModelUseSatPresolve()
  Whether we also use the sat presolve when cp_model_presolve is true.
  optional bool cp_model_use_sat_presolve = 93 [default = true];
  Specified by:
  
  hasCpModelUseSatPresolve in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the cpModelUseSatPresolve field is set.
- getCpModelUseSatPresolve
  
  public boolean getCpModelUseSatPresolve()
  Whether we also use the sat presolve when cp_model_presolve is true.
  optional bool cp_model_use_sat_presolve = 93 [default = true];
  Specified by:
  
  getCpModelUseSatPresolve in interface SatParametersOrBuilder
  
  Returns:
  
  The cpModelUseSatPresolve.
- hasUseSatInprocessing
  
  public boolean hasUseSatInprocessing()
  
  optional bool use_sat_inprocessing = 163 [default = false];
  
  Specified by:
  
  hasUseSatInprocessing in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useSatInprocessing field is set.
- getUseSatInprocessing
  
  public boolean getUseSatInprocessing()
  
  optional bool use_sat_inprocessing = 163 [default = false];
  
  Specified by:
  
  getUseSatInprocessing in interface SatParametersOrBuilder
  
  Returns:
  
  The useSatInprocessing.
- hasExpandElementConstraints
  
  public boolean hasExpandElementConstraints()
  If true, the element constraints are expanded into many linear constraints of the form (index == i) => (element[i] == target).
  optional bool expand_element_constraints = 140 [default = true];
  Specified by:
  
  hasExpandElementConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the expandElementConstraints field is set.
- getExpandElementConstraints
  
  public boolean getExpandElementConstraints()
  If true, the element constraints are expanded into many linear constraints of the form (index == i) => (element[i] == target).
  optional bool expand_element_constraints = 140 [default = true];
  Specified by:
  
  getExpandElementConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  The expandElementConstraints.
- hasExpandAutomatonConstraints
  
  public boolean hasExpandAutomatonConstraints()
  If true, the automaton constraints are expanded.
  optional bool expand_automaton_constraints = 143 [default = true];
  Specified by:
  
  hasExpandAutomatonConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the expandAutomatonConstraints field is set.
- getExpandAutomatonConstraints
  
  public boolean getExpandAutomatonConstraints()
  If true, the automaton constraints are expanded.
  optional bool expand_automaton_constraints = 143 [default = true];
  Specified by:
  
  getExpandAutomatonConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  The expandAutomatonConstraints.
- hasExpandTableConstraints
  
  public boolean hasExpandTableConstraints()
  If true, the positive table constraints are expanded. Note that currently, negative table constraints are always expanded.
  optional bool expand_table_constraints = 158 [default = true];
  Specified by:
  
  hasExpandTableConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the expandTableConstraints field is set.
- getExpandTableConstraints
  
  public boolean getExpandTableConstraints()
  If true, the positive table constraints are expanded. Note that currently, negative table constraints are always expanded.
  optional bool expand_table_constraints = 158 [default = true];
  Specified by:
  
  getExpandTableConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  The expandTableConstraints.
- hasExpandAlldiffConstraints
  
  public boolean hasExpandAlldiffConstraints()
  If true, expand all_different constraints that are not permutations. Permutations (#Variables = #Values) are always expanded.
  optional bool expand_alldiff_constraints = 170 [default = false];
  Specified by:
  
  hasExpandAlldiffConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the expandAlldiffConstraints field is set.
- getExpandAlldiffConstraints
  
  public boolean getExpandAlldiffConstraints()
  If true, expand all_different constraints that are not permutations. Permutations (#Variables = #Values) are always expanded.
  optional bool expand_alldiff_constraints = 170 [default = false];
  Specified by:
  
  getExpandAlldiffConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  The expandAlldiffConstraints.
- hasExpandReservoirConstraints
  
  public boolean hasExpandReservoirConstraints()
  If true, expand the reservoir constraints by creating booleans for all possible precedences between event and encoding the constraint.
  optional bool expand_reservoir_constraints = 182 [default = true];
  Specified by:
  
  hasExpandReservoirConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the expandReservoirConstraints field is set.
- getExpandReservoirConstraints
  
  public boolean getExpandReservoirConstraints()
  If true, expand the reservoir constraints by creating booleans for all possible precedences between event and encoding the constraint.
  optional bool expand_reservoir_constraints = 182 [default = true];
  Specified by:
  
  getExpandReservoirConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  The expandReservoirConstraints.
- hasDisableConstraintExpansion
  
  public boolean hasDisableConstraintExpansion()
  If true, it disable all constraint expansion. This should only be used to test the presolve of expanded constraints.
  optional bool disable_constraint_expansion = 181 [default = false];
  Specified by:
  
  hasDisableConstraintExpansion in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the disableConstraintExpansion field is set.
- getDisableConstraintExpansion
  
  public boolean getDisableConstraintExpansion()
  If true, it disable all constraint expansion. This should only be used to test the presolve of expanded constraints.
  optional bool disable_constraint_expansion = 181 [default = false];
  Specified by:
  
  getDisableConstraintExpansion in interface SatParametersOrBuilder
  
  Returns:
  
  The disableConstraintExpansion.
- hasMergeNoOverlapWorkLimit
  
  public boolean hasMergeNoOverlapWorkLimit()
  During presolve, we use a maximum clique heuristic to merge together no-overlap constraints or at most one constraints. This code can be slow, so we have a limit in place on the number of explored nodes in the underlying graph. The internal limit is an int64, but we use double here to simplify manual input.
  optional double merge_no_overlap_work_limit = 145 [default = 1000000000000];
  Specified by:
  
  hasMergeNoOverlapWorkLimit in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the mergeNoOverlapWorkLimit field is set.
- getMergeNoOverlapWorkLimit
  
  public double getMergeNoOverlapWorkLimit()
  During presolve, we use a maximum clique heuristic to merge together no-overlap constraints or at most one constraints. This code can be slow, so we have a limit in place on the number of explored nodes in the underlying graph. The internal limit is an int64, but we use double here to simplify manual input.
  optional double merge_no_overlap_work_limit = 145 [default = 1000000000000];
  Specified by:
  
  getMergeNoOverlapWorkLimit in interface SatParametersOrBuilder
  
  Returns:
  
  The mergeNoOverlapWorkLimit.
- hasMergeAtMostOneWorkLimit
  
  public boolean hasMergeAtMostOneWorkLimit()
  
  optional double merge_at_most_one_work_limit = 146 [default = 100000000];
  
  Specified by:
  
  hasMergeAtMostOneWorkLimit in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the mergeAtMostOneWorkLimit field is set.
- getMergeAtMostOneWorkLimit
  
  public double getMergeAtMostOneWorkLimit()
  
  optional double merge_at_most_one_work_limit = 146 [default = 100000000];
  
  Specified by:
  
  getMergeAtMostOneWorkLimit in interface SatParametersOrBuilder
  
  Returns:
  
  The mergeAtMostOneWorkLimit.
- hasPresolveSubstitutionLevel
  
  public boolean hasPresolveSubstitutionLevel()
  How much substitution (also called free variable aggregation in MIP litterature) should we perform at presolve. This currently only concerns variable appearing only in linear constraints. For now the value 0 turns it off and any positive value performs substitution.
  optional int32 presolve_substitution_level = 147 [default = 1];
  Specified by:
  
  hasPresolveSubstitutionLevel in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the presolveSubstitutionLevel field is set.
- getPresolveSubstitutionLevel
  
  public int getPresolveSubstitutionLevel()
  How much substitution (also called free variable aggregation in MIP litterature) should we perform at presolve. This currently only concerns variable appearing only in linear constraints. For now the value 0 turns it off and any positive value performs substitution.
  optional int32 presolve_substitution_level = 147 [default = 1];
  Specified by:
  
  getPresolveSubstitutionLevel in interface SatParametersOrBuilder
  
  Returns:
  
  The presolveSubstitutionLevel.
- hasPresolveExtractIntegerEnforcement
  
  public boolean hasPresolveExtractIntegerEnforcement()
  If true, we will extract from linear constraints, enforcement literals of the form "integer variable at bound => simplified constraint". This should always be beneficial except that we don't always handle them as efficiently as we could for now. This causes problem on manna81.mps (LP relaxation not as tight it seems) and on neos-3354841-apure.mps.gz (too many literals created this way).
  optional bool presolve_extract_integer_enforcement = 174 [default = false];
  Specified by:
  
  hasPresolveExtractIntegerEnforcement in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the presolveExtractIntegerEnforcement field is set.
- getPresolveExtractIntegerEnforcement
  
  public boolean getPresolveExtractIntegerEnforcement()
  If true, we will extract from linear constraints, enforcement literals of the form "integer variable at bound => simplified constraint". This should always be beneficial except that we don't always handle them as efficiently as we could for now. This causes problem on manna81.mps (LP relaxation not as tight it seems) and on neos-3354841-apure.mps.gz (too many literals created this way).
  optional bool presolve_extract_integer_enforcement = 174 [default = false];
  Specified by:
  
  getPresolveExtractIntegerEnforcement in interface SatParametersOrBuilder
  
  Returns:
  
  The presolveExtractIntegerEnforcement.
- hasUseOptimizationHints
  
  public boolean hasUseOptimizationHints()
  For an optimization problem, whether we follow some hints in order to find a better first solution. For a variable with hint, the solver will always try to follow the hint. It will revert to the variable_branching default otherwise.
  optional bool use_optimization_hints = 35 [default = true];
  Specified by:
  
  hasUseOptimizationHints in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useOptimizationHints field is set.
- getUseOptimizationHints
  
  public boolean getUseOptimizationHints()
  For an optimization problem, whether we follow some hints in order to find a better first solution. For a variable with hint, the solver will always try to follow the hint. It will revert to the variable_branching default otherwise.
  optional bool use_optimization_hints = 35 [default = true];
  Specified by:
  
  getUseOptimizationHints in interface SatParametersOrBuilder
  
  Returns:
  
  The useOptimizationHints.
- hasMinimizeCore
  
  public boolean hasMinimizeCore()
  Whether we use a simple heuristic to try to minimize an UNSAT core.
  optional bool minimize_core = 50 [default = true];
  Specified by:
  
  hasMinimizeCore in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the minimizeCore field is set.
- getMinimizeCore
  
  public boolean getMinimizeCore()
  Whether we use a simple heuristic to try to minimize an UNSAT core.
  optional bool minimize_core = 50 [default = true];
  Specified by:
  
  getMinimizeCore in interface SatParametersOrBuilder
  
  Returns:
  
  The minimizeCore.
- hasFindMultipleCores
  
  public boolean hasFindMultipleCores()
  Whether we try to find more independent cores for a given set of assumptions in the core based max-SAT algorithms.
  optional bool find_multiple_cores = 84 [default = true];
  Specified by:
  
  hasFindMultipleCores in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the findMultipleCores field is set.
- getFindMultipleCores
  
  public boolean getFindMultipleCores()
  Whether we try to find more independent cores for a given set of assumptions in the core based max-SAT algorithms.
  optional bool find_multiple_cores = 84 [default = true];
  Specified by:
  
  getFindMultipleCores in interface SatParametersOrBuilder
  
  Returns:
  
  The findMultipleCores.
- hasCoverOptimization
  
  public boolean hasCoverOptimization()
  If true, when the max-sat algo find a core, we compute the minimal number of literals in the core that needs to be true to have a feasible solution.
  optional bool cover_optimization = 89 [default = true];
  Specified by:
  
  hasCoverOptimization in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the coverOptimization field is set.
- getCoverOptimization
  
  public boolean getCoverOptimization()
  If true, when the max-sat algo find a core, we compute the minimal number of literals in the core that needs to be true to have a feasible solution.
  optional bool cover_optimization = 89 [default = true];
  Specified by:
  
  getCoverOptimization in interface SatParametersOrBuilder
  
  Returns:
  
  The coverOptimization.
- hasMaxSatAssumptionOrder
  
  public boolean hasMaxSatAssumptionOrder()
  
  optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
  
  Specified by:
  
  hasMaxSatAssumptionOrder in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxSatAssumptionOrder field is set.
- getMaxSatAssumptionOrder
  
  public SatParameters.MaxSatAssumptionOrder getMaxSatAssumptionOrder()
  
  optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
  
  Specified by:
  
  getMaxSatAssumptionOrder in interface SatParametersOrBuilder
  
  Returns:
  
  The maxSatAssumptionOrder.
- hasMaxSatReverseAssumptionOrder
  
  public boolean hasMaxSatReverseAssumptionOrder()
  If true, adds the assumption in the reverse order of the one defined by max_sat_assumption_order.
  optional bool max_sat_reverse_assumption_order = 52 [default = false];
  Specified by:
  
  hasMaxSatReverseAssumptionOrder in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxSatReverseAssumptionOrder field is set.
- getMaxSatReverseAssumptionOrder
  
  public boolean getMaxSatReverseAssumptionOrder()
  If true, adds the assumption in the reverse order of the one defined by max_sat_assumption_order.
  optional bool max_sat_reverse_assumption_order = 52 [default = false];
  Specified by:
  
  getMaxSatReverseAssumptionOrder in interface SatParametersOrBuilder
  
  Returns:
  
  The maxSatReverseAssumptionOrder.
- hasMaxSatStratification
  
  public boolean hasMaxSatStratification()
  
  optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
  
  Specified by:
  
  hasMaxSatStratification in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxSatStratification field is set.
- getMaxSatStratification
  
  public SatParameters.MaxSatStratificationAlgorithm getMaxSatStratification()
  
  optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
  
  Specified by:
  
  getMaxSatStratification in interface SatParametersOrBuilder
  
  Returns:
  
  The maxSatStratification.
- hasUsePrecedencesInDisjunctiveConstraint
  
  public boolean hasUsePrecedencesInDisjunctiveConstraint()
  When this is true, then a disjunctive constraint will try to use the precedence relations between time intervals to propagate their bounds further. For instance if task A and B are both before C and task A and B are in disjunction, then we can deduce that task C must start after duration(A) + duration(B) instead of simply max(duration(A), duration(B)), provided that the start time for all task was currently zero. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
  Specified by:
  
  hasUsePrecedencesInDisjunctiveConstraint in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the usePrecedencesInDisjunctiveConstraint field is set.
- getUsePrecedencesInDisjunctiveConstraint
  
  public boolean getUsePrecedencesInDisjunctiveConstraint()
  When this is true, then a disjunctive constraint will try to use the precedence relations between time intervals to propagate their bounds further. For instance if task A and B are both before C and task A and B are in disjunction, then we can deduce that task C must start after duration(A) + duration(B) instead of simply max(duration(A), duration(B)), provided that the start time for all task was currently zero. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
  Specified by:
  
  getUsePrecedencesInDisjunctiveConstraint in interface SatParametersOrBuilder
  
  Returns:
  
  The usePrecedencesInDisjunctiveConstraint.
- hasUseOverloadCheckerInCumulativeConstraint
  
  public boolean hasUseOverloadCheckerInCumulativeConstraint()
  When this is true, the cumulative constraint is reinforced with overload checking, i.e., an additional level of reasoning based on energy. This additional level supplements the default level of reasoning as well as timetable edge finding. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_overload_checker_in_cumulative_constraint = 78 [default = false];
  Specified by:
  
  hasUseOverloadCheckerInCumulativeConstraint in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useOverloadCheckerInCumulativeConstraint field is set.
- getUseOverloadCheckerInCumulativeConstraint
  
  public boolean getUseOverloadCheckerInCumulativeConstraint()
  When this is true, the cumulative constraint is reinforced with overload checking, i.e., an additional level of reasoning based on energy. This additional level supplements the default level of reasoning as well as timetable edge finding. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_overload_checker_in_cumulative_constraint = 78 [default = false];
  Specified by:
  
  getUseOverloadCheckerInCumulativeConstraint in interface SatParametersOrBuilder
  
  Returns:
  
  The useOverloadCheckerInCumulativeConstraint.
- hasUseTimetableEdgeFindingInCumulativeConstraint
  
  public boolean hasUseTimetableEdgeFindingInCumulativeConstraint()
  When this is true, the cumulative constraint is reinforced with timetable edge finding, i.e., an additional level of reasoning based on the conjunction of energy and mandatory parts. This additional level supplements the default level of reasoning as well as overload_checker. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_timetable_edge_finding_in_cumulative_constraint = 79 [default = false];
  Specified by:
  
  hasUseTimetableEdgeFindingInCumulativeConstraint in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useTimetableEdgeFindingInCumulativeConstraint field is set.
- getUseTimetableEdgeFindingInCumulativeConstraint
  
  public boolean getUseTimetableEdgeFindingInCumulativeConstraint()
  When this is true, the cumulative constraint is reinforced with timetable edge finding, i.e., an additional level of reasoning based on the conjunction of energy and mandatory parts. This additional level supplements the default level of reasoning as well as overload_checker. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_timetable_edge_finding_in_cumulative_constraint = 79 [default = false];
  Specified by:
  
  getUseTimetableEdgeFindingInCumulativeConstraint in interface SatParametersOrBuilder
  
  Returns:
  
  The useTimetableEdgeFindingInCumulativeConstraint.
- hasUseDisjunctiveConstraintInCumulativeConstraint
  
  public boolean hasUseDisjunctiveConstraintInCumulativeConstraint()
  When this is true, the cumulative constraint is reinforced with propagators from the disjunctive constraint to improve the inference on a set of tasks that are disjunctive at the root of the problem. This additional level supplements the default level of reasoning. Propagators of the cumulative constraint will not be used at all if all the tasks are disjunctive at root node. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_disjunctive_constraint_in_cumulative_constraint = 80 [default = true];
  Specified by:
  
  hasUseDisjunctiveConstraintInCumulativeConstraint in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useDisjunctiveConstraintInCumulativeConstraint field is set.
- getUseDisjunctiveConstraintInCumulativeConstraint
  
  public boolean getUseDisjunctiveConstraintInCumulativeConstraint()
  When this is true, the cumulative constraint is reinforced with propagators from the disjunctive constraint to improve the inference on a set of tasks that are disjunctive at the root of the problem. This additional level supplements the default level of reasoning. Propagators of the cumulative constraint will not be used at all if all the tasks are disjunctive at root node. This always result in better propagation, but it is usually slow, so depending on the problem, turning this off may lead to a faster solution.
  optional bool use_disjunctive_constraint_in_cumulative_constraint = 80 [default = true];
  Specified by:
  
  getUseDisjunctiveConstraintInCumulativeConstraint in interface SatParametersOrBuilder
  
  Returns:
  
  The useDisjunctiveConstraintInCumulativeConstraint.
- hasLinearizationLevel
  
  public boolean hasLinearizationLevel()
  A non-negative level indicating the type of constraints we consider in the LP relaxation. At level zero, no LP relaxation is used. At level 1, only the linear constraint and full encoding are added. At level 2, we also add all the Boolean constraints.
  optional int32 linearization_level = 90 [default = 1];
  Specified by:
  
  hasLinearizationLevel in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the linearizationLevel field is set.
- getLinearizationLevel
  
  public int getLinearizationLevel()
  A non-negative level indicating the type of constraints we consider in the LP relaxation. At level zero, no LP relaxation is used. At level 1, only the linear constraint and full encoding are added. At level 2, we also add all the Boolean constraints.
  optional int32 linearization_level = 90 [default = 1];
  Specified by:
  
  getLinearizationLevel in interface SatParametersOrBuilder
  
  Returns:
  
  The linearizationLevel.
- hasBooleanEncodingLevel
  
  public boolean hasBooleanEncodingLevel()
  A non-negative level indicating how much we should try to fully encode Integer variables as Boolean.
  optional int32 boolean_encoding_level = 107 [default = 1];
  Specified by:
  
  hasBooleanEncodingLevel in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the booleanEncodingLevel field is set.
- getBooleanEncodingLevel
  
  public int getBooleanEncodingLevel()
  A non-negative level indicating how much we should try to fully encode Integer variables as Boolean.
  optional int32 boolean_encoding_level = 107 [default = 1];
  Specified by:
  
  getBooleanEncodingLevel in interface SatParametersOrBuilder
  
  Returns:
  
  The booleanEncodingLevel.
- hasMaxNumCuts
  
  public boolean hasMaxNumCuts()
  The limit on the number of cuts in our cut pool. When this is reached we do not generate cuts anymore. TODO(user): We should probably remove this parameters, and just always generate cuts but only keep the best n or something.
  optional int32 max_num_cuts = 91 [default = 10000];
  Specified by:
  
  hasMaxNumCuts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxNumCuts field is set.
- getMaxNumCuts
  
  public int getMaxNumCuts()
  The limit on the number of cuts in our cut pool. When this is reached we do not generate cuts anymore. TODO(user): We should probably remove this parameters, and just always generate cuts but only keep the best n or something.
  optional int32 max_num_cuts = 91 [default = 10000];
  Specified by:
  
  getMaxNumCuts in interface SatParametersOrBuilder
  
  Returns:
  
  The maxNumCuts.
- hasOnlyAddCutsAtLevelZero
  
  public boolean hasOnlyAddCutsAtLevelZero()
  For the cut that can be generated at any level, this control if we only try to generate them at the root node.
  optional bool only_add_cuts_at_level_zero = 92 [default = false];
  Specified by:
  
  hasOnlyAddCutsAtLevelZero in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the onlyAddCutsAtLevelZero field is set.
- getOnlyAddCutsAtLevelZero
  
  public boolean getOnlyAddCutsAtLevelZero()
  For the cut that can be generated at any level, this control if we only try to generate them at the root node.
  optional bool only_add_cuts_at_level_zero = 92 [default = false];
  Specified by:
  
  getOnlyAddCutsAtLevelZero in interface SatParametersOrBuilder
  
  Returns:
  
  The onlyAddCutsAtLevelZero.
- hasAddKnapsackCuts
  
  public boolean hasAddKnapsackCuts()
  Whether we generate knapsack cuts. Note that in our setting where all variables are integer and bounded on both side, such a cut could be applied to any constraint.
  optional bool add_knapsack_cuts = 111 [default = false];
  Specified by:
  
  hasAddKnapsackCuts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the addKnapsackCuts field is set.
- getAddKnapsackCuts
  
  public boolean getAddKnapsackCuts()
  Whether we generate knapsack cuts. Note that in our setting where all variables are integer and bounded on both side, such a cut could be applied to any constraint.
  optional bool add_knapsack_cuts = 111 [default = false];
  Specified by:
  
  getAddKnapsackCuts in interface SatParametersOrBuilder
  
  Returns:
  
  The addKnapsackCuts.
- hasAddCgCuts
  
  public boolean hasAddCgCuts()
  Whether we generate and add Chvatal-Gomory cuts to the LP at root node. Note that for now, this is not heavily tuned.
  optional bool add_cg_cuts = 117 [default = true];
  Specified by:
  
  hasAddCgCuts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the addCgCuts field is set.
- getAddCgCuts
  
  public boolean getAddCgCuts()
  Whether we generate and add Chvatal-Gomory cuts to the LP at root node. Note that for now, this is not heavily tuned.
  optional bool add_cg_cuts = 117 [default = true];
  Specified by:
  
  getAddCgCuts in interface SatParametersOrBuilder
  
  Returns:
  
  The addCgCuts.
- hasAddMirCuts
  
  public boolean hasAddMirCuts()
  Whether we generate MIR cuts at root node. Note that for now, this is not heavily tuned.
  optional bool add_mir_cuts = 120 [default = true];
  Specified by:
  
  hasAddMirCuts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the addMirCuts field is set.
- getAddMirCuts
  
  public boolean getAddMirCuts()
  Whether we generate MIR cuts at root node. Note that for now, this is not heavily tuned.
  optional bool add_mir_cuts = 120 [default = true];
  Specified by:
  
  getAddMirCuts in interface SatParametersOrBuilder
  
  Returns:
  
  The addMirCuts.
- hasAddZeroHalfCuts
  
  public boolean hasAddZeroHalfCuts()
  Whether we generate Zero-Half cuts at root node. Note that for now, this is not heavily tuned.
  optional bool add_zero_half_cuts = 169 [default = true];
  Specified by:
  
  hasAddZeroHalfCuts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the addZeroHalfCuts field is set.
- getAddZeroHalfCuts
  
  public boolean getAddZeroHalfCuts()
  Whether we generate Zero-Half cuts at root node. Note that for now, this is not heavily tuned.
  optional bool add_zero_half_cuts = 169 [default = true];
  Specified by:
  
  getAddZeroHalfCuts in interface SatParametersOrBuilder
  
  Returns:
  
  The addZeroHalfCuts.
- hasAddCliqueCuts
  
  public boolean hasAddCliqueCuts()
  Whether we generate clique cuts from the binary implication graph. Note that as the search goes on, this graph will contains new binary clauses learned by the SAT engine.
  optional bool add_clique_cuts = 172 [default = true];
  Specified by:
  
  hasAddCliqueCuts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the addCliqueCuts field is set.
- getAddCliqueCuts
  
  public boolean getAddCliqueCuts()
  Whether we generate clique cuts from the binary implication graph. Note that as the search goes on, this graph will contains new binary clauses learned by the SAT engine.
  optional bool add_clique_cuts = 172 [default = true];
  Specified by:
  
  getAddCliqueCuts in interface SatParametersOrBuilder
  
  Returns:
  
  The addCliqueCuts.
- hasMaxAllDiffCutSize
  
  public boolean hasMaxAllDiffCutSize()
  Cut generator for all diffs can add too many cuts for large all_diff constraints. This parameter restricts the large all_diff constraints to have a cut generator.
  optional int32 max_all_diff_cut_size = 148 [default = 7];
  Specified by:
  
  hasMaxAllDiffCutSize in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxAllDiffCutSize field is set.
- getMaxAllDiffCutSize
  
  public int getMaxAllDiffCutSize()
  Cut generator for all diffs can add too many cuts for large all_diff constraints. This parameter restricts the large all_diff constraints to have a cut generator.
  optional int32 max_all_diff_cut_size = 148 [default = 7];
  Specified by:
  
  getMaxAllDiffCutSize in interface SatParametersOrBuilder
  
  Returns:
  
  The maxAllDiffCutSize.
- hasAddLinMaxCuts
  
  public boolean hasAddLinMaxCuts()
  For the lin max constraints, generates the cuts described in "Strong mixed-integer programming formulations for trained neural networks" by Ross Anderson et. (https://arxiv.org/pdf/1811.01988.pdf)
  optional bool add_lin_max_cuts = 152 [default = true];
  Specified by:
  
  hasAddLinMaxCuts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the addLinMaxCuts field is set.
- getAddLinMaxCuts
  
  public boolean getAddLinMaxCuts()
  For the lin max constraints, generates the cuts described in "Strong mixed-integer programming formulations for trained neural networks" by Ross Anderson et. (https://arxiv.org/pdf/1811.01988.pdf)
  optional bool add_lin_max_cuts = 152 [default = true];
  Specified by:
  
  getAddLinMaxCuts in interface SatParametersOrBuilder
  
  Returns:
  
  The addLinMaxCuts.
- hasMaxIntegerRoundingScaling
  
  public boolean hasMaxIntegerRoundingScaling()
  In the integer rounding procedure used for MIR and Gomory cut, the maximum "scaling" we use (must be positive). The lower this is, the lower the integer coefficients of the cut will be. Note that cut generated by lower values are not necessarily worse than cut generated by larger value. There is no strict dominance relationship. Setting this to 2 result in the "strong fractional rouding" of Letchford and Lodi.
  optional int32 max_integer_rounding_scaling = 119 [default = 600];
  Specified by:
  
  hasMaxIntegerRoundingScaling in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxIntegerRoundingScaling field is set.
- getMaxIntegerRoundingScaling
  
  public int getMaxIntegerRoundingScaling()
  In the integer rounding procedure used for MIR and Gomory cut, the maximum "scaling" we use (must be positive). The lower this is, the lower the integer coefficients of the cut will be. Note that cut generated by lower values are not necessarily worse than cut generated by larger value. There is no strict dominance relationship. Setting this to 2 result in the "strong fractional rouding" of Letchford and Lodi.
  optional int32 max_integer_rounding_scaling = 119 [default = 600];
  Specified by:
  
  getMaxIntegerRoundingScaling in interface SatParametersOrBuilder
  
  Returns:
  
  The maxIntegerRoundingScaling.
- hasAddLpConstraintsLazily
  
  public boolean hasAddLpConstraintsLazily()
  If true, we start by an empty LP, and only add constraints not satisfied by the current LP solution batch by batch. A constraint that is only added like this is known as a "lazy" constraint in the literature, except that we currently consider all constraints as lazy here.
  optional bool add_lp_constraints_lazily = 112 [default = true];
  Specified by:
  
  hasAddLpConstraintsLazily in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the addLpConstraintsLazily field is set.
- getAddLpConstraintsLazily
  
  public boolean getAddLpConstraintsLazily()
  If true, we start by an empty LP, and only add constraints not satisfied by the current LP solution batch by batch. A constraint that is only added like this is known as a "lazy" constraint in the literature, except that we currently consider all constraints as lazy here.
  optional bool add_lp_constraints_lazily = 112 [default = true];
  Specified by:
  
  getAddLpConstraintsLazily in interface SatParametersOrBuilder
  
  Returns:
  
  The addLpConstraintsLazily.
- hasMinOrthogonalityForLpConstraints
  
  public boolean hasMinOrthogonalityForLpConstraints()
  While adding constraints, skip the constraints which have orthogonality less than 'min_orthogonality_for_lp_constraints' with already added constraints during current call. Orthogonality is defined as 1 - cosine(vector angle between constraints). A value of zero disable this feature.
  optional double min_orthogonality_for_lp_constraints = 115 [default = 0.05];
  Specified by:
  
  hasMinOrthogonalityForLpConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the minOrthogonalityForLpConstraints field is set.
- getMinOrthogonalityForLpConstraints
  
  public double getMinOrthogonalityForLpConstraints()
  While adding constraints, skip the constraints which have orthogonality less than 'min_orthogonality_for_lp_constraints' with already added constraints during current call. Orthogonality is defined as 1 - cosine(vector angle between constraints). A value of zero disable this feature.
  optional double min_orthogonality_for_lp_constraints = 115 [default = 0.05];
  Specified by:
  
  getMinOrthogonalityForLpConstraints in interface SatParametersOrBuilder
  
  Returns:
  
  The minOrthogonalityForLpConstraints.
- hasMaxCutRoundsAtLevelZero
  
  public boolean hasMaxCutRoundsAtLevelZero()
  Max number of time we perform cut generation and resolve the LP at level 0.
  optional int32 max_cut_rounds_at_level_zero = 154 [default = 1];
  Specified by:
  
  hasMaxCutRoundsAtLevelZero in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxCutRoundsAtLevelZero field is set.
- getMaxCutRoundsAtLevelZero
  
  public int getMaxCutRoundsAtLevelZero()
  Max number of time we perform cut generation and resolve the LP at level 0.
  optional int32 max_cut_rounds_at_level_zero = 154 [default = 1];
  Specified by:
  
  getMaxCutRoundsAtLevelZero in interface SatParametersOrBuilder
  
  Returns:
  
  The maxCutRoundsAtLevelZero.
- hasMaxConsecutiveInactiveCount
  
  public boolean hasMaxConsecutiveInactiveCount()
  If a constraint/cut in LP is not active for that many consecutive OPTIMAL solves, remove it from the LP. Note that it might be added again later if it become violated by the current LP solution.
  optional int32 max_consecutive_inactive_count = 121 [default = 100];
  Specified by:
  
  hasMaxConsecutiveInactiveCount in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the maxConsecutiveInactiveCount field is set.
- getMaxConsecutiveInactiveCount
  
  public int getMaxConsecutiveInactiveCount()
  If a constraint/cut in LP is not active for that many consecutive OPTIMAL solves, remove it from the LP. Note that it might be added again later if it become violated by the current LP solution.
  optional int32 max_consecutive_inactive_count = 121 [default = 100];
  Specified by:
  
  getMaxConsecutiveInactiveCount in interface SatParametersOrBuilder
  
  Returns:
  
  The maxConsecutiveInactiveCount.
- hasCutMaxActiveCountValue
  
  public boolean hasCutMaxActiveCountValue()
  These parameters are similar to sat clause management activity parameters. They are effective only if the number of generated cuts exceed the storage limit. Default values are based on a few experiments on miplib instances.
  optional double cut_max_active_count_value = 155 [default = 10000000000];
  Specified by:
  
  hasCutMaxActiveCountValue in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the cutMaxActiveCountValue field is set.
- getCutMaxActiveCountValue
  
  public double getCutMaxActiveCountValue()
  These parameters are similar to sat clause management activity parameters. They are effective only if the number of generated cuts exceed the storage limit. Default values are based on a few experiments on miplib instances.
  optional double cut_max_active_count_value = 155 [default = 10000000000];
  Specified by:
  
  getCutMaxActiveCountValue in interface SatParametersOrBuilder
  
  Returns:
  
  The cutMaxActiveCountValue.
- hasCutActiveCountDecay
  
  public boolean hasCutActiveCountDecay()
  
  optional double cut_active_count_decay = 156 [default = 0.8];
  
  Specified by:
  
  hasCutActiveCountDecay in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the cutActiveCountDecay field is set.
- getCutActiveCountDecay
  
  public double getCutActiveCountDecay()
  
  optional double cut_active_count_decay = 156 [default = 0.8];
  
  Specified by:
  
  getCutActiveCountDecay in interface SatParametersOrBuilder
  
  Returns:
  
  The cutActiveCountDecay.
- hasCutCleanupTarget
  
  public boolean hasCutCleanupTarget()
  Target number of constraints to remove during cleanup.
  optional int32 cut_cleanup_target = 157 [default = 1000];
  Specified by:
  
  hasCutCleanupTarget in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the cutCleanupTarget field is set.
- getCutCleanupTarget
  
  public int getCutCleanupTarget()
  Target number of constraints to remove during cleanup.
  optional int32 cut_cleanup_target = 157 [default = 1000];
  Specified by:
  
  getCutCleanupTarget in interface SatParametersOrBuilder
  
  Returns:
  
  The cutCleanupTarget.
- hasNewConstraintsBatchSize
  
  public boolean hasNewConstraintsBatchSize()
  Add that many lazy constraints (or cuts) at once in the LP. Note that at the beginning of the solve, we do add more than this.
  optional int32 new_constraints_batch_size = 122 [default = 50];
  Specified by:
  
  hasNewConstraintsBatchSize in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the newConstraintsBatchSize field is set.
- getNewConstraintsBatchSize
  
  public int getNewConstraintsBatchSize()
  Add that many lazy constraints (or cuts) at once in the LP. Note that at the beginning of the solve, we do add more than this.
  optional int32 new_constraints_batch_size = 122 [default = 50];
  Specified by:
  
  getNewConstraintsBatchSize in interface SatParametersOrBuilder
  
  Returns:
  
  The newConstraintsBatchSize.
- hasSearchBranching
  
  public boolean hasSearchBranching()
  
  optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
  
  Specified by:
  
  hasSearchBranching in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the searchBranching field is set.
- getSearchBranching
  
  public SatParameters.SearchBranching getSearchBranching()
  
  optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
  
  Specified by:
  
  getSearchBranching in interface SatParametersOrBuilder
  
  Returns:
  
  The searchBranching.
- hasHintConflictLimit
  
  public boolean hasHintConflictLimit()
  Conflict limit used in the phase that exploit the solution hint.
  optional int32 hint_conflict_limit = 153 [default = 10];
  Specified by:
  
  hasHintConflictLimit in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the hintConflictLimit field is set.
- getHintConflictLimit
  
  public int getHintConflictLimit()
  Conflict limit used in the phase that exploit the solution hint.
  optional int32 hint_conflict_limit = 153 [default = 10];
  Specified by:
  
  getHintConflictLimit in interface SatParametersOrBuilder
  
  Returns:
  
  The hintConflictLimit.
- hasRepairHint
  
  public boolean hasRepairHint()
  If true, the solver tries to repair the solution given in the hint. This search terminates after the 'hint_conflict_limit' is reached and the solver switches to regular search. If false, then we do a FIXED_SEARCH using the hint until the hint_conflict_limit is reached.
  optional bool repair_hint = 167 [default = false];
  Specified by:
  
  hasRepairHint in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the repairHint field is set.
- getRepairHint
  
  public boolean getRepairHint()
  If true, the solver tries to repair the solution given in the hint. This search terminates after the 'hint_conflict_limit' is reached and the solver switches to regular search. If false, then we do a FIXED_SEARCH using the hint until the hint_conflict_limit is reached.
  optional bool repair_hint = 167 [default = false];
  Specified by:
  
  getRepairHint in interface SatParametersOrBuilder
  
  Returns:
  
  The repairHint.
- hasExploitIntegerLpSolution
  
  public boolean hasExploitIntegerLpSolution()
  If true and the Lp relaxation of the problem has an integer optimal solution, try to exploit it. Note that since the LP relaxation may not contain all the constraints, such a solution is not necessarily a solution of the full problem.
  optional bool exploit_integer_lp_solution = 94 [default = true];
  Specified by:
  
  hasExploitIntegerLpSolution in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the exploitIntegerLpSolution field is set.
- getExploitIntegerLpSolution
  
  public boolean getExploitIntegerLpSolution()
  If true and the Lp relaxation of the problem has an integer optimal solution, try to exploit it. Note that since the LP relaxation may not contain all the constraints, such a solution is not necessarily a solution of the full problem.
  optional bool exploit_integer_lp_solution = 94 [default = true];
  Specified by:
  
  getExploitIntegerLpSolution in interface SatParametersOrBuilder
  
  Returns:
  
  The exploitIntegerLpSolution.
- hasExploitAllLpSolution
  
  public boolean hasExploitAllLpSolution()
  If true and the Lp relaxation of the problem has a solution, try to exploit it. This is same as above except in this case the lp solution might not be an integer solution.
  optional bool exploit_all_lp_solution = 116 [default = true];
  Specified by:
  
  hasExploitAllLpSolution in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the exploitAllLpSolution field is set.
- getExploitAllLpSolution
  
  public boolean getExploitAllLpSolution()
  If true and the Lp relaxation of the problem has a solution, try to exploit it. This is same as above except in this case the lp solution might not be an integer solution.
  optional bool exploit_all_lp_solution = 116 [default = true];
  Specified by:
  
  getExploitAllLpSolution in interface SatParametersOrBuilder
  
  Returns:
  
  The exploitAllLpSolution.
- hasExploitBestSolution
  
  public boolean hasExploitBestSolution()
  When branching on a variable, follow the last best solution value.
  optional bool exploit_best_solution = 130 [default = false];
  Specified by:
  
  hasExploitBestSolution in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the exploitBestSolution field is set.
- getExploitBestSolution
  
  public boolean getExploitBestSolution()
  When branching on a variable, follow the last best solution value.
  optional bool exploit_best_solution = 130 [default = false];
  Specified by:
  
  getExploitBestSolution in interface SatParametersOrBuilder
  
  Returns:
  
  The exploitBestSolution.
- hasExploitRelaxationSolution
  
  public boolean hasExploitRelaxationSolution()
  When branching on a variable, follow the last best relaxation solution value. We use the relaxation with the tightest bound on the objective as the best relaxation solution.
  optional bool exploit_relaxation_solution = 161 [default = false];
  Specified by:
  
  hasExploitRelaxationSolution in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the exploitRelaxationSolution field is set.
- getExploitRelaxationSolution
  
  public boolean getExploitRelaxationSolution()
  When branching on a variable, follow the last best relaxation solution value. We use the relaxation with the tightest bound on the objective as the best relaxation solution.
  optional bool exploit_relaxation_solution = 161 [default = false];
  Specified by:
  
  getExploitRelaxationSolution in interface SatParametersOrBuilder
  
  Returns:
  
  The exploitRelaxationSolution.
- hasExploitObjective
  
  public boolean hasExploitObjective()
  When branching an a variable that directly affect the objective, branch on the value that lead to the best objective first.
  optional bool exploit_objective = 131 [default = true];
  Specified by:
  
  hasExploitObjective in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the exploitObjective field is set.
- getExploitObjective
  
  public boolean getExploitObjective()
  When branching an a variable that directly affect the objective, branch on the value that lead to the best objective first.
  optional bool exploit_objective = 131 [default = true];
  Specified by:
  
  getExploitObjective in interface SatParametersOrBuilder
  
  Returns:
  
  The exploitObjective.
- hasProbingPeriodAtRoot
  
  public boolean hasProbingPeriodAtRoot()
  If set at zero (the default), it is disabled. Otherwise the solver attempts probing at every 'probing_period' root node. Period of 1 enables probing at every root node.
  optional int64 probing_period_at_root = 142 [default = 0];
  Specified by:
  
  hasProbingPeriodAtRoot in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the probingPeriodAtRoot field is set.
- getProbingPeriodAtRoot
  
  public long getProbingPeriodAtRoot()
  If set at zero (the default), it is disabled. Otherwise the solver attempts probing at every 'probing_period' root node. Period of 1 enables probing at every root node.
  optional int64 probing_period_at_root = 142 [default = 0];
  Specified by:
  
  getProbingPeriodAtRoot in interface SatParametersOrBuilder
  
  Returns:
  
  The probingPeriodAtRoot.
- hasUseProbingSearch
  
  public boolean hasUseProbingSearch()
  If true, search will continuously probe Boolean variables, and integer variable bounds.
  optional bool use_probing_search = 176 [default = false];
  Specified by:
  
  hasUseProbingSearch in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useProbingSearch field is set.
- getUseProbingSearch
  
  public boolean getUseProbingSearch()
  If true, search will continuously probe Boolean variables, and integer variable bounds.
  optional bool use_probing_search = 176 [default = false];
  Specified by:
  
  getUseProbingSearch in interface SatParametersOrBuilder
  
  Returns:
  
  The useProbingSearch.
- hasPseudoCostReliabilityThreshold
  
  public boolean hasPseudoCostReliabilityThreshold()
  The solver ignores the pseudo costs of variables with number of recordings less than this threshold.
  optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
  Specified by:
  
  hasPseudoCostReliabilityThreshold in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the pseudoCostReliabilityThreshold field is set.
- getPseudoCostReliabilityThreshold
  
  public long getPseudoCostReliabilityThreshold()
  The solver ignores the pseudo costs of variables with number of recordings less than this threshold.
  optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
  Specified by:
  
  getPseudoCostReliabilityThreshold in interface SatParametersOrBuilder
  
  Returns:
  
  The pseudoCostReliabilityThreshold.
- hasOptimizeWithCore
  
  public boolean hasOptimizeWithCore()
  The default optimization method is a simple "linear scan", each time trying to find a better solution than the previous one. If this is true, then we use a core-based approach (like in max-SAT) when we try to increase the lower bound instead.
  optional bool optimize_with_core = 83 [default = false];
  Specified by:
  
  hasOptimizeWithCore in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the optimizeWithCore field is set.
- getOptimizeWithCore
  
  public boolean getOptimizeWithCore()
  The default optimization method is a simple "linear scan", each time trying to find a better solution than the previous one. If this is true, then we use a core-based approach (like in max-SAT) when we try to increase the lower bound instead.
  optional bool optimize_with_core = 83 [default = false];
  Specified by:
  
  getOptimizeWithCore in interface SatParametersOrBuilder
  
  Returns:
  
  The optimizeWithCore.
- hasBinarySearchNumConflicts
  
  public boolean hasBinarySearchNumConflicts()
  If non-negative, perform a binary search on the objective variable in order to find an [min, max] interval outside of which the solver proved unsat/sat under this amount of conflict. This can quickly reduce the objective domain on some problems.
  optional int32 binary_search_num_conflicts = 99 [default = -1];
  Specified by:
  
  hasBinarySearchNumConflicts in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the binarySearchNumConflicts field is set.
- getBinarySearchNumConflicts
  
  public int getBinarySearchNumConflicts()
  If non-negative, perform a binary search on the objective variable in order to find an [min, max] interval outside of which the solver proved unsat/sat under this amount of conflict. This can quickly reduce the objective domain on some problems.
  optional int32 binary_search_num_conflicts = 99 [default = -1];
  Specified by:
  
  getBinarySearchNumConflicts in interface SatParametersOrBuilder
  
  Returns:
  
  The binarySearchNumConflicts.
- hasOptimizeWithMaxHs
  
  public boolean hasOptimizeWithMaxHs()
  This has no effect if optimize_with_core is false. If true, use a different core-based algorithm similar to the max-HS algo for max-SAT. This is a hybrid MIP/CP approach and it uses a MIP solver in addition to the CP/SAT one. This is also related to the PhD work of tobyodavies@ "Automatic Logic-Based Benders Decomposition with MiniZinc" http://aaai.org/ocs/index.php/AAAI/AAAI17/paper/view/14489
  optional bool optimize_with_max_hs = 85 [default = false];
  Specified by:
  
  hasOptimizeWithMaxHs in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the optimizeWithMaxHs field is set.
- getOptimizeWithMaxHs
  
  public boolean getOptimizeWithMaxHs()
  This has no effect if optimize_with_core is false. If true, use a different core-based algorithm similar to the max-HS algo for max-SAT. This is a hybrid MIP/CP approach and it uses a MIP solver in addition to the CP/SAT one. This is also related to the PhD work of tobyodavies@ "Automatic Logic-Based Benders Decomposition with MiniZinc" http://aaai.org/ocs/index.php/AAAI/AAAI17/paper/view/14489
  optional bool optimize_with_max_hs = 85 [default = false];
  Specified by:
  
  getOptimizeWithMaxHs in interface SatParametersOrBuilder
  
  Returns:
  
  The optimizeWithMaxHs.
- hasEnumerateAllSolutions
  
  public boolean hasEnumerateAllSolutions()
  Whether we enumerate all solutions of a problem without objective. Note that setting this to true automatically disable the presolve. This is because the presolve rules only guarantee the existence of one feasible solution to the presolved problem. TODO(user): Do not disable the presolve and let the user choose what behavior is best by setting keep_all_feasible_solutions_in_presolve.
  optional bool enumerate_all_solutions = 87 [default = false];
  Specified by:
  
  hasEnumerateAllSolutions in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the enumerateAllSolutions field is set.
- getEnumerateAllSolutions
  
  public boolean getEnumerateAllSolutions()
  Whether we enumerate all solutions of a problem without objective. Note that setting this to true automatically disable the presolve. This is because the presolve rules only guarantee the existence of one feasible solution to the presolved problem. TODO(user): Do not disable the presolve and let the user choose what behavior is best by setting keep_all_feasible_solutions_in_presolve.
  optional bool enumerate_all_solutions = 87 [default = false];
  Specified by:
  
  getEnumerateAllSolutions in interface SatParametersOrBuilder
  
  Returns:
  
  The enumerateAllSolutions.
- hasKeepAllFeasibleSolutionsInPresolve
  
  public boolean hasKeepAllFeasibleSolutionsInPresolve()
  If true, we disable the presolve reductions that remove feasible solutions from the search space. Such solution are usually dominated by a "better" solution that is kept, but depending on the situation, we might want to keep all solutions. A trivial example is when a variable is unused. If this is true, then the presolve will not fix it to an arbitrary value and it will stay in the search space.
  optional bool keep_all_feasible_solutions_in_presolve = 173 [default = false];
  Specified by:
  
  hasKeepAllFeasibleSolutionsInPresolve in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the keepAllFeasibleSolutionsInPresolve field is set.
- getKeepAllFeasibleSolutionsInPresolve
  
  public boolean getKeepAllFeasibleSolutionsInPresolve()
  If true, we disable the presolve reductions that remove feasible solutions from the search space. Such solution are usually dominated by a "better" solution that is kept, but depending on the situation, we might want to keep all solutions. A trivial example is when a variable is unused. If this is true, then the presolve will not fix it to an arbitrary value and it will stay in the search space.
  optional bool keep_all_feasible_solutions_in_presolve = 173 [default = false];
  Specified by:
  
  getKeepAllFeasibleSolutionsInPresolve in interface SatParametersOrBuilder
  
  Returns:
  
  The keepAllFeasibleSolutionsInPresolve.
- hasFillTightenedDomainsInResponse
  
  public boolean hasFillTightenedDomainsInResponse()
  If true, add information about the derived variable domains to the CpSolverResponse. It is an option because it makes the response slighly bigger and there is a bit more work involved during the postsolve to construct it, but it should still have a low overhead. See the tightened_variables field in CpSolverResponse for more details.
  optional bool fill_tightened_domains_in_response = 132 [default = false];
  Specified by:
  
  hasFillTightenedDomainsInResponse in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the fillTightenedDomainsInResponse field is set.
- getFillTightenedDomainsInResponse
  
  public boolean getFillTightenedDomainsInResponse()
  If true, add information about the derived variable domains to the CpSolverResponse. It is an option because it makes the response slighly bigger and there is a bit more work involved during the postsolve to construct it, but it should still have a low overhead. See the tightened_variables field in CpSolverResponse for more details.
  optional bool fill_tightened_domains_in_response = 132 [default = false];
  Specified by:
  
  getFillTightenedDomainsInResponse in interface SatParametersOrBuilder
  
  Returns:
  
  The fillTightenedDomainsInResponse.
- hasInstantiateAllVariables
  
  public boolean hasInstantiateAllVariables()
  If true, the solver will add a default integer branching strategy to the already defined search strategy.
  optional bool instantiate_all_variables = 106 [default = true];
  Specified by:
  
  hasInstantiateAllVariables in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the instantiateAllVariables field is set.
- getInstantiateAllVariables
  
  public boolean getInstantiateAllVariables()
  If true, the solver will add a default integer branching strategy to the already defined search strategy.
  optional bool instantiate_all_variables = 106 [default = true];
  Specified by:
  
  getInstantiateAllVariables in interface SatParametersOrBuilder
  
  Returns:
  
  The instantiateAllVariables.
- hasAutoDetectGreaterThanAtLeastOneOf
  
  public boolean hasAutoDetectGreaterThanAtLeastOneOf()
  If true, then the precedences propagator try to detect for each variable if it has a set of "optional incoming arc" for which at least one of them is present. This is usually useful to have but can be slow on model with a lot of precedence.
  optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
  Specified by:
  
  hasAutoDetectGreaterThanAtLeastOneOf in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the autoDetectGreaterThanAtLeastOneOf field is set.
- getAutoDetectGreaterThanAtLeastOneOf
  
  public boolean getAutoDetectGreaterThanAtLeastOneOf()
  If true, then the precedences propagator try to detect for each variable if it has a set of "optional incoming arc" for which at least one of them is present. This is usually useful to have but can be slow on model with a lot of precedence.
  optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
  Specified by:
  
  getAutoDetectGreaterThanAtLeastOneOf in interface SatParametersOrBuilder
  
  Returns:
  
  The autoDetectGreaterThanAtLeastOneOf.
- hasStopAfterFirstSolution
  
  public boolean hasStopAfterFirstSolution()
  For an optimization problem, stop the solver as soon as we have a solution.
  optional bool stop_after_first_solution = 98 [default = false];
  Specified by:
  
  hasStopAfterFirstSolution in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the stopAfterFirstSolution field is set.
- getStopAfterFirstSolution
  
  public boolean getStopAfterFirstSolution()
  For an optimization problem, stop the solver as soon as we have a solution.
  optional bool stop_after_first_solution = 98 [default = false];
  Specified by:
  
  getStopAfterFirstSolution in interface SatParametersOrBuilder
  
  Returns:
  
  The stopAfterFirstSolution.
- hasStopAfterPresolve
  
  public boolean hasStopAfterPresolve()
  Mainly used when improving the presolver. When true, stops the solver after the presolve is complete.
  optional bool stop_after_presolve = 149 [default = false];
  Specified by:
  
  hasStopAfterPresolve in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the stopAfterPresolve field is set.
- getStopAfterPresolve
  
  public boolean getStopAfterPresolve()
  Mainly used when improving the presolver. When true, stops the solver after the presolve is complete.
  optional bool stop_after_presolve = 149 [default = false];
  Specified by:
  
  getStopAfterPresolve in interface SatParametersOrBuilder
  
  Returns:
  
  The stopAfterPresolve.
- hasNumSearchWorkers
  
  public boolean hasNumSearchWorkers()
  Specify the number of parallel workers to use during search. A number <= 1 means no parallelism. As of 2020-04-10, if you're using SAT via MPSolver (to solve integer programs) this field is overridden with a value of 8, if the field is not set *explicitly*. Thus, always set this field explicitly or via MPSolver::SetNumThreads().
  optional int32 num_search_workers = 100 [default = 1];
  Specified by:
  
  hasNumSearchWorkers in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the numSearchWorkers field is set.
- getNumSearchWorkers
  
  public int getNumSearchWorkers()
  Specify the number of parallel workers to use during search. A number <= 1 means no parallelism. As of 2020-04-10, if you're using SAT via MPSolver (to solve integer programs) this field is overridden with a value of 8, if the field is not set *explicitly*. Thus, always set this field explicitly or via MPSolver::SetNumThreads().
  optional int32 num_search_workers = 100 [default = 1];
  Specified by:
  
  getNumSearchWorkers in interface SatParametersOrBuilder
  
  Returns:
  
  The numSearchWorkers.
- hasInterleaveSearch
  
  public boolean hasInterleaveSearch()
  Experimental. If this is true, then we interleave all our major search strategy and distribute the work amongst num_search_workers. The search is deterministic (independently of num_search_workers!), and we schedule and wait for interleave_batch_size task to be completed before synchronizing and scheduling the next batch of tasks.
  optional bool interleave_search = 136 [default = false];
  Specified by:
  
  hasInterleaveSearch in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the interleaveSearch field is set.
- getInterleaveSearch
  
  public boolean getInterleaveSearch()
  Experimental. If this is true, then we interleave all our major search strategy and distribute the work amongst num_search_workers. The search is deterministic (independently of num_search_workers!), and we schedule and wait for interleave_batch_size task to be completed before synchronizing and scheduling the next batch of tasks.
  optional bool interleave_search = 136 [default = false];
  Specified by:
  
  getInterleaveSearch in interface SatParametersOrBuilder
  
  Returns:
  
  The interleaveSearch.
- hasInterleaveBatchSize
  
  public boolean hasInterleaveBatchSize()
  
  optional int32 interleave_batch_size = 134 [default = 1];
  
  Specified by:
  
  hasInterleaveBatchSize in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the interleaveBatchSize field is set.
- getInterleaveBatchSize
  
  public int getInterleaveBatchSize()
  
  optional int32 interleave_batch_size = 134 [default = 1];
  
  Specified by:
  
  getInterleaveBatchSize in interface SatParametersOrBuilder
  
  Returns:
  
  The interleaveBatchSize.
- hasReduceMemoryUsageInInterleaveMode
  
  public boolean hasReduceMemoryUsageInInterleaveMode()
  Temporary parameter until the memory usage is more optimized.
  optional bool reduce_memory_usage_in_interleave_mode = 141 [default = false];
  Specified by:
  
  hasReduceMemoryUsageInInterleaveMode in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the reduceMemoryUsageInInterleaveMode field is set.
- getReduceMemoryUsageInInterleaveMode
  
  public boolean getReduceMemoryUsageInInterleaveMode()
  Temporary parameter until the memory usage is more optimized.
  optional bool reduce_memory_usage_in_interleave_mode = 141 [default = false];
  Specified by:
  
  getReduceMemoryUsageInInterleaveMode in interface SatParametersOrBuilder
  
  Returns:
  
  The reduceMemoryUsageInInterleaveMode.
- hasShareObjectiveBounds
  
  public boolean hasShareObjectiveBounds()
  Allows objective sharing between workers.
  optional bool share_objective_bounds = 113 [default = true];
  Specified by:
  
  hasShareObjectiveBounds in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the shareObjectiveBounds field is set.
- getShareObjectiveBounds
  
  public boolean getShareObjectiveBounds()
  Allows objective sharing between workers.
  optional bool share_objective_bounds = 113 [default = true];
  Specified by:
  
  getShareObjectiveBounds in interface SatParametersOrBuilder
  
  Returns:
  
  The shareObjectiveBounds.
- hasShareLevelZeroBounds
  
  public boolean hasShareLevelZeroBounds()
  Allows sharing of the bounds of modified variables at level 0.
  optional bool share_level_zero_bounds = 114 [default = true];
  Specified by:
  
  hasShareLevelZeroBounds in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the shareLevelZeroBounds field is set.
- getShareLevelZeroBounds
  
  public boolean getShareLevelZeroBounds()
  Allows sharing of the bounds of modified variables at level 0.
  optional bool share_level_zero_bounds = 114 [default = true];
  Specified by:
  
  getShareLevelZeroBounds in interface SatParametersOrBuilder
  
  Returns:
  
  The shareLevelZeroBounds.
- hasUseLnsOnly
  
  public boolean hasUseLnsOnly()
  LNS parameters.
  optional bool use_lns_only = 101 [default = false];
  Specified by:
  
  hasUseLnsOnly in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useLnsOnly field is set.
- getUseLnsOnly
  
  public boolean getUseLnsOnly()
  LNS parameters.
  optional bool use_lns_only = 101 [default = false];
  Specified by:
  
  getUseLnsOnly in interface SatParametersOrBuilder
  
  Returns:
  
  The useLnsOnly.
- hasLnsFocusOnDecisionVariables
  
  public boolean hasLnsFocusOnDecisionVariables()
  
  optional bool lns_focus_on_decision_variables = 105 [default = false];
  
  Specified by:
  
  hasLnsFocusOnDecisionVariables in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the lnsFocusOnDecisionVariables field is set.
- getLnsFocusOnDecisionVariables
  
  public boolean getLnsFocusOnDecisionVariables()
  
  optional bool lns_focus_on_decision_variables = 105 [default = false];
  
  Specified by:
  
  getLnsFocusOnDecisionVariables in interface SatParametersOrBuilder
  
  Returns:
  
  The lnsFocusOnDecisionVariables.
- hasLnsExpandIntervalsInConstraintGraph
  
  public boolean hasLnsExpandIntervalsInConstraintGraph()
  
  optional bool lns_expand_intervals_in_constraint_graph = 184 [default = true];
  
  Specified by:
  
  hasLnsExpandIntervalsInConstraintGraph in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the lnsExpandIntervalsInConstraintGraph field is set.
- getLnsExpandIntervalsInConstraintGraph
  
  public boolean getLnsExpandIntervalsInConstraintGraph()
  
  optional bool lns_expand_intervals_in_constraint_graph = 184 [default = true];
  
  Specified by:
  
  getLnsExpandIntervalsInConstraintGraph in interface SatParametersOrBuilder
  
  Returns:
  
  The lnsExpandIntervalsInConstraintGraph.
- hasUseRinsLns
  
  public boolean hasUseRinsLns()
  Turns on relaxation induced neighborhood generator.
  optional bool use_rins_lns = 129 [default = true];
  Specified by:
  
  hasUseRinsLns in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useRinsLns field is set.
- getUseRinsLns
  
  public boolean getUseRinsLns()
  Turns on relaxation induced neighborhood generator.
  optional bool use_rins_lns = 129 [default = true];
  Specified by:
  
  getUseRinsLns in interface SatParametersOrBuilder
  
  Returns:
  
  The useRinsLns.
- hasUseFeasibilityPump
  
  public boolean hasUseFeasibilityPump()
  Adds a feasibility pump subsolver along with lns subsolvers.
  optional bool use_feasibility_pump = 164 [default = true];
  Specified by:
  
  hasUseFeasibilityPump in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useFeasibilityPump field is set.
- getUseFeasibilityPump
  
  public boolean getUseFeasibilityPump()
  Adds a feasibility pump subsolver along with lns subsolvers.
  optional bool use_feasibility_pump = 164 [default = true];
  Specified by:
  
  getUseFeasibilityPump in interface SatParametersOrBuilder
  
  Returns:
  
  The useFeasibilityPump.
- hasFpRounding
  
  public boolean hasFpRounding()
  
  optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
  
  Specified by:
  
  hasFpRounding in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the fpRounding field is set.
- getFpRounding
  
  public SatParameters.FPRoundingMethod getFpRounding()
  
  optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
  
  Specified by:
  
  getFpRounding in interface SatParametersOrBuilder
  
  Returns:
  
  The fpRounding.
- hasUseRelaxationLns
  
  public boolean hasUseRelaxationLns()
  Turns on a lns worker which solves relaxed version of the original problem by removing constraints from the problem in order to get better bounds.
  optional bool use_relaxation_lns = 150 [default = false];
  Specified by:
  
  hasUseRelaxationLns in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useRelaxationLns field is set.
- getUseRelaxationLns
  
  public boolean getUseRelaxationLns()
  Turns on a lns worker which solves relaxed version of the original problem by removing constraints from the problem in order to get better bounds.
  optional bool use_relaxation_lns = 150 [default = false];
  Specified by:
  
  getUseRelaxationLns in interface SatParametersOrBuilder
  
  Returns:
  
  The useRelaxationLns.
- hasDiversifyLnsParams
  
  public boolean hasDiversifyLnsParams()
  If true, registers more lns subsolvers with different parameters.
  optional bool diversify_lns_params = 137 [default = false];
  Specified by:
  
  hasDiversifyLnsParams in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the diversifyLnsParams field is set.
- getDiversifyLnsParams
  
  public boolean getDiversifyLnsParams()
  If true, registers more lns subsolvers with different parameters.
  optional bool diversify_lns_params = 137 [default = false];
  Specified by:
  
  getDiversifyLnsParams in interface SatParametersOrBuilder
  
  Returns:
  
  The diversifyLnsParams.
- hasRandomizeSearch
  
  public boolean hasRandomizeSearch()
  Randomize fixed search.
  optional bool randomize_search = 103 [default = false];
  Specified by:
  
  hasRandomizeSearch in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the randomizeSearch field is set.
- getRandomizeSearch
  
  public boolean getRandomizeSearch()
  Randomize fixed search.
  optional bool randomize_search = 103 [default = false];
  Specified by:
  
  getRandomizeSearch in interface SatParametersOrBuilder
  
  Returns:
  
  The randomizeSearch.
- hasSearchRandomizationTolerance
  
  public boolean hasSearchRandomizationTolerance()
  Search randomization will collect equivalent 'max valued' variables, and pick one randomly. For instance, if the variable strategy is CHOOSE_FIRST, all unassigned variables are equivalent. If the variable strategy is CHOOSE_LOWEST_MIN, and `lm` is the current lowest min of all unassigned variables, then the set of max valued variables will be all unassigned variables where lm <= variable min <= lm + search_randomization_tolerance
  optional int64 search_randomization_tolerance = 104 [default = 0];
  Specified by:
  
  hasSearchRandomizationTolerance in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the searchRandomizationTolerance field is set.
- getSearchRandomizationTolerance
  
  public long getSearchRandomizationTolerance()
  Search randomization will collect equivalent 'max valued' variables, and pick one randomly. For instance, if the variable strategy is CHOOSE_FIRST, all unassigned variables are equivalent. If the variable strategy is CHOOSE_LOWEST_MIN, and `lm` is the current lowest min of all unassigned variables, then the set of max valued variables will be all unassigned variables where lm <= variable min <= lm + search_randomization_tolerance
  optional int64 search_randomization_tolerance = 104 [default = 0];
  Specified by:
  
  getSearchRandomizationTolerance in interface SatParametersOrBuilder
  
  Returns:
  
  The searchRandomizationTolerance.
- hasUseOptionalVariables
  
  public boolean hasUseOptionalVariables()
  If true, we automatically detect variables whose constraint are always enforced by the same literal and we mark them as optional. This allows to propagate them as if they were present in some situation.
  optional bool use_optional_variables = 108 [default = true];
  Specified by:
  
  hasUseOptionalVariables in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useOptionalVariables field is set.
- getUseOptionalVariables
  
  public boolean getUseOptionalVariables()
  If true, we automatically detect variables whose constraint are always enforced by the same literal and we mark them as optional. This allows to propagate them as if they were present in some situation.
  optional bool use_optional_variables = 108 [default = true];
  Specified by:
  
  getUseOptionalVariables in interface SatParametersOrBuilder
  
  Returns:
  
  The useOptionalVariables.
- hasUseExactLpReason
  
  public boolean hasUseExactLpReason()
  The solver usually exploit the LP relaxation of a model. If this option is true, then whatever is infered by the LP will be used like an heuristic to compute EXACT propagation on the IP. So with this option, there is no numerical imprecision issues.
  optional bool use_exact_lp_reason = 109 [default = true];
  Specified by:
  
  hasUseExactLpReason in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useExactLpReason field is set.
- getUseExactLpReason
  
  public boolean getUseExactLpReason()
  The solver usually exploit the LP relaxation of a model. If this option is true, then whatever is infered by the LP will be used like an heuristic to compute EXACT propagation on the IP. So with this option, there is no numerical imprecision issues.
  optional bool use_exact_lp_reason = 109 [default = true];
  Specified by:
  
  getUseExactLpReason in interface SatParametersOrBuilder
  
  Returns:
  
  The useExactLpReason.
- hasUseBranchingInLp
  
  public boolean hasUseBranchingInLp()
  If true, the solver attemts to generate more info inside lp propagator by branching on some variables if certain criteria are met during the search tree exploration.
  optional bool use_branching_in_lp = 139 [default = false];
  Specified by:
  
  hasUseBranchingInLp in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useBranchingInLp field is set.
- getUseBranchingInLp
  
  public boolean getUseBranchingInLp()
  If true, the solver attemts to generate more info inside lp propagator by branching on some variables if certain criteria are met during the search tree exploration.
  optional bool use_branching_in_lp = 139 [default = false];
  Specified by:
  
  getUseBranchingInLp in interface SatParametersOrBuilder
  
  Returns:
  
  The useBranchingInLp.
- hasUseCombinedNoOverlap
  
  public boolean hasUseCombinedNoOverlap()
  This can be beneficial if there is a lot of no-overlap constraints but a relatively low number of different intervals in the problem. Like 1000 intervals, but 1M intervals in the no-overlap constraints covering them.
  optional bool use_combined_no_overlap = 133 [default = false];
  Specified by:
  
  hasUseCombinedNoOverlap in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useCombinedNoOverlap field is set.
- getUseCombinedNoOverlap
  
  public boolean getUseCombinedNoOverlap()
  This can be beneficial if there is a lot of no-overlap constraints but a relatively low number of different intervals in the problem. Like 1000 intervals, but 1M intervals in the no-overlap constraints covering them.
  optional bool use_combined_no_overlap = 133 [default = false];
  Specified by:
  
  getUseCombinedNoOverlap in interface SatParametersOrBuilder
  
  Returns:
  
  The useCombinedNoOverlap.
- hasCatchSigintSignal
  
  public boolean hasCatchSigintSignal()
  Indicates if the CP-SAT layer should catch Control-C (SIGINT) signals when calling solve. If set, catching the SIGINT signal will terminate the search gracefully, as if a time limit was reached.
  optional bool catch_sigint_signal = 135 [default = true];
  Specified by:
  
  hasCatchSigintSignal in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the catchSigintSignal field is set.
- getCatchSigintSignal
  
  public boolean getCatchSigintSignal()
  Indicates if the CP-SAT layer should catch Control-C (SIGINT) signals when calling solve. If set, catching the SIGINT signal will terminate the search gracefully, as if a time limit was reached.
  optional bool catch_sigint_signal = 135 [default = true];
  Specified by:
  
  getCatchSigintSignal in interface SatParametersOrBuilder
  
  Returns:
  
  The catchSigintSignal.
- hasUseImpliedBounds
  
  public boolean hasUseImpliedBounds()
  Stores and exploits "implied-bounds" in the solver. That is, relations of the form literal => (var >= bound). This is currently used to derive stronger cuts.
  optional bool use_implied_bounds = 144 [default = true];
  Specified by:
  
  hasUseImpliedBounds in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the useImpliedBounds field is set.
- getUseImpliedBounds
  
  public boolean getUseImpliedBounds()
  Stores and exploits "implied-bounds" in the solver. That is, relations of the form literal => (var >= bound). This is currently used to derive stronger cuts.
  optional bool use_implied_bounds = 144 [default = true];
  Specified by:
  
  getUseImpliedBounds in interface SatParametersOrBuilder
  
  Returns:
  
  The useImpliedBounds.
- hasPolishLpSolution
  
  public boolean hasPolishLpSolution()
  Whether we try to do a few degenerate iteration at the end of an LP solve to minimize the fractionality of the integer variable in the basis. This helps on some problems, but not so much on others. It also cost of bit of time to do such polish step.
  optional bool polish_lp_solution = 175 [default = false];
  Specified by:
  
  hasPolishLpSolution in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the polishLpSolution field is set.
- getPolishLpSolution
  
  public boolean getPolishLpSolution()
  Whether we try to do a few degenerate iteration at the end of an LP solve to minimize the fractionality of the integer variable in the basis. This helps on some problems, but not so much on others. It also cost of bit of time to do such polish step.
  optional bool polish_lp_solution = 175 [default = false];
  Specified by:
  
  getPolishLpSolution in interface SatParametersOrBuilder
  
  Returns:
  
  The polishLpSolution.
- hasConvertIntervals
  
  public boolean hasConvertIntervals()
  Temporary flag util the feature is more mature. This convert intervals to the newer proto format that support affine start/var/end instead of just variables. It changes a bit the search and is not always better currently.
  optional bool convert_intervals = 177 [default = false];
  Specified by:
  
  hasConvertIntervals in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the convertIntervals field is set.
- getConvertIntervals
  
  public boolean getConvertIntervals()
  Temporary flag util the feature is more mature. This convert intervals to the newer proto format that support affine start/var/end instead of just variables. It changes a bit the search and is not always better currently.
  optional bool convert_intervals = 177 [default = false];
  Specified by:
  
  getConvertIntervals in interface SatParametersOrBuilder
  
  Returns:
  
  The convertIntervals.
- hasSymmetryLevel
  
  public boolean hasSymmetryLevel()
  Whether we try to automatically detect the symmetries in a model and exploit them. Currently, at level 1 we detect them in presolve and try to fix Booleans. At level 2, we also do some form of dynamic symmetry breaking during search.
  optional int32 symmetry_level = 183 [default = 2];
  Specified by:
  
  hasSymmetryLevel in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the symmetryLevel field is set.
- getSymmetryLevel
  
  public int getSymmetryLevel()
  Whether we try to automatically detect the symmetries in a model and exploit them. Currently, at level 1 we detect them in presolve and try to fix Booleans. At level 2, we also do some form of dynamic symmetry breaking during search.
  optional int32 symmetry_level = 183 [default = 2];
  Specified by:
  
  getSymmetryLevel in interface SatParametersOrBuilder
  
  Returns:
  
  The symmetryLevel.
- hasMipMaxBound
  
  public boolean hasMipMaxBound()
  We need to bound the maximum magnitude of the variables for CP-SAT, and that is the bound we use. If the MIP model expect larger variable value in the solution, then the converted model will likely not be relevant.
  optional double mip_max_bound = 124 [default = 10000000];
  Specified by:
  
  hasMipMaxBound in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the mipMaxBound field is set.
- getMipMaxBound
  
  public double getMipMaxBound()
  We need to bound the maximum magnitude of the variables for CP-SAT, and that is the bound we use. If the MIP model expect larger variable value in the solution, then the converted model will likely not be relevant.
  optional double mip_max_bound = 124 [default = 10000000];
  Specified by:
  
  getMipMaxBound in interface SatParametersOrBuilder
  
  Returns:
  
  The mipMaxBound.
- hasMipVarScaling
  
  public boolean hasMipVarScaling()
  All continuous variable of the problem will be multiplied by this factor. By default, we don't do any variable scaling and rely on the MIP model to specify continuous variable domain with the wanted precision.
  optional double mip_var_scaling = 125 [default = 1];
  Specified by:
  
  hasMipVarScaling in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the mipVarScaling field is set.
- getMipVarScaling
  
  public double getMipVarScaling()
  All continuous variable of the problem will be multiplied by this factor. By default, we don't do any variable scaling and rely on the MIP model to specify continuous variable domain with the wanted precision.
  optional double mip_var_scaling = 125 [default = 1];
  Specified by:
  
  getMipVarScaling in interface SatParametersOrBuilder
  
  Returns:
  
  The mipVarScaling.
- hasMipAutomaticallyScaleVariables
  
  public boolean hasMipAutomaticallyScaleVariables()
  If true, some continuous variable might be automatially scaled. For now, this is only the case where we detect that a variable is actually an integer multiple of a constant. For instance, variables of the form k * 0.5 are quite frequent, and if we detect this, we will scale such variable domain by 2 to make it implied integer.
  optional bool mip_automatically_scale_variables = 166 [default = true];
  Specified by:
  
  hasMipAutomaticallyScaleVariables in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the mipAutomaticallyScaleVariables field is set.
- getMipAutomaticallyScaleVariables
  
  public boolean getMipAutomaticallyScaleVariables()
  If true, some continuous variable might be automatially scaled. For now, this is only the case where we detect that a variable is actually an integer multiple of a constant. For instance, variables of the form k * 0.5 are quite frequent, and if we detect this, we will scale such variable domain by 2 to make it implied integer.
  optional bool mip_automatically_scale_variables = 166 [default = true];
  Specified by:
  
  getMipAutomaticallyScaleVariables in interface SatParametersOrBuilder
  
  Returns:
  
  The mipAutomaticallyScaleVariables.
- hasMipWantedPrecision
  
  public boolean hasMipWantedPrecision()
  When scaling constraint with double coefficients to integer coefficients, we will multiply by a power of 2 and round the coefficients. We will choose the lowest power such that we have no potential overflow and the worst case constraint activity error do not exceed this threshold relative to the constraint bounds. We also use this to decide by how much we relax the constraint bounds so that we can have a feasible integer solution of constraints involving continuous variable. This is required for instance when you have an == rhs constraint as in many situation you cannot have a perfect equality with integer variables and coefficients.
  optional double mip_wanted_precision = 126 [default = 1e-06];
  Specified by:
  
  hasMipWantedPrecision in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the mipWantedPrecision field is set.
- getMipWantedPrecision
  
  public double getMipWantedPrecision()
  When scaling constraint with double coefficients to integer coefficients, we will multiply by a power of 2 and round the coefficients. We will choose the lowest power such that we have no potential overflow and the worst case constraint activity error do not exceed this threshold relative to the constraint bounds. We also use this to decide by how much we relax the constraint bounds so that we can have a feasible integer solution of constraints involving continuous variable. This is required for instance when you have an == rhs constraint as in many situation you cannot have a perfect equality with integer variables and coefficients.
  optional double mip_wanted_precision = 126 [default = 1e-06];
  Specified by:
  
  getMipWantedPrecision in interface SatParametersOrBuilder
  
  Returns:
  
  The mipWantedPrecision.
- hasMipMaxActivityExponent
  
  public boolean hasMipMaxActivityExponent()
  To avoid integer overflow, we always force the maximum possible constraint activity (and objective value) according to the initial variable domain to be smaller than 2 to this given power. Because of this, we cannot always reach the "mip_wanted_precision" parameter above. This can go as high as 62, but some internal algo currently abort early if they might run into integer overflow, so it is better to keep it a bit lower than this.
  optional int32 mip_max_activity_exponent = 127 [default = 53];
  Specified by:
  
  hasMipMaxActivityExponent in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the mipMaxActivityExponent field is set.
- getMipMaxActivityExponent
  
  public int getMipMaxActivityExponent()
  To avoid integer overflow, we always force the maximum possible constraint activity (and objective value) according to the initial variable domain to be smaller than 2 to this given power. Because of this, we cannot always reach the "mip_wanted_precision" parameter above. This can go as high as 62, but some internal algo currently abort early if they might run into integer overflow, so it is better to keep it a bit lower than this.
  optional int32 mip_max_activity_exponent = 127 [default = 53];
  Specified by:
  
  getMipMaxActivityExponent in interface SatParametersOrBuilder
  
  Returns:
  
  The mipMaxActivityExponent.
- hasMipCheckPrecision
  
  public boolean hasMipCheckPrecision()
  As explained in mip_precision and mip_max_activity_exponent, we cannot always reach the wanted precision during scaling. We use this threshold to enphasize in the logs when the precision seems bad.
  optional double mip_check_precision = 128 [default = 0.0001];
  Specified by:
  
  hasMipCheckPrecision in interface SatParametersOrBuilder
  
  Returns:
  
  Whether the mipCheckPrecision field is set.
- getMipCheckPrecision
  
  public double getMipCheckPrecision()
  As explained in mip_precision and mip_max_activity_exponent, we cannot always reach the wanted precision during scaling. We use this threshold to enphasize in the logs when the precision seems bad.
  optional double mip_check_precision = 128 [default = 0.0001];
  Specified by:
  
  getMipCheckPrecision in interface SatParametersOrBuilder
  
  Returns:
  
  The mipCheckPrecision.
- isInitialized
  
  public final boolean isInitialized()
  
  Specified by:
  
  isInitialized in interface com.google.protobuf.MessageLiteOrBuilder
  
  Overrides:
  
  isInitialized in class com.google.protobuf.GeneratedMessageV3
- writeTo
  
  public void writeTo(com.google.protobuf.CodedOutputStream output) throws java.io.IOException
  
  Specified by:
  
  writeTo in interface com.google.protobuf.MessageLite
  
  Overrides:
  
  writeTo in class com.google.protobuf.GeneratedMessageV3
  
  Throws:
  
  java.io.IOException
- getSerializedSize
  
  public int getSerializedSize()
  
  Specified by:
  
  getSerializedSize in interface com.google.protobuf.MessageLite
  
  Overrides:
  
  getSerializedSize in class com.google.protobuf.GeneratedMessageV3
- equals
  
  public boolean equals(java.lang.Object obj)
  
  Specified by:
  
  equals in interface com.google.protobuf.Message
  
  Overrides:
  
  equals in class com.google.protobuf.AbstractMessage
- hashCode
  
  public int hashCode()
  
  Specified by:
  
  hashCode in interface com.google.protobuf.Message
  
  Overrides:
  
  hashCode in class com.google.protobuf.AbstractMessage
- parseFrom
  
  public static SatParameters parseFrom(java.nio.ByteBuffer data) throws com.google.protobuf.InvalidProtocolBufferException
  
  Throws:
  
  com.google.protobuf.InvalidProtocolBufferException
- parseFrom
  
  public static SatParameters parseFrom(java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException
  
  Throws:
  
  com.google.protobuf.InvalidProtocolBufferException
- parseFrom
  
  public static SatParameters parseFrom(com.google.protobuf.ByteString data) throws com.google.protobuf.InvalidProtocolBufferException
  
  Throws:
  
  com.google.protobuf.InvalidProtocolBufferException
- parseFrom
  
  public static SatParameters parseFrom(com.google.protobuf.ByteString data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException
  
  Throws:
  
  com.google.protobuf.InvalidProtocolBufferException
- parseFrom
  
  public static SatParameters parseFrom(byte[] data) throws com.google.protobuf.InvalidProtocolBufferException
  
  Throws:
  
  com.google.protobuf.InvalidProtocolBufferException
- parseFrom
  
  public static SatParameters parseFrom(byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException
  
  Throws:
  
  com.google.protobuf.InvalidProtocolBufferException
- parseFrom
  
  public static SatParameters parseFrom(java.io.InputStream input) throws java.io.IOException
  
  Throws:
  
  java.io.IOException
- parseFrom
  
  public static SatParameters parseFrom(java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException
  
  Throws:
  
  java.io.IOException
- parseDelimitedFrom
  
  public static SatParameters parseDelimitedFrom(java.io.InputStream input) throws java.io.IOException
  
  Throws:
  
  java.io.IOException
- parseDelimitedFrom
  
  public static SatParameters parseDelimitedFrom(java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException
  
  Throws:
  
  java.io.IOException
- parseFrom
  
  public static SatParameters parseFrom(com.google.protobuf.CodedInputStream input) throws java.io.IOException
  
  Throws:
  
  java.io.IOException
- parseFrom
  
  public static SatParameters parseFrom(com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException
  
  Throws:
  
  java.io.IOException
- newBuilderForType
  
  public SatParameters.Builder newBuilderForType()
  
  Specified by:
  
  newBuilderForType in interface com.google.protobuf.Message
  
  Specified by:
  
  newBuilderForType in interface com.google.protobuf.MessageLite
- newBuilder
  
  public static SatParameters.Builder newBuilder()
- newBuilder
  
  public static SatParameters.Builder newBuilder(SatParameters prototype)
- toBuilder
  
  public SatParameters.Builder toBuilder()
  
  Specified by:
  
  toBuilder in interface com.google.protobuf.Message
  
  Specified by:
  
  toBuilder in interface com.google.protobuf.MessageLite
- newBuilderForType
  
  protected SatParameters.Builder newBuilderForType(com.google.protobuf.GeneratedMessageV3.BuilderParent parent)
  
  Specified by:
  
  newBuilderForType in class com.google.protobuf.GeneratedMessageV3
- getDefaultInstance
  
  public static SatParameters getDefaultInstance()
- parser
  
  public static com.google.protobuf.Parser<SatParameters> parser()
- getParserForType
  
  public com.google.protobuf.Parser<SatParameters> getParserForType()
  
  Specified by:
  
  getParserForType in interface com.google.protobuf.Message
  
  Specified by:
  
  getParserForType in interface com.google.protobuf.MessageLite
  
  Overrides:
  
  getParserForType in class com.google.protobuf.GeneratedMessageV3
- getDefaultInstanceForType
  
  public SatParameters getDefaultInstanceForType()
  
  Specified by:
  
  getDefaultInstanceForType in interface com.google.protobuf.MessageLiteOrBuilder
  
  Specified by:
  
  getDefaultInstanceForType in interface com.google.protobuf.MessageOrBuilder

Class SatParameters

Nested Class Summary

Nested classes/interfaces inherited from class com.google.protobuf.GeneratedMessageV3

Nested classes/interfaces inherited from class com.google.protobuf.AbstractMessageLite

Field Summary

Fields inherited from class com.google.protobuf.GeneratedMessageV3

Fields inherited from class com.google.protobuf.AbstractMessage

Fields inherited from class com.google.protobuf.AbstractMessageLite

Method Summary

Methods inherited from class com.google.protobuf.GeneratedMessageV3

Methods inherited from class com.google.protobuf.AbstractMessage

Methods inherited from class com.google.protobuf.AbstractMessageLite

Methods inherited from class java.lang.Object

Methods inherited from interface com.google.protobuf.MessageLite

Methods inherited from interface com.google.protobuf.MessageOrBuilder

Field Details

NAME_FIELD_NUMBER

PREFERRED_VARIABLE_ORDER_FIELD_NUMBER

INITIAL_POLARITY_FIELD_NUMBER

USE_PHASE_SAVING_FIELD_NUMBER

POLARITY_REPHASE_INCREMENT_FIELD_NUMBER

RANDOM_POLARITY_RATIO_FIELD_NUMBER

RANDOM_BRANCHES_RATIO_FIELD_NUMBER

USE_ERWA_HEURISTIC_FIELD_NUMBER

INITIAL_VARIABLES_ACTIVITY_FIELD_NUMBER

ALSO_BUMP_VARIABLES_IN_CONFLICT_REASONS_FIELD_NUMBER

MINIMIZATION_ALGORITHM_FIELD_NUMBER

BINARY_MINIMIZATION_ALGORITHM_FIELD_NUMBER

SUBSUMPTION_DURING_CONFLICT_ANALYSIS_FIELD_NUMBER

CLAUSE_CLEANUP_PERIOD_FIELD_NUMBER

CLAUSE_CLEANUP_TARGET_FIELD_NUMBER

CLAUSE_CLEANUP_PROTECTION_FIELD_NUMBER

CLAUSE_CLEANUP_LBD_BOUND_FIELD_NUMBER

CLAUSE_CLEANUP_ORDERING_FIELD_NUMBER

PB_CLEANUP_INCREMENT_FIELD_NUMBER

PB_CLEANUP_RATIO_FIELD_NUMBER

MINIMIZE_WITH_PROPAGATION_RESTART_PERIOD_FIELD_NUMBER

MINIMIZE_WITH_PROPAGATION_NUM_DECISIONS_FIELD_NUMBER

VARIABLE_ACTIVITY_DECAY_FIELD_NUMBER

MAX_VARIABLE_ACTIVITY_VALUE_FIELD_NUMBER

GLUCOSE_MAX_DECAY_FIELD_NUMBER

GLUCOSE_DECAY_INCREMENT_FIELD_NUMBER

GLUCOSE_DECAY_INCREMENT_PERIOD_FIELD_NUMBER

CLAUSE_ACTIVITY_DECAY_FIELD_NUMBER

MAX_CLAUSE_ACTIVITY_VALUE_FIELD_NUMBER

RESTART_ALGORITHMS_FIELD_NUMBER

DEFAULT_RESTART_ALGORITHMS_FIELD_NUMBER

RESTART_PERIOD_FIELD_NUMBER

RESTART_RUNNING_WINDOW_SIZE_FIELD_NUMBER

RESTART_DL_AVERAGE_RATIO_FIELD_NUMBER

RESTART_LBD_AVERAGE_RATIO_FIELD_NUMBER

USE_BLOCKING_RESTART_FIELD_NUMBER

BLOCKING_RESTART_WINDOW_SIZE_FIELD_NUMBER

BLOCKING_RESTART_MULTIPLIER_FIELD_NUMBER

NUM_CONFLICTS_BEFORE_STRATEGY_CHANGES_FIELD_NUMBER

STRATEGY_CHANGE_INCREASE_RATIO_FIELD_NUMBER

MAX_TIME_IN_SECONDS_FIELD_NUMBER

MAX_DETERMINISTIC_TIME_FIELD_NUMBER

MAX_NUMBER_OF_CONFLICTS_FIELD_NUMBER

MAX_MEMORY_IN_MB_FIELD_NUMBER

ABSOLUTE_GAP_LIMIT_FIELD_NUMBER

RELATIVE_GAP_LIMIT_FIELD_NUMBER

TREAT_BINARY_CLAUSES_SEPARATELY_FIELD_NUMBER

RANDOM_SEED_FIELD_NUMBER

PERMUTE_VARIABLE_RANDOMLY_FIELD_NUMBER

PERMUTE_PRESOLVE_CONSTRAINT_ORDER_FIELD_NUMBER

USE_ABSL_RANDOM_FIELD_NUMBER

LOG_SEARCH_PROGRESS_FIELD_NUMBER

LOG_PREFIX_FIELD_NUMBER

LOG_TO_STDOUT_FIELD_NUMBER

LOG_TO_RESPONSE_FIELD_NUMBER

USE_PB_RESOLUTION_FIELD_NUMBER

MINIMIZE_REDUCTION_DURING_PB_RESOLUTION_FIELD_NUMBER

COUNT_ASSUMPTION_LEVELS_IN_LBD_FIELD_NUMBER

PRESOLVE_BVE_THRESHOLD_FIELD_NUMBER

PRESOLVE_BVE_CLAUSE_WEIGHT_FIELD_NUMBER

PRESOLVE_PROBING_DETERMINISTIC_TIME_LIMIT_FIELD_NUMBER

PRESOLVE_BLOCKED_CLAUSE_FIELD_NUMBER

PRESOLVE_USE_BVA_FIELD_NUMBER

PRESOLVE_BVA_THRESHOLD_FIELD_NUMBER