C++ Reference

C++ Reference: CP-SAT

sat_parameters.pb.h
Go to the documentation of this file.
1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: ortools/sat/sat_parameters.proto
3 
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_ortools_2fsat_2fsat_5fparameters_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_ortools_2fsat_2fsat_5fparameters_2eproto
6 
7 #include <limits>
8 #include <string>
9 
10 #include <google/protobuf/port_def.inc>
11 #if PROTOBUF_VERSION < 3013000
12 #error This file was generated by a newer version of protoc which is
13 #error incompatible with your Protocol Buffer headers. Please update
14 #error your headers.
15 #endif
16 #if 3013000 < PROTOBUF_MIN_PROTOC_VERSION
17 #error This file was generated by an older version of protoc which is
18 #error incompatible with your Protocol Buffer headers. Please
19 #error regenerate this file with a newer version of protoc.
20 #endif
21 
22 #include <google/protobuf/port_undef.inc>
23 #include <google/protobuf/io/coded_stream.h>
24 #include <google/protobuf/arena.h>
25 #include <google/protobuf/arenastring.h>
26 #include <google/protobuf/generated_message_table_driven.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/inlined_string_field.h>
29 #include <google/protobuf/metadata_lite.h>
30 #include <google/protobuf/generated_message_reflection.h>
31 #include <google/protobuf/message.h>
32 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
33 #include <google/protobuf/extension_set.h> // IWYU pragma: export
34 #include <google/protobuf/generated_enum_reflection.h>
35 #include <google/protobuf/unknown_field_set.h>
36 // @@protoc_insertion_point(includes)
37 #include <google/protobuf/port_def.inc>
38 #define PROTOBUF_INTERNAL_EXPORT_ortools_2fsat_2fsat_5fparameters_2eproto
39 PROTOBUF_NAMESPACE_OPEN
40 namespace internal {
41 class AnyMetadata;
42 } // namespace internal
43 PROTOBUF_NAMESPACE_CLOSE
44 
45 // Internal implementation detail -- do not use these members.
46 struct TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto {
47  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
48  PROTOBUF_SECTION_VARIABLE(protodesc_cold);
49  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
50  PROTOBUF_SECTION_VARIABLE(protodesc_cold);
51  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
52  PROTOBUF_SECTION_VARIABLE(protodesc_cold);
53  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
54  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
55  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
56 };
57 extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto;
58 namespace operations_research {
59 namespace sat {
60 class SatParameters;
61 class SatParametersDefaultTypeInternal;
62 extern SatParametersDefaultTypeInternal _SatParameters_default_instance_;
63 } // namespace sat
64 } // namespace operations_research
65 PROTOBUF_NAMESPACE_OPEN
66 template<> ::operations_research::sat::SatParameters* Arena::CreateMaybeMessage<::operations_research::sat::SatParameters>(Arena*);
67 PROTOBUF_NAMESPACE_CLOSE
68 namespace operations_research {
69 namespace sat {
70 
71 enum SatParameters_VariableOrder : int {
72  SatParameters_VariableOrder_IN_ORDER = 0,
73  SatParameters_VariableOrder_IN_REVERSE_ORDER = 1,
74  SatParameters_VariableOrder_IN_RANDOM_ORDER = 2
75 };
76 bool SatParameters_VariableOrder_IsValid(int value);
77 constexpr SatParameters_VariableOrder SatParameters_VariableOrder_VariableOrder_MIN = SatParameters_VariableOrder_IN_ORDER;
78 constexpr SatParameters_VariableOrder SatParameters_VariableOrder_VariableOrder_MAX = SatParameters_VariableOrder_IN_RANDOM_ORDER;
79 constexpr int SatParameters_VariableOrder_VariableOrder_ARRAYSIZE = SatParameters_VariableOrder_VariableOrder_MAX + 1;
80 
81 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_VariableOrder_descriptor();
82 template<typename T>
83 inline const std::string& SatParameters_VariableOrder_Name(T enum_t_value) {
84  static_assert(::std::is_same<T, SatParameters_VariableOrder>::value ||
85  ::std::is_integral<T>::value,
86  "Incorrect type passed to function SatParameters_VariableOrder_Name.");
87  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
88  SatParameters_VariableOrder_descriptor(), enum_t_value);
89 }
90 inline bool SatParameters_VariableOrder_Parse(
91  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_VariableOrder* value) {
92  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_VariableOrder>(
93  SatParameters_VariableOrder_descriptor(), name, value);
94 }
95 enum SatParameters_Polarity : int {
96  SatParameters_Polarity_POLARITY_TRUE = 0,
97  SatParameters_Polarity_POLARITY_FALSE = 1,
98  SatParameters_Polarity_POLARITY_RANDOM = 2,
99  SatParameters_Polarity_POLARITY_WEIGHTED_SIGN = 3,
100  SatParameters_Polarity_POLARITY_REVERSE_WEIGHTED_SIGN = 4
101 };
102 bool SatParameters_Polarity_IsValid(int value);
103 constexpr SatParameters_Polarity SatParameters_Polarity_Polarity_MIN = SatParameters_Polarity_POLARITY_TRUE;
104 constexpr SatParameters_Polarity SatParameters_Polarity_Polarity_MAX = SatParameters_Polarity_POLARITY_REVERSE_WEIGHTED_SIGN;
105 constexpr int SatParameters_Polarity_Polarity_ARRAYSIZE = SatParameters_Polarity_Polarity_MAX + 1;
106 
107 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_Polarity_descriptor();
108 template<typename T>
109 inline const std::string& SatParameters_Polarity_Name(T enum_t_value) {
110  static_assert(::std::is_same<T, SatParameters_Polarity>::value ||
111  ::std::is_integral<T>::value,
112  "Incorrect type passed to function SatParameters_Polarity_Name.");
113  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
114  SatParameters_Polarity_descriptor(), enum_t_value);
115 }
116 inline bool SatParameters_Polarity_Parse(
117  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_Polarity* value) {
118  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_Polarity>(
119  SatParameters_Polarity_descriptor(), name, value);
120 }
121 enum SatParameters_ConflictMinimizationAlgorithm : int {
122  SatParameters_ConflictMinimizationAlgorithm_NONE = 0,
123  SatParameters_ConflictMinimizationAlgorithm_SIMPLE = 1,
124  SatParameters_ConflictMinimizationAlgorithm_RECURSIVE = 2,
125  SatParameters_ConflictMinimizationAlgorithm_EXPERIMENTAL = 3
126 };
127 bool SatParameters_ConflictMinimizationAlgorithm_IsValid(int value);
128 constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MIN = SatParameters_ConflictMinimizationAlgorithm_NONE;
129 constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MAX = SatParameters_ConflictMinimizationAlgorithm_EXPERIMENTAL;
130 constexpr int SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_ARRAYSIZE = SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MAX + 1;
131 
132 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_ConflictMinimizationAlgorithm_descriptor();
133 template<typename T>
134 inline const std::string& SatParameters_ConflictMinimizationAlgorithm_Name(T enum_t_value) {
135  static_assert(::std::is_same<T, SatParameters_ConflictMinimizationAlgorithm>::value ||
136  ::std::is_integral<T>::value,
137  "Incorrect type passed to function SatParameters_ConflictMinimizationAlgorithm_Name.");
138  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
139  SatParameters_ConflictMinimizationAlgorithm_descriptor(), enum_t_value);
140 }
141 inline bool SatParameters_ConflictMinimizationAlgorithm_Parse(
142  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_ConflictMinimizationAlgorithm* value) {
143  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_ConflictMinimizationAlgorithm>(
144  SatParameters_ConflictMinimizationAlgorithm_descriptor(), name, value);
145 }
146 enum SatParameters_BinaryMinizationAlgorithm : int {
147  SatParameters_BinaryMinizationAlgorithm_NO_BINARY_MINIMIZATION = 0,
148  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST = 1,
149  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION = 4,
150  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_WITH_REACHABILITY = 2,
151  SatParameters_BinaryMinizationAlgorithm_EXPERIMENTAL_BINARY_MINIMIZATION = 3
152 };
153 bool SatParameters_BinaryMinizationAlgorithm_IsValid(int value);
154 constexpr SatParameters_BinaryMinizationAlgorithm SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MIN = SatParameters_BinaryMinizationAlgorithm_NO_BINARY_MINIMIZATION;
155 constexpr SatParameters_BinaryMinizationAlgorithm SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MAX = SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION;
156 constexpr int SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_ARRAYSIZE = SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MAX + 1;
157 
158 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_BinaryMinizationAlgorithm_descriptor();
159 template<typename T>
160 inline const std::string& SatParameters_BinaryMinizationAlgorithm_Name(T enum_t_value) {
161  static_assert(::std::is_same<T, SatParameters_BinaryMinizationAlgorithm>::value ||
162  ::std::is_integral<T>::value,
163  "Incorrect type passed to function SatParameters_BinaryMinizationAlgorithm_Name.");
164  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
165  SatParameters_BinaryMinizationAlgorithm_descriptor(), enum_t_value);
166 }
167 inline bool SatParameters_BinaryMinizationAlgorithm_Parse(
168  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_BinaryMinizationAlgorithm* value) {
169  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_BinaryMinizationAlgorithm>(
170  SatParameters_BinaryMinizationAlgorithm_descriptor(), name, value);
171 }
172 enum SatParameters_ClauseProtection : int {
173  SatParameters_ClauseProtection_PROTECTION_NONE = 0,
174  SatParameters_ClauseProtection_PROTECTION_ALWAYS = 1,
175  SatParameters_ClauseProtection_PROTECTION_LBD = 2
176 };
177 bool SatParameters_ClauseProtection_IsValid(int value);
178 constexpr SatParameters_ClauseProtection SatParameters_ClauseProtection_ClauseProtection_MIN = SatParameters_ClauseProtection_PROTECTION_NONE;
179 constexpr SatParameters_ClauseProtection SatParameters_ClauseProtection_ClauseProtection_MAX = SatParameters_ClauseProtection_PROTECTION_LBD;
180 constexpr int SatParameters_ClauseProtection_ClauseProtection_ARRAYSIZE = SatParameters_ClauseProtection_ClauseProtection_MAX + 1;
181 
182 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_ClauseProtection_descriptor();
183 template<typename T>
184 inline const std::string& SatParameters_ClauseProtection_Name(T enum_t_value) {
185  static_assert(::std::is_same<T, SatParameters_ClauseProtection>::value ||
186  ::std::is_integral<T>::value,
187  "Incorrect type passed to function SatParameters_ClauseProtection_Name.");
188  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
189  SatParameters_ClauseProtection_descriptor(), enum_t_value);
190 }
191 inline bool SatParameters_ClauseProtection_Parse(
192  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_ClauseProtection* value) {
193  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_ClauseProtection>(
194  SatParameters_ClauseProtection_descriptor(), name, value);
195 }
196 enum SatParameters_ClauseOrdering : int {
197  SatParameters_ClauseOrdering_CLAUSE_ACTIVITY = 0,
198  SatParameters_ClauseOrdering_CLAUSE_LBD = 1
199 };
200 bool SatParameters_ClauseOrdering_IsValid(int value);
201 constexpr SatParameters_ClauseOrdering SatParameters_ClauseOrdering_ClauseOrdering_MIN = SatParameters_ClauseOrdering_CLAUSE_ACTIVITY;
202 constexpr SatParameters_ClauseOrdering SatParameters_ClauseOrdering_ClauseOrdering_MAX = SatParameters_ClauseOrdering_CLAUSE_LBD;
203 constexpr int SatParameters_ClauseOrdering_ClauseOrdering_ARRAYSIZE = SatParameters_ClauseOrdering_ClauseOrdering_MAX + 1;
204 
205 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_ClauseOrdering_descriptor();
206 template<typename T>
207 inline const std::string& SatParameters_ClauseOrdering_Name(T enum_t_value) {
208  static_assert(::std::is_same<T, SatParameters_ClauseOrdering>::value ||
209  ::std::is_integral<T>::value,
210  "Incorrect type passed to function SatParameters_ClauseOrdering_Name.");
211  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
212  SatParameters_ClauseOrdering_descriptor(), enum_t_value);
213 }
214 inline bool SatParameters_ClauseOrdering_Parse(
215  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_ClauseOrdering* value) {
216  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_ClauseOrdering>(
217  SatParameters_ClauseOrdering_descriptor(), name, value);
218 }
219 enum SatParameters_RestartAlgorithm : int {
220  SatParameters_RestartAlgorithm_NO_RESTART = 0,
221  SatParameters_RestartAlgorithm_LUBY_RESTART = 1,
222  SatParameters_RestartAlgorithm_DL_MOVING_AVERAGE_RESTART = 2,
223  SatParameters_RestartAlgorithm_LBD_MOVING_AVERAGE_RESTART = 3,
224  SatParameters_RestartAlgorithm_FIXED_RESTART = 4
225 };
226 bool SatParameters_RestartAlgorithm_IsValid(int value);
227 constexpr SatParameters_RestartAlgorithm SatParameters_RestartAlgorithm_RestartAlgorithm_MIN = SatParameters_RestartAlgorithm_NO_RESTART;
228 constexpr SatParameters_RestartAlgorithm SatParameters_RestartAlgorithm_RestartAlgorithm_MAX = SatParameters_RestartAlgorithm_FIXED_RESTART;
229 constexpr int SatParameters_RestartAlgorithm_RestartAlgorithm_ARRAYSIZE = SatParameters_RestartAlgorithm_RestartAlgorithm_MAX + 1;
230 
231 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_RestartAlgorithm_descriptor();
232 template<typename T>
233 inline const std::string& SatParameters_RestartAlgorithm_Name(T enum_t_value) {
234  static_assert(::std::is_same<T, SatParameters_RestartAlgorithm>::value ||
235  ::std::is_integral<T>::value,
236  "Incorrect type passed to function SatParameters_RestartAlgorithm_Name.");
237  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
238  SatParameters_RestartAlgorithm_descriptor(), enum_t_value);
239 }
240 inline bool SatParameters_RestartAlgorithm_Parse(
241  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_RestartAlgorithm* value) {
242  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_RestartAlgorithm>(
243  SatParameters_RestartAlgorithm_descriptor(), name, value);
244 }
245 enum SatParameters_MaxSatAssumptionOrder : int {
246  SatParameters_MaxSatAssumptionOrder_DEFAULT_ASSUMPTION_ORDER = 0,
247  SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_DEPTH = 1,
248  SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_WEIGHT = 2
249 };
250 bool SatParameters_MaxSatAssumptionOrder_IsValid(int value);
251 constexpr SatParameters_MaxSatAssumptionOrder SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MIN = SatParameters_MaxSatAssumptionOrder_DEFAULT_ASSUMPTION_ORDER;
252 constexpr SatParameters_MaxSatAssumptionOrder SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MAX = SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_WEIGHT;
253 constexpr int SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_ARRAYSIZE = SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MAX + 1;
254 
255 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_MaxSatAssumptionOrder_descriptor();
256 template<typename T>
257 inline const std::string& SatParameters_MaxSatAssumptionOrder_Name(T enum_t_value) {
258  static_assert(::std::is_same<T, SatParameters_MaxSatAssumptionOrder>::value ||
259  ::std::is_integral<T>::value,
260  "Incorrect type passed to function SatParameters_MaxSatAssumptionOrder_Name.");
261  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
262  SatParameters_MaxSatAssumptionOrder_descriptor(), enum_t_value);
263 }
264 inline bool SatParameters_MaxSatAssumptionOrder_Parse(
265  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_MaxSatAssumptionOrder* value) {
266  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_MaxSatAssumptionOrder>(
267  SatParameters_MaxSatAssumptionOrder_descriptor(), name, value);
268 }
269 enum SatParameters_MaxSatStratificationAlgorithm : int {
270  SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_NONE = 0,
271  SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_DESCENT = 1,
272  SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_ASCENT = 2
273 };
274 bool SatParameters_MaxSatStratificationAlgorithm_IsValid(int value);
275 constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MIN = SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_NONE;
276 constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MAX = SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_ASCENT;
277 constexpr int SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_ARRAYSIZE = SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MAX + 1;
278 
279 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_MaxSatStratificationAlgorithm_descriptor();
280 template<typename T>
281 inline const std::string& SatParameters_MaxSatStratificationAlgorithm_Name(T enum_t_value) {
282  static_assert(::std::is_same<T, SatParameters_MaxSatStratificationAlgorithm>::value ||
283  ::std::is_integral<T>::value,
284  "Incorrect type passed to function SatParameters_MaxSatStratificationAlgorithm_Name.");
285  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
286  SatParameters_MaxSatStratificationAlgorithm_descriptor(), enum_t_value);
287 }
288 inline bool SatParameters_MaxSatStratificationAlgorithm_Parse(
289  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_MaxSatStratificationAlgorithm* value) {
290  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_MaxSatStratificationAlgorithm>(
291  SatParameters_MaxSatStratificationAlgorithm_descriptor(), name, value);
292 }
293 enum SatParameters_SearchBranching : int {
294  SatParameters_SearchBranching_AUTOMATIC_SEARCH = 0,
295  SatParameters_SearchBranching_FIXED_SEARCH = 1,
296  SatParameters_SearchBranching_PORTFOLIO_SEARCH = 2,
297  SatParameters_SearchBranching_LP_SEARCH = 3,
298  SatParameters_SearchBranching_PSEUDO_COST_SEARCH = 4,
299  SatParameters_SearchBranching_PORTFOLIO_WITH_QUICK_RESTART_SEARCH = 5,
300  SatParameters_SearchBranching_HINT_SEARCH = 6
301 };
302 bool SatParameters_SearchBranching_IsValid(int value);
303 constexpr SatParameters_SearchBranching SatParameters_SearchBranching_SearchBranching_MIN = SatParameters_SearchBranching_AUTOMATIC_SEARCH;
304 constexpr SatParameters_SearchBranching SatParameters_SearchBranching_SearchBranching_MAX = SatParameters_SearchBranching_HINT_SEARCH;
305 constexpr int SatParameters_SearchBranching_SearchBranching_ARRAYSIZE = SatParameters_SearchBranching_SearchBranching_MAX + 1;
306 
307 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_SearchBranching_descriptor();
308 template<typename T>
309 inline const std::string& SatParameters_SearchBranching_Name(T enum_t_value) {
310  static_assert(::std::is_same<T, SatParameters_SearchBranching>::value ||
311  ::std::is_integral<T>::value,
312  "Incorrect type passed to function SatParameters_SearchBranching_Name.");
313  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
314  SatParameters_SearchBranching_descriptor(), enum_t_value);
315 }
316 inline bool SatParameters_SearchBranching_Parse(
317  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_SearchBranching* value) {
318  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_SearchBranching>(
319  SatParameters_SearchBranching_descriptor(), name, value);
320 }
321 enum SatParameters_FPRoundingMethod : int {
322  SatParameters_FPRoundingMethod_NEAREST_INTEGER = 0,
323  SatParameters_FPRoundingMethod_LOCK_BASED = 1,
324  SatParameters_FPRoundingMethod_ACTIVE_LOCK_BASED = 3,
325  SatParameters_FPRoundingMethod_PROPAGATION_ASSISTED = 2
326 };
327 bool SatParameters_FPRoundingMethod_IsValid(int value);
328 constexpr SatParameters_FPRoundingMethod SatParameters_FPRoundingMethod_FPRoundingMethod_MIN = SatParameters_FPRoundingMethod_NEAREST_INTEGER;
329 constexpr SatParameters_FPRoundingMethod SatParameters_FPRoundingMethod_FPRoundingMethod_MAX = SatParameters_FPRoundingMethod_ACTIVE_LOCK_BASED;
330 constexpr int SatParameters_FPRoundingMethod_FPRoundingMethod_ARRAYSIZE = SatParameters_FPRoundingMethod_FPRoundingMethod_MAX + 1;
331 
332 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_FPRoundingMethod_descriptor();
333 template<typename T>
334 inline const std::string& SatParameters_FPRoundingMethod_Name(T enum_t_value) {
335  static_assert(::std::is_same<T, SatParameters_FPRoundingMethod>::value ||
336  ::std::is_integral<T>::value,
337  "Incorrect type passed to function SatParameters_FPRoundingMethod_Name.");
338  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
339  SatParameters_FPRoundingMethod_descriptor(), enum_t_value);
340 }
341 inline bool SatParameters_FPRoundingMethod_Parse(
342  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_FPRoundingMethod* value) {
343  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_FPRoundingMethod>(
344  SatParameters_FPRoundingMethod_descriptor(), name, value);
345 }
346 // ===================================================================
347 
348 class SatParameters PROTOBUF_FINAL :
349  public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.SatParameters) */ {
350  public:
351  inline SatParameters() : SatParameters(nullptr) {}
352  virtual ~SatParameters();
353 
354  SatParameters(const SatParameters& from);
355  SatParameters(SatParameters&& from) noexcept
356  : SatParameters() {
357  *this = ::std::move(from);
358  }
359 
360  inline SatParameters& operator=(const SatParameters& from) {
361  CopyFrom(from);
362  return *this;
363  }
364  inline SatParameters& operator=(SatParameters&& from) noexcept {
365  if (GetArena() == from.GetArena()) {
366  if (this != &from) InternalSwap(&from);
367  } else {
368  CopyFrom(from);
369  }
370  return *this;
371  }
372 
373  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
374  return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
375  }
376  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
377  return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
378  }
379 
380  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
381  return GetDescriptor();
382  }
383  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
384  return GetMetadataStatic().descriptor;
385  }
386  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
387  return GetMetadataStatic().reflection;
388  }
389  static const SatParameters& default_instance();
390 
391  static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
392  static inline const SatParameters* internal_default_instance() {
393  return reinterpret_cast<const SatParameters*>(
394  &_SatParameters_default_instance_);
395  }
396  static constexpr int kIndexInFileMessages =
397  0;
398 
399  friend void swap(SatParameters& a, SatParameters& b) {
400  a.Swap(&b);
401  }
402  inline void Swap(SatParameters* other) {
403  if (other == this) return;
404  if (GetArena() == other->GetArena()) {
405  InternalSwap(other);
406  } else {
407  ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
408  }
409  }
410  void UnsafeArenaSwap(SatParameters* other) {
411  if (other == this) return;
412  GOOGLE_DCHECK(GetArena() == other->GetArena());
413  InternalSwap(other);
414  }
415 
416  // implements Message ----------------------------------------------
417 
418  inline SatParameters* New() const final {
419  return CreateMaybeMessage<SatParameters>(nullptr);
420  }
421 
422  SatParameters* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
423  return CreateMaybeMessage<SatParameters>(arena);
424  }
425  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
426  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
427  void CopyFrom(const SatParameters& from);
428  void MergeFrom(const SatParameters& from);
429  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
430  bool IsInitialized() const final;
431 
432  size_t ByteSizeLong() const final;
433  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
434  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
435  ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
436  int GetCachedSize() const final { return _cached_size_.Get(); }
437 
438  private:
439  inline void SharedCtor();
440  inline void SharedDtor();
441  void SetCachedSize(int size) const final;
442  void InternalSwap(SatParameters* other);
443  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
444  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
445  return "operations_research.sat.SatParameters";
446  }
447  protected:
448  explicit SatParameters(::PROTOBUF_NAMESPACE_ID::Arena* arena);
449  private:
450  static void ArenaDtor(void* object);
451  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
452  public:
453 
454  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
455  private:
456  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
457  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto);
458  return ::descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto.file_level_metadata[kIndexInFileMessages];
459  }
460 
461  public:
462 
463  // nested types ----------------------------------------------------
464 
465  typedef SatParameters_VariableOrder VariableOrder;
466  static constexpr VariableOrder IN_ORDER =
467  SatParameters_VariableOrder_IN_ORDER;
468  static constexpr VariableOrder IN_REVERSE_ORDER =
469  SatParameters_VariableOrder_IN_REVERSE_ORDER;
470  static constexpr VariableOrder IN_RANDOM_ORDER =
471  SatParameters_VariableOrder_IN_RANDOM_ORDER;
472  static inline bool VariableOrder_IsValid(int value) {
473  return SatParameters_VariableOrder_IsValid(value);
474  }
475  static constexpr VariableOrder VariableOrder_MIN =
476  SatParameters_VariableOrder_VariableOrder_MIN;
477  static constexpr VariableOrder VariableOrder_MAX =
478  SatParameters_VariableOrder_VariableOrder_MAX;
479  static constexpr int VariableOrder_ARRAYSIZE =
480  SatParameters_VariableOrder_VariableOrder_ARRAYSIZE;
481  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
482  VariableOrder_descriptor() {
483  return SatParameters_VariableOrder_descriptor();
484  }
485  template<typename T>
486  static inline const std::string& VariableOrder_Name(T enum_t_value) {
487  static_assert(::std::is_same<T, VariableOrder>::value ||
488  ::std::is_integral<T>::value,
489  "Incorrect type passed to function VariableOrder_Name.");
490  return SatParameters_VariableOrder_Name(enum_t_value);
491  }
492  static inline bool VariableOrder_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
493  VariableOrder* value) {
494  return SatParameters_VariableOrder_Parse(name, value);
495  }
496 
497  typedef SatParameters_Polarity Polarity;
498  static constexpr Polarity POLARITY_TRUE =
499  SatParameters_Polarity_POLARITY_TRUE;
500  static constexpr Polarity POLARITY_FALSE =
501  SatParameters_Polarity_POLARITY_FALSE;
502  static constexpr Polarity POLARITY_RANDOM =
503  SatParameters_Polarity_POLARITY_RANDOM;
504  static constexpr Polarity POLARITY_WEIGHTED_SIGN =
505  SatParameters_Polarity_POLARITY_WEIGHTED_SIGN;
506  static constexpr Polarity POLARITY_REVERSE_WEIGHTED_SIGN =
507  SatParameters_Polarity_POLARITY_REVERSE_WEIGHTED_SIGN;
508  static inline bool Polarity_IsValid(int value) {
509  return SatParameters_Polarity_IsValid(value);
510  }
511  static constexpr Polarity Polarity_MIN =
512  SatParameters_Polarity_Polarity_MIN;
513  static constexpr Polarity Polarity_MAX =
514  SatParameters_Polarity_Polarity_MAX;
515  static constexpr int Polarity_ARRAYSIZE =
516  SatParameters_Polarity_Polarity_ARRAYSIZE;
517  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
518  Polarity_descriptor() {
519  return SatParameters_Polarity_descriptor();
520  }
521  template<typename T>
522  static inline const std::string& Polarity_Name(T enum_t_value) {
523  static_assert(::std::is_same<T, Polarity>::value ||
524  ::std::is_integral<T>::value,
525  "Incorrect type passed to function Polarity_Name.");
526  return SatParameters_Polarity_Name(enum_t_value);
527  }
528  static inline bool Polarity_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
529  Polarity* value) {
530  return SatParameters_Polarity_Parse(name, value);
531  }
532 
533  typedef SatParameters_ConflictMinimizationAlgorithm ConflictMinimizationAlgorithm;
534  static constexpr ConflictMinimizationAlgorithm NONE =
535  SatParameters_ConflictMinimizationAlgorithm_NONE;
536  static constexpr ConflictMinimizationAlgorithm SIMPLE =
537  SatParameters_ConflictMinimizationAlgorithm_SIMPLE;
538  static constexpr ConflictMinimizationAlgorithm RECURSIVE =
539  SatParameters_ConflictMinimizationAlgorithm_RECURSIVE;
540  static constexpr ConflictMinimizationAlgorithm EXPERIMENTAL =
541  SatParameters_ConflictMinimizationAlgorithm_EXPERIMENTAL;
542  static inline bool ConflictMinimizationAlgorithm_IsValid(int value) {
543  return SatParameters_ConflictMinimizationAlgorithm_IsValid(value);
544  }
545  static constexpr ConflictMinimizationAlgorithm ConflictMinimizationAlgorithm_MIN =
546  SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MIN;
547  static constexpr ConflictMinimizationAlgorithm ConflictMinimizationAlgorithm_MAX =
548  SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MAX;
549  static constexpr int ConflictMinimizationAlgorithm_ARRAYSIZE =
550  SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_ARRAYSIZE;
551  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
552  ConflictMinimizationAlgorithm_descriptor() {
553  return SatParameters_ConflictMinimizationAlgorithm_descriptor();
554  }
555  template<typename T>
556  static inline const std::string& ConflictMinimizationAlgorithm_Name(T enum_t_value) {
557  static_assert(::std::is_same<T, ConflictMinimizationAlgorithm>::value ||
558  ::std::is_integral<T>::value,
559  "Incorrect type passed to function ConflictMinimizationAlgorithm_Name.");
560  return SatParameters_ConflictMinimizationAlgorithm_Name(enum_t_value);
561  }
562  static inline bool ConflictMinimizationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
563  ConflictMinimizationAlgorithm* value) {
564  return SatParameters_ConflictMinimizationAlgorithm_Parse(name, value);
565  }
566 
567  typedef SatParameters_BinaryMinizationAlgorithm BinaryMinizationAlgorithm;
568  static constexpr BinaryMinizationAlgorithm NO_BINARY_MINIMIZATION =
569  SatParameters_BinaryMinizationAlgorithm_NO_BINARY_MINIMIZATION;
570  static constexpr BinaryMinizationAlgorithm BINARY_MINIMIZATION_FIRST =
571  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST;
572  static constexpr BinaryMinizationAlgorithm BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION =
573  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION;
574  static constexpr BinaryMinizationAlgorithm BINARY_MINIMIZATION_WITH_REACHABILITY =
575  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_WITH_REACHABILITY;
576  static constexpr BinaryMinizationAlgorithm EXPERIMENTAL_BINARY_MINIMIZATION =
577  SatParameters_BinaryMinizationAlgorithm_EXPERIMENTAL_BINARY_MINIMIZATION;
578  static inline bool BinaryMinizationAlgorithm_IsValid(int value) {
579  return SatParameters_BinaryMinizationAlgorithm_IsValid(value);
580  }
581  static constexpr BinaryMinizationAlgorithm BinaryMinizationAlgorithm_MIN =
582  SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MIN;
583  static constexpr BinaryMinizationAlgorithm BinaryMinizationAlgorithm_MAX =
584  SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MAX;
585  static constexpr int BinaryMinizationAlgorithm_ARRAYSIZE =
586  SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_ARRAYSIZE;
587  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
588  BinaryMinizationAlgorithm_descriptor() {
589  return SatParameters_BinaryMinizationAlgorithm_descriptor();
590  }
591  template<typename T>
592  static inline const std::string& BinaryMinizationAlgorithm_Name(T enum_t_value) {
593  static_assert(::std::is_same<T, BinaryMinizationAlgorithm>::value ||
594  ::std::is_integral<T>::value,
595  "Incorrect type passed to function BinaryMinizationAlgorithm_Name.");
596  return SatParameters_BinaryMinizationAlgorithm_Name(enum_t_value);
597  }
598  static inline bool BinaryMinizationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
599  BinaryMinizationAlgorithm* value) {
600  return SatParameters_BinaryMinizationAlgorithm_Parse(name, value);
601  }
602 
603  typedef SatParameters_ClauseProtection ClauseProtection;
604  static constexpr ClauseProtection PROTECTION_NONE =
605  SatParameters_ClauseProtection_PROTECTION_NONE;
606  static constexpr ClauseProtection PROTECTION_ALWAYS =
607  SatParameters_ClauseProtection_PROTECTION_ALWAYS;
608  static constexpr ClauseProtection PROTECTION_LBD =
609  SatParameters_ClauseProtection_PROTECTION_LBD;
610  static inline bool ClauseProtection_IsValid(int value) {
611  return SatParameters_ClauseProtection_IsValid(value);
612  }
613  static constexpr ClauseProtection ClauseProtection_MIN =
614  SatParameters_ClauseProtection_ClauseProtection_MIN;
615  static constexpr ClauseProtection ClauseProtection_MAX =
616  SatParameters_ClauseProtection_ClauseProtection_MAX;
617  static constexpr int ClauseProtection_ARRAYSIZE =
618  SatParameters_ClauseProtection_ClauseProtection_ARRAYSIZE;
619  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
620  ClauseProtection_descriptor() {
621  return SatParameters_ClauseProtection_descriptor();
622  }
623  template<typename T>
624  static inline const std::string& ClauseProtection_Name(T enum_t_value) {
625  static_assert(::std::is_same<T, ClauseProtection>::value ||
626  ::std::is_integral<T>::value,
627  "Incorrect type passed to function ClauseProtection_Name.");
628  return SatParameters_ClauseProtection_Name(enum_t_value);
629  }
630  static inline bool ClauseProtection_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
631  ClauseProtection* value) {
632  return SatParameters_ClauseProtection_Parse(name, value);
633  }
634 
635  typedef SatParameters_ClauseOrdering ClauseOrdering;
636  static constexpr ClauseOrdering CLAUSE_ACTIVITY =
637  SatParameters_ClauseOrdering_CLAUSE_ACTIVITY;
638  static constexpr ClauseOrdering CLAUSE_LBD =
639  SatParameters_ClauseOrdering_CLAUSE_LBD;
640  static inline bool ClauseOrdering_IsValid(int value) {
641  return SatParameters_ClauseOrdering_IsValid(value);
642  }
643  static constexpr ClauseOrdering ClauseOrdering_MIN =
644  SatParameters_ClauseOrdering_ClauseOrdering_MIN;
645  static constexpr ClauseOrdering ClauseOrdering_MAX =
646  SatParameters_ClauseOrdering_ClauseOrdering_MAX;
647  static constexpr int ClauseOrdering_ARRAYSIZE =
648  SatParameters_ClauseOrdering_ClauseOrdering_ARRAYSIZE;
649  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
650  ClauseOrdering_descriptor() {
651  return SatParameters_ClauseOrdering_descriptor();
652  }
653  template<typename T>
654  static inline const std::string& ClauseOrdering_Name(T enum_t_value) {
655  static_assert(::std::is_same<T, ClauseOrdering>::value ||
656  ::std::is_integral<T>::value,
657  "Incorrect type passed to function ClauseOrdering_Name.");
658  return SatParameters_ClauseOrdering_Name(enum_t_value);
659  }
660  static inline bool ClauseOrdering_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
661  ClauseOrdering* value) {
662  return SatParameters_ClauseOrdering_Parse(name, value);
663  }
664 
665  typedef SatParameters_RestartAlgorithm RestartAlgorithm;
666  static constexpr RestartAlgorithm NO_RESTART =
667  SatParameters_RestartAlgorithm_NO_RESTART;
668  static constexpr RestartAlgorithm LUBY_RESTART =
669  SatParameters_RestartAlgorithm_LUBY_RESTART;
670  static constexpr RestartAlgorithm DL_MOVING_AVERAGE_RESTART =
671  SatParameters_RestartAlgorithm_DL_MOVING_AVERAGE_RESTART;
672  static constexpr RestartAlgorithm LBD_MOVING_AVERAGE_RESTART =
673  SatParameters_RestartAlgorithm_LBD_MOVING_AVERAGE_RESTART;
674  static constexpr RestartAlgorithm FIXED_RESTART =
675  SatParameters_RestartAlgorithm_FIXED_RESTART;
676  static inline bool RestartAlgorithm_IsValid(int value) {
677  return SatParameters_RestartAlgorithm_IsValid(value);
678  }
679  static constexpr RestartAlgorithm RestartAlgorithm_MIN =
680  SatParameters_RestartAlgorithm_RestartAlgorithm_MIN;
681  static constexpr RestartAlgorithm RestartAlgorithm_MAX =
682  SatParameters_RestartAlgorithm_RestartAlgorithm_MAX;
683  static constexpr int RestartAlgorithm_ARRAYSIZE =
684  SatParameters_RestartAlgorithm_RestartAlgorithm_ARRAYSIZE;
685  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
686  RestartAlgorithm_descriptor() {
687  return SatParameters_RestartAlgorithm_descriptor();
688  }
689  template<typename T>
690  static inline const std::string& RestartAlgorithm_Name(T enum_t_value) {
691  static_assert(::std::is_same<T, RestartAlgorithm>::value ||
692  ::std::is_integral<T>::value,
693  "Incorrect type passed to function RestartAlgorithm_Name.");
694  return SatParameters_RestartAlgorithm_Name(enum_t_value);
695  }
696  static inline bool RestartAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
697  RestartAlgorithm* value) {
698  return SatParameters_RestartAlgorithm_Parse(name, value);
699  }
700 
701  typedef SatParameters_MaxSatAssumptionOrder MaxSatAssumptionOrder;
702  static constexpr MaxSatAssumptionOrder DEFAULT_ASSUMPTION_ORDER =
703  SatParameters_MaxSatAssumptionOrder_DEFAULT_ASSUMPTION_ORDER;
704  static constexpr MaxSatAssumptionOrder ORDER_ASSUMPTION_BY_DEPTH =
705  SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_DEPTH;
706  static constexpr MaxSatAssumptionOrder ORDER_ASSUMPTION_BY_WEIGHT =
707  SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_WEIGHT;
708  static inline bool MaxSatAssumptionOrder_IsValid(int value) {
709  return SatParameters_MaxSatAssumptionOrder_IsValid(value);
710  }
711  static constexpr MaxSatAssumptionOrder MaxSatAssumptionOrder_MIN =
712  SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MIN;
713  static constexpr MaxSatAssumptionOrder MaxSatAssumptionOrder_MAX =
714  SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MAX;
715  static constexpr int MaxSatAssumptionOrder_ARRAYSIZE =
716  SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_ARRAYSIZE;
717  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
718  MaxSatAssumptionOrder_descriptor() {
719  return SatParameters_MaxSatAssumptionOrder_descriptor();
720  }
721  template<typename T>
722  static inline const std::string& MaxSatAssumptionOrder_Name(T enum_t_value) {
723  static_assert(::std::is_same<T, MaxSatAssumptionOrder>::value ||
724  ::std::is_integral<T>::value,
725  "Incorrect type passed to function MaxSatAssumptionOrder_Name.");
726  return SatParameters_MaxSatAssumptionOrder_Name(enum_t_value);
727  }
728  static inline bool MaxSatAssumptionOrder_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
729  MaxSatAssumptionOrder* value) {
730  return SatParameters_MaxSatAssumptionOrder_Parse(name, value);
731  }
732 
733  typedef SatParameters_MaxSatStratificationAlgorithm MaxSatStratificationAlgorithm;
734  static constexpr MaxSatStratificationAlgorithm STRATIFICATION_NONE =
735  SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_NONE;
736  static constexpr MaxSatStratificationAlgorithm STRATIFICATION_DESCENT =
737  SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_DESCENT;
738  static constexpr MaxSatStratificationAlgorithm STRATIFICATION_ASCENT =
739  SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_ASCENT;
740  static inline bool MaxSatStratificationAlgorithm_IsValid(int value) {
741  return SatParameters_MaxSatStratificationAlgorithm_IsValid(value);
742  }
743  static constexpr MaxSatStratificationAlgorithm MaxSatStratificationAlgorithm_MIN =
744  SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MIN;
745  static constexpr MaxSatStratificationAlgorithm MaxSatStratificationAlgorithm_MAX =
746  SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MAX;
747  static constexpr int MaxSatStratificationAlgorithm_ARRAYSIZE =
748  SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_ARRAYSIZE;
749  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
750  MaxSatStratificationAlgorithm_descriptor() {
751  return SatParameters_MaxSatStratificationAlgorithm_descriptor();
752  }
753  template<typename T>
754  static inline const std::string& MaxSatStratificationAlgorithm_Name(T enum_t_value) {
755  static_assert(::std::is_same<T, MaxSatStratificationAlgorithm>::value ||
756  ::std::is_integral<T>::value,
757  "Incorrect type passed to function MaxSatStratificationAlgorithm_Name.");
758  return SatParameters_MaxSatStratificationAlgorithm_Name(enum_t_value);
759  }
760  static inline bool MaxSatStratificationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
761  MaxSatStratificationAlgorithm* value) {
762  return SatParameters_MaxSatStratificationAlgorithm_Parse(name, value);
763  }
764 
765  typedef SatParameters_SearchBranching SearchBranching;
766  static constexpr SearchBranching AUTOMATIC_SEARCH =
767  SatParameters_SearchBranching_AUTOMATIC_SEARCH;
768  static constexpr SearchBranching FIXED_SEARCH =
769  SatParameters_SearchBranching_FIXED_SEARCH;
770  static constexpr SearchBranching PORTFOLIO_SEARCH =
771  SatParameters_SearchBranching_PORTFOLIO_SEARCH;
772  static constexpr SearchBranching LP_SEARCH =
773  SatParameters_SearchBranching_LP_SEARCH;
774  static constexpr SearchBranching PSEUDO_COST_SEARCH =
775  SatParameters_SearchBranching_PSEUDO_COST_SEARCH;
776  static constexpr SearchBranching PORTFOLIO_WITH_QUICK_RESTART_SEARCH =
777  SatParameters_SearchBranching_PORTFOLIO_WITH_QUICK_RESTART_SEARCH;
778  static constexpr SearchBranching HINT_SEARCH =
779  SatParameters_SearchBranching_HINT_SEARCH;
780  static inline bool SearchBranching_IsValid(int value) {
781  return SatParameters_SearchBranching_IsValid(value);
782  }
783  static constexpr SearchBranching SearchBranching_MIN =
784  SatParameters_SearchBranching_SearchBranching_MIN;
785  static constexpr SearchBranching SearchBranching_MAX =
786  SatParameters_SearchBranching_SearchBranching_MAX;
787  static constexpr int SearchBranching_ARRAYSIZE =
788  SatParameters_SearchBranching_SearchBranching_ARRAYSIZE;
789  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
790  SearchBranching_descriptor() {
791  return SatParameters_SearchBranching_descriptor();
792  }
793  template<typename T>
794  static inline const std::string& SearchBranching_Name(T enum_t_value) {
795  static_assert(::std::is_same<T, SearchBranching>::value ||
796  ::std::is_integral<T>::value,
797  "Incorrect type passed to function SearchBranching_Name.");
798  return SatParameters_SearchBranching_Name(enum_t_value);
799  }
800  static inline bool SearchBranching_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
801  SearchBranching* value) {
802  return SatParameters_SearchBranching_Parse(name, value);
803  }
804 
805  typedef SatParameters_FPRoundingMethod FPRoundingMethod;
806  static constexpr FPRoundingMethod NEAREST_INTEGER =
807  SatParameters_FPRoundingMethod_NEAREST_INTEGER;
808  static constexpr FPRoundingMethod LOCK_BASED =
809  SatParameters_FPRoundingMethod_LOCK_BASED;
810  static constexpr FPRoundingMethod ACTIVE_LOCK_BASED =
811  SatParameters_FPRoundingMethod_ACTIVE_LOCK_BASED;
812  static constexpr FPRoundingMethod PROPAGATION_ASSISTED =
813  SatParameters_FPRoundingMethod_PROPAGATION_ASSISTED;
814  static inline bool FPRoundingMethod_IsValid(int value) {
815  return SatParameters_FPRoundingMethod_IsValid(value);
816  }
817  static constexpr FPRoundingMethod FPRoundingMethod_MIN =
818  SatParameters_FPRoundingMethod_FPRoundingMethod_MIN;
819  static constexpr FPRoundingMethod FPRoundingMethod_MAX =
820  SatParameters_FPRoundingMethod_FPRoundingMethod_MAX;
821  static constexpr int FPRoundingMethod_ARRAYSIZE =
822  SatParameters_FPRoundingMethod_FPRoundingMethod_ARRAYSIZE;
823  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
824  FPRoundingMethod_descriptor() {
825  return SatParameters_FPRoundingMethod_descriptor();
826  }
827  template<typename T>
828  static inline const std::string& FPRoundingMethod_Name(T enum_t_value) {
829  static_assert(::std::is_same<T, FPRoundingMethod>::value ||
830  ::std::is_integral<T>::value,
831  "Incorrect type passed to function FPRoundingMethod_Name.");
832  return SatParameters_FPRoundingMethod_Name(enum_t_value);
833  }
834  static inline bool FPRoundingMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
835  FPRoundingMethod* value) {
836  return SatParameters_FPRoundingMethod_Parse(name, value);
837  }
838 
839  // accessors -------------------------------------------------------
840 
841  enum : int {
842  kRestartAlgorithmsFieldNumber = 61,
843  kDefaultRestartAlgorithmsFieldNumber = 70,
844  kPreferredVariableOrderFieldNumber = 1,
845  kMaxSatAssumptionOrderFieldNumber = 51,
846  kRandomBranchesRatioFieldNumber = 32,
847  kRandomPolarityRatioFieldNumber = 45,
848  kClauseCleanupProtectionFieldNumber = 58,
849  kClauseCleanupOrderingFieldNumber = 60,
850  kUseErwaHeuristicFieldNumber = 75,
851  kAlsoBumpVariablesInConflictReasonsFieldNumber = 77,
852  kUseBlockingRestartFieldNumber = 64,
853  kLogSearchProgressFieldNumber = 41,
854  kNumConflictsBeforeStrategyChangesFieldNumber = 68,
855  kStrategyChangeIncreaseRatioFieldNumber = 69,
856  kInitialVariablesActivityFieldNumber = 76,
857  kMaxSatReverseAssumptionOrderFieldNumber = 52,
858  kUseOverloadCheckerInCumulativeConstraintFieldNumber = 78,
859  kUseTimetableEdgeFindingInCumulativeConstraintFieldNumber = 79,
860  kOnlyAddCutsAtLevelZeroFieldNumber = 92,
861  kSearchBranchingFieldNumber = 82,
862  kOptimizeWithCoreFieldNumber = 83,
863  kOptimizeWithMaxHsFieldNumber = 85,
864  kEnumerateAllSolutionsFieldNumber = 87,
865  kFillTightenedDomainsInResponseFieldNumber = 132,
866  kUsePbResolutionFieldNumber = 43,
867  kMinimizeReductionDuringPbResolutionFieldNumber = 48,
868  kCpModelPostsolveWithFullSolverFieldNumber = 162,
869  kUseSatInprocessingFieldNumber = 163,
870  kSearchRandomizationToleranceFieldNumber = 104,
871  kUseLnsOnlyFieldNumber = 101,
872  kLnsFocusOnDecisionVariablesFieldNumber = 105,
873  kUseRelaxationLnsFieldNumber = 150,
874  kDiversifyLnsParamsFieldNumber = 137,
875  kRandomizeSearchFieldNumber = 103,
876  kUseBranchingInLpFieldNumber = 139,
877  kUseCombinedNoOverlapFieldNumber = 133,
878  kStopAfterFirstSolutionFieldNumber = 98,
879  kStopAfterPresolveFieldNumber = 149,
880  kInterleaveSearchFieldNumber = 136,
881  kReduceMemoryUsageInInterleaveModeFieldNumber = 141,
882  kAddKnapsackCutsFieldNumber = 111,
883  kRepairHintFieldNumber = 167,
884  kExploitBestSolutionFieldNumber = 130,
885  kExploitRelaxationSolutionFieldNumber = 161,
886  kProbingPeriodAtRootFieldNumber = 142,
887  kCpModelMaxNumPresolveOperationsFieldNumber = 151,
888  kAbsoluteGapLimitFieldNumber = 159,
889  kRelativeGapLimitFieldNumber = 160,
890  kInitialPolarityFieldNumber = 2,
891  kMinimizationAlgorithmFieldNumber = 4,
892  kClauseCleanupPeriodFieldNumber = 11,
893  kClauseCleanupTargetFieldNumber = 13,
894  kVariableActivityDecayFieldNumber = 15,
895  kMaxVariableActivityValueFieldNumber = 16,
896  kClauseActivityDecayFieldNumber = 17,
897  kMaxClauseActivityValueFieldNumber = 18,
898  kGlucoseMaxDecayFieldNumber = 22,
899  kGlucoseDecayIncrementFieldNumber = 23,
900  kGlucoseDecayIncrementPeriodFieldNumber = 24,
901  kRestartPeriodFieldNumber = 30,
902  kRandomSeedFieldNumber = 31,
903  kBinaryMinimizationAlgorithmFieldNumber = 34,
904  kMaxTimeInSecondsFieldNumber = 36,
905  kMaxNumberOfConflictsFieldNumber = 37,
906  kMaxMemoryInMbFieldNumber = 40,
907  kUsePhaseSavingFieldNumber = 44,
908  kSubsumptionDuringConflictAnalysisFieldNumber = 56,
909  kTreatBinaryClausesSeparatelyFieldNumber = 33,
910  kCountAssumptionLevelsInLbdFieldNumber = 49,
911  kPbCleanupIncrementFieldNumber = 46,
912  kPbCleanupRatioFieldNumber = 47,
913  kMaxSatStratificationFieldNumber = 53,
914  kPresolveBveThresholdFieldNumber = 54,
915  kPresolveProbingDeterministicTimeLimitFieldNumber = 57,
916  kPresolveBveClauseWeightFieldNumber = 55,
917  kClauseCleanupLbdBoundFieldNumber = 59,
918  kRestartDlAverageRatioFieldNumber = 63,
919  kRestartRunningWindowSizeFieldNumber = 62,
920  kBlockingRestartWindowSizeFieldNumber = 65,
921  kBlockingRestartMultiplierFieldNumber = 66,
922  kMaxDeterministicTimeFieldNumber = 67,
923  kRestartLbdAverageRatioFieldNumber = 71,
924  kPresolveBvaThresholdFieldNumber = 73,
925  kMinimizeCoreFieldNumber = 50,
926  kFindMultipleCoresFieldNumber = 84,
927  kCoverOptimizationFieldNumber = 89,
928  kUsePrecedencesInDisjunctiveConstraintFieldNumber = 74,
929  kPresolveBlockedClauseFieldNumber = 88,
930  kPresolveUseBvaFieldNumber = 72,
931  kCpModelPresolveFieldNumber = 86,
932  kCpModelUseSatPresolveFieldNumber = 93,
933  kLinearizationLevelFieldNumber = 90,
934  kMaxNumCutsFieldNumber = 91,
935  kMinimizeWithPropagationRestartPeriodFieldNumber = 96,
936  kMinimizeWithPropagationNumDecisionsFieldNumber = 97,
937  kBinarySearchNumConflictsFieldNumber = 99,
938  kNumSearchWorkersFieldNumber = 100,
939  kBooleanEncodingLevelFieldNumber = 107,
940  kInstantiateAllVariablesFieldNumber = 106,
941  kAutoDetectGreaterThanAtLeastOneOfFieldNumber = 95,
942  kShareObjectiveBoundsFieldNumber = 113,
943  kShareLevelZeroBoundsFieldNumber = 114,
944  kCpModelProbingLevelFieldNumber = 110,
945  kMinOrthogonalityForLpConstraintsFieldNumber = 115,
946  kAddLpConstraintsLazilyFieldNumber = 112,
947  kExploitIntegerLpSolutionFieldNumber = 94,
948  kExploitAllLpSolutionFieldNumber = 116,
949  kExploitObjectiveFieldNumber = 131,
950  kUseDisjunctiveConstraintInCumulativeConstraintFieldNumber = 80,
951  kAddCgCutsFieldNumber = 117,
952  kAddMirCutsFieldNumber = 120,
953  kAddLinMaxCutsFieldNumber = 152,
954  kMaxIntegerRoundingScalingFieldNumber = 119,
955  kExpandElementConstraintsFieldNumber = 140,
956  kExpandAutomatonConstraintsFieldNumber = 143,
957  kExpandTableConstraintsFieldNumber = 158,
958  kUseOptimizationHintsFieldNumber = 35,
959  kMaxConsecutiveInactiveCountFieldNumber = 121,
960  kNewConstraintsBatchSizeFieldNumber = 122,
961  kPseudoCostReliabilityThresholdFieldNumber = 123,
962  kMipMaxBoundFieldNumber = 124,
963  kMipVarScalingFieldNumber = 125,
964  kMipWantedPrecisionFieldNumber = 126,
965  kMipMaxActivityExponentFieldNumber = 127,
966  kUseRinsLnsFieldNumber = 129,
967  kUseFeasibilityPumpFieldNumber = 164,
968  kUseOptionalVariablesFieldNumber = 108,
969  kUseExactLpReasonFieldNumber = 109,
970  kMipCheckPrecisionFieldNumber = 128,
971  kInterleaveBatchSizeFieldNumber = 134,
972  kMaxPresolveIterationsFieldNumber = 138,
973  kMergeNoOverlapWorkLimitFieldNumber = 145,
974  kMergeAtMostOneWorkLimitFieldNumber = 146,
975  kPresolveSubstitutionLevelFieldNumber = 147,
976  kMaxAllDiffCutSizeFieldNumber = 148,
977  kCatchSigintSignalFieldNumber = 135,
978  kUseImpliedBoundsFieldNumber = 144,
979  kMipAutomaticallyScaleVariablesFieldNumber = 166,
980  kHintConflictLimitFieldNumber = 153,
981  kCutMaxActiveCountValueFieldNumber = 155,
982  kMaxCutRoundsAtLevelZeroFieldNumber = 154,
983  kCutCleanupTargetFieldNumber = 157,
984  kCutActiveCountDecayFieldNumber = 156,
985  kFpRoundingFieldNumber = 165,
986  kPolarityRephaseIncrementFieldNumber = 168,
987  };
988  // repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
989  int restart_algorithms_size() const;
990  private:
991  int _internal_restart_algorithms_size() const;
992  public:
993  void clear_restart_algorithms();
994  private:
995  ::operations_research::sat::SatParameters_RestartAlgorithm _internal_restart_algorithms(int index) const;
996  void _internal_add_restart_algorithms(::operations_research::sat::SatParameters_RestartAlgorithm value);
997  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_restart_algorithms();
998  public:
999  ::operations_research::sat::SatParameters_RestartAlgorithm restart_algorithms(int index) const;
1000  void set_restart_algorithms(int index, ::operations_research::sat::SatParameters_RestartAlgorithm value);
1001  void add_restart_algorithms(::operations_research::sat::SatParameters_RestartAlgorithm value);
1002  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& restart_algorithms() const;
1003  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_restart_algorithms();
1004 
1005  // optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
1006  bool has_default_restart_algorithms() const;
1007  private:
1008  bool _internal_has_default_restart_algorithms() const;
1009  public:
1010  void clear_default_restart_algorithms();
1011  const std::string& default_restart_algorithms() const;
1012  void set_default_restart_algorithms(const std::string& value);
1013  void set_default_restart_algorithms(std::string&& value);
1014  void set_default_restart_algorithms(const char* value);
1015  void set_default_restart_algorithms(const char* value, size_t size);
1016  std::string* mutable_default_restart_algorithms();
1017  std::string* release_default_restart_algorithms();
1018  void set_allocated_default_restart_algorithms(std::string* default_restart_algorithms);
1019  private:
1020  const std::string& _internal_default_restart_algorithms() const;
1021  void _internal_set_default_restart_algorithms(const std::string& value);
1022  std::string* _internal_mutable_default_restart_algorithms();
1023  public:
1024 
1025  // optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
1026  bool has_preferred_variable_order() const;
1027  private:
1028  bool _internal_has_preferred_variable_order() const;
1029  public:
1030  void clear_preferred_variable_order();
1031  ::operations_research::sat::SatParameters_VariableOrder preferred_variable_order() const;
1032  void set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value);
1033  private:
1034  ::operations_research::sat::SatParameters_VariableOrder _internal_preferred_variable_order() const;
1035  void _internal_set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value);
1036  public:
1037 
1038  // optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
1039  bool has_max_sat_assumption_order() const;
1040  private:
1041  bool _internal_has_max_sat_assumption_order() const;
1042  public:
1043  void clear_max_sat_assumption_order();
1044  ::operations_research::sat::SatParameters_MaxSatAssumptionOrder max_sat_assumption_order() const;
1045  void set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value);
1046  private:
1047  ::operations_research::sat::SatParameters_MaxSatAssumptionOrder _internal_max_sat_assumption_order() const;
1048  void _internal_set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value);
1049  public:
1050 
1051  // optional double random_branches_ratio = 32 [default = 0];
1052  bool has_random_branches_ratio() const;
1053  private:
1054  bool _internal_has_random_branches_ratio() const;
1055  public:
1056  void clear_random_branches_ratio();
1057  double random_branches_ratio() const;
1058  void set_random_branches_ratio(double value);
1059  private:
1060  double _internal_random_branches_ratio() const;
1061  void _internal_set_random_branches_ratio(double value);
1062  public:
1063 
1064  // optional double random_polarity_ratio = 45 [default = 0];
1065  bool has_random_polarity_ratio() const;
1066  private:
1067  bool _internal_has_random_polarity_ratio() const;
1068  public:
1069  void clear_random_polarity_ratio();
1070  double random_polarity_ratio() const;
1071  void set_random_polarity_ratio(double value);
1072  private:
1073  double _internal_random_polarity_ratio() const;
1074  void _internal_set_random_polarity_ratio(double value);
1075  public:
1076 
1077  // optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];
1078  bool has_clause_cleanup_protection() const;
1079  private:
1080  bool _internal_has_clause_cleanup_protection() const;
1081  public:
1082  void clear_clause_cleanup_protection();
1083  ::operations_research::sat::SatParameters_ClauseProtection clause_cleanup_protection() const;
1084  void set_clause_cleanup_protection(::operations_research::sat::SatParameters_ClauseProtection value);
1085  private:
1086  ::operations_research::sat::SatParameters_ClauseProtection _internal_clause_cleanup_protection() const;
1087  void _internal_set_clause_cleanup_protection(::operations_research::sat::SatParameters_ClauseProtection value);
1088  public:
1089 
1090  // optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
1091  bool has_clause_cleanup_ordering() const;
1092  private:
1093  bool _internal_has_clause_cleanup_ordering() const;
1094  public:
1095  void clear_clause_cleanup_ordering();
1096  ::operations_research::sat::SatParameters_ClauseOrdering clause_cleanup_ordering() const;
1097  void set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value);
1098  private:
1099  ::operations_research::sat::SatParameters_ClauseOrdering _internal_clause_cleanup_ordering() const;
1100  void _internal_set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value);
1101  public:
1102 
1103  // optional bool use_erwa_heuristic = 75 [default = false];
1104  bool has_use_erwa_heuristic() const;
1105  private:
1106  bool _internal_has_use_erwa_heuristic() const;
1107  public:
1108  void clear_use_erwa_heuristic();
1109  bool use_erwa_heuristic() const;
1110  void set_use_erwa_heuristic(bool value);
1111  private:
1112  bool _internal_use_erwa_heuristic() const;
1113  void _internal_set_use_erwa_heuristic(bool value);
1114  public:
1115 
1116  // optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
1117  bool has_also_bump_variables_in_conflict_reasons() const;
1118  private:
1119  bool _internal_has_also_bump_variables_in_conflict_reasons() const;
1120  public:
1121  void clear_also_bump_variables_in_conflict_reasons();
1122  bool also_bump_variables_in_conflict_reasons() const;
1123  void set_also_bump_variables_in_conflict_reasons(bool value);
1124  private:
1125  bool _internal_also_bump_variables_in_conflict_reasons() const;
1126  void _internal_set_also_bump_variables_in_conflict_reasons(bool value);
1127  public:
1128 
1129  // optional bool use_blocking_restart = 64 [default = false];
1130  bool has_use_blocking_restart() const;
1131  private:
1132  bool _internal_has_use_blocking_restart() const;
1133  public:
1134  void clear_use_blocking_restart();
1135  bool use_blocking_restart() const;
1136  void set_use_blocking_restart(bool value);
1137  private:
1138  bool _internal_use_blocking_restart() const;
1139  void _internal_set_use_blocking_restart(bool value);
1140  public:
1141 
1142  // optional bool log_search_progress = 41 [default = false];
1143  bool has_log_search_progress() const;
1144  private:
1145  bool _internal_has_log_search_progress() const;
1146  public:
1147  void clear_log_search_progress();
1148  bool log_search_progress() const;
1149  void set_log_search_progress(bool value);
1150  private:
1151  bool _internal_log_search_progress() const;
1152  void _internal_set_log_search_progress(bool value);
1153  public:
1154 
1155  // optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
1156  bool has_num_conflicts_before_strategy_changes() const;
1157  private:
1158  bool _internal_has_num_conflicts_before_strategy_changes() const;
1159  public:
1160  void clear_num_conflicts_before_strategy_changes();
1161  ::PROTOBUF_NAMESPACE_ID::int32 num_conflicts_before_strategy_changes() const;
1162  void set_num_conflicts_before_strategy_changes(::PROTOBUF_NAMESPACE_ID::int32 value);
1163  private:
1164  ::PROTOBUF_NAMESPACE_ID::int32 _internal_num_conflicts_before_strategy_changes() const;
1165  void _internal_set_num_conflicts_before_strategy_changes(::PROTOBUF_NAMESPACE_ID::int32 value);
1166  public:
1167 
1168  // optional double strategy_change_increase_ratio = 69 [default = 0];
1169  bool has_strategy_change_increase_ratio() const;
1170  private:
1171  bool _internal_has_strategy_change_increase_ratio() const;
1172  public:
1173  void clear_strategy_change_increase_ratio();
1174  double strategy_change_increase_ratio() const;
1175  void set_strategy_change_increase_ratio(double value);
1176  private:
1177  double _internal_strategy_change_increase_ratio() const;
1178  void _internal_set_strategy_change_increase_ratio(double value);
1179  public:
1180 
1181  // optional double initial_variables_activity = 76 [default = 0];
1182  bool has_initial_variables_activity() const;
1183  private:
1184  bool _internal_has_initial_variables_activity() const;
1185  public:
1186  void clear_initial_variables_activity();
1187  double initial_variables_activity() const;
1188  void set_initial_variables_activity(double value);
1189  private:
1190  double _internal_initial_variables_activity() const;
1191  void _internal_set_initial_variables_activity(double value);
1192  public:
1193 
1194  // optional bool max_sat_reverse_assumption_order = 52 [default = false];
1195  bool has_max_sat_reverse_assumption_order() const;
1196  private:
1197  bool _internal_has_max_sat_reverse_assumption_order() const;
1198  public:
1199  void clear_max_sat_reverse_assumption_order();
1200  bool max_sat_reverse_assumption_order() const;
1201  void set_max_sat_reverse_assumption_order(bool value);
1202  private:
1203  bool _internal_max_sat_reverse_assumption_order() const;
1204  void _internal_set_max_sat_reverse_assumption_order(bool value);
1205  public:
1206 
1207  // optional bool use_overload_checker_in_cumulative_constraint = 78 [default = false];
1208  bool has_use_overload_checker_in_cumulative_constraint() const;
1209  private:
1210  bool _internal_has_use_overload_checker_in_cumulative_constraint() const;
1211  public:
1212  void clear_use_overload_checker_in_cumulative_constraint();
1213  bool use_overload_checker_in_cumulative_constraint() const;
1214  void set_use_overload_checker_in_cumulative_constraint(bool value);
1215  private:
1216  bool _internal_use_overload_checker_in_cumulative_constraint() const;
1217  void _internal_set_use_overload_checker_in_cumulative_constraint(bool value);
1218  public:
1219 
1220  // optional bool use_timetable_edge_finding_in_cumulative_constraint = 79 [default = false];
1221  bool has_use_timetable_edge_finding_in_cumulative_constraint() const;
1222  private:
1223  bool _internal_has_use_timetable_edge_finding_in_cumulative_constraint() const;
1224  public:
1225  void clear_use_timetable_edge_finding_in_cumulative_constraint();
1226  bool use_timetable_edge_finding_in_cumulative_constraint() const;
1227  void set_use_timetable_edge_finding_in_cumulative_constraint(bool value);
1228  private:
1229  bool _internal_use_timetable_edge_finding_in_cumulative_constraint() const;
1230  void _internal_set_use_timetable_edge_finding_in_cumulative_constraint(bool value);
1231  public:
1232 
1233  // optional bool only_add_cuts_at_level_zero = 92 [default = false];
1234  bool has_only_add_cuts_at_level_zero() const;
1235  private:
1236  bool _internal_has_only_add_cuts_at_level_zero() const;
1237  public:
1238  void clear_only_add_cuts_at_level_zero();
1239  bool only_add_cuts_at_level_zero() const;
1240  void set_only_add_cuts_at_level_zero(bool value);
1241  private:
1242  bool _internal_only_add_cuts_at_level_zero() const;
1243  void _internal_set_only_add_cuts_at_level_zero(bool value);
1244  public:
1245 
1246  // optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
1247  bool has_search_branching() const;
1248  private:
1249  bool _internal_has_search_branching() const;
1250  public:
1251  void clear_search_branching();
1252  ::operations_research::sat::SatParameters_SearchBranching search_branching() const;
1253  void set_search_branching(::operations_research::sat::SatParameters_SearchBranching value);
1254  private:
1255  ::operations_research::sat::SatParameters_SearchBranching _internal_search_branching() const;
1256  void _internal_set_search_branching(::operations_research::sat::SatParameters_SearchBranching value);
1257  public:
1258 
1259  // optional bool optimize_with_core = 83 [default = false];
1260  bool has_optimize_with_core() const;
1261  private:
1262  bool _internal_has_optimize_with_core() const;
1263  public:
1264  void clear_optimize_with_core();
1265  bool optimize_with_core() const;
1266  void set_optimize_with_core(bool value);
1267  private:
1268  bool _internal_optimize_with_core() const;
1269  void _internal_set_optimize_with_core(bool value);
1270  public:
1271 
1272  // optional bool optimize_with_max_hs = 85 [default = false];
1273  bool has_optimize_with_max_hs() const;
1274  private:
1275  bool _internal_has_optimize_with_max_hs() const;
1276  public:
1277  void clear_optimize_with_max_hs();
1278  bool optimize_with_max_hs() const;
1279  void set_optimize_with_max_hs(bool value);
1280  private:
1281  bool _internal_optimize_with_max_hs() const;
1282  void _internal_set_optimize_with_max_hs(bool value);
1283  public:
1284 
1285  // optional bool enumerate_all_solutions = 87 [default = false];
1286  bool has_enumerate_all_solutions() const;
1287  private:
1288  bool _internal_has_enumerate_all_solutions() const;
1289  public:
1290  void clear_enumerate_all_solutions();
1291  bool enumerate_all_solutions() const;
1292  void set_enumerate_all_solutions(bool value);
1293  private:
1294  bool _internal_enumerate_all_solutions() const;
1295  void _internal_set_enumerate_all_solutions(bool value);
1296  public:
1297 
1298  // optional bool fill_tightened_domains_in_response = 132 [default = false];
1299  bool has_fill_tightened_domains_in_response() const;
1300  private:
1301  bool _internal_has_fill_tightened_domains_in_response() const;
1302  public:
1303  void clear_fill_tightened_domains_in_response();
1304  bool fill_tightened_domains_in_response() const;
1305  void set_fill_tightened_domains_in_response(bool value);
1306  private:
1307  bool _internal_fill_tightened_domains_in_response() const;
1308  void _internal_set_fill_tightened_domains_in_response(bool value);
1309  public:
1310 
1311  // optional bool use_pb_resolution = 43 [default = false];
1312  bool has_use_pb_resolution() const;
1313  private:
1314  bool _internal_has_use_pb_resolution() const;
1315  public:
1316  void clear_use_pb_resolution();
1317  bool use_pb_resolution() const;
1318  void set_use_pb_resolution(bool value);
1319  private:
1320  bool _internal_use_pb_resolution() const;
1321  void _internal_set_use_pb_resolution(bool value);
1322  public:
1323 
1324  // optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
1325  bool has_minimize_reduction_during_pb_resolution() const;
1326  private:
1327  bool _internal_has_minimize_reduction_during_pb_resolution() const;
1328  public:
1329  void clear_minimize_reduction_during_pb_resolution();
1330  bool minimize_reduction_during_pb_resolution() const;
1331  void set_minimize_reduction_during_pb_resolution(bool value);
1332  private:
1333  bool _internal_minimize_reduction_during_pb_resolution() const;
1334  void _internal_set_minimize_reduction_during_pb_resolution(bool value);
1335  public:
1336 
1337  // optional bool cp_model_postsolve_with_full_solver = 162 [default = false];
1338  bool has_cp_model_postsolve_with_full_solver() const;
1339  private:
1340  bool _internal_has_cp_model_postsolve_with_full_solver() const;
1341  public:
1342  void clear_cp_model_postsolve_with_full_solver();
1343  bool cp_model_postsolve_with_full_solver() const;
1344  void set_cp_model_postsolve_with_full_solver(bool value);
1345  private:
1346  bool _internal_cp_model_postsolve_with_full_solver() const;
1347  void _internal_set_cp_model_postsolve_with_full_solver(bool value);
1348  public:
1349 
1350  // optional bool use_sat_inprocessing = 163 [default = false];
1351  bool has_use_sat_inprocessing() const;
1352  private:
1353  bool _internal_has_use_sat_inprocessing() const;
1354  public:
1355  void clear_use_sat_inprocessing();
1356  bool use_sat_inprocessing() const;
1357  void set_use_sat_inprocessing(bool value);
1358  private:
1359  bool _internal_use_sat_inprocessing() const;
1360  void _internal_set_use_sat_inprocessing(bool value);
1361  public:
1362 
1363  // optional int64 search_randomization_tolerance = 104 [default = 0];
1364  bool has_search_randomization_tolerance() const;
1365  private:
1366  bool _internal_has_search_randomization_tolerance() const;
1367  public:
1368  void clear_search_randomization_tolerance();
1369  ::PROTOBUF_NAMESPACE_ID::int64 search_randomization_tolerance() const;
1370  void set_search_randomization_tolerance(::PROTOBUF_NAMESPACE_ID::int64 value);
1371  private:
1372  ::PROTOBUF_NAMESPACE_ID::int64 _internal_search_randomization_tolerance() const;
1373  void _internal_set_search_randomization_tolerance(::PROTOBUF_NAMESPACE_ID::int64 value);
1374  public:
1375 
1376  // optional bool use_lns_only = 101 [default = false];
1377  bool has_use_lns_only() const;
1378  private:
1379  bool _internal_has_use_lns_only() const;
1380  public:
1381  void clear_use_lns_only();
1382  bool use_lns_only() const;
1383  void set_use_lns_only(bool value);
1384  private:
1385  bool _internal_use_lns_only() const;
1386  void _internal_set_use_lns_only(bool value);
1387  public:
1388 
1389  // optional bool lns_focus_on_decision_variables = 105 [default = false];
1390  bool has_lns_focus_on_decision_variables() const;
1391  private:
1392  bool _internal_has_lns_focus_on_decision_variables() const;
1393  public:
1394  void clear_lns_focus_on_decision_variables();
1395  bool lns_focus_on_decision_variables() const;
1396  void set_lns_focus_on_decision_variables(bool value);
1397  private:
1398  bool _internal_lns_focus_on_decision_variables() const;
1399  void _internal_set_lns_focus_on_decision_variables(bool value);
1400  public:
1401 
1402  // optional bool use_relaxation_lns = 150 [default = false];
1403  bool has_use_relaxation_lns() const;
1404  private:
1405  bool _internal_has_use_relaxation_lns() const;
1406  public:
1407  void clear_use_relaxation_lns();
1408  bool use_relaxation_lns() const;
1409  void set_use_relaxation_lns(bool value);
1410  private:
1411  bool _internal_use_relaxation_lns() const;
1412  void _internal_set_use_relaxation_lns(bool value);
1413  public:
1414 
1415  // optional bool diversify_lns_params = 137 [default = false];
1416  bool has_diversify_lns_params() const;
1417  private:
1418  bool _internal_has_diversify_lns_params() const;
1419  public:
1420  void clear_diversify_lns_params();
1421  bool diversify_lns_params() const;
1422  void set_diversify_lns_params(bool value);
1423  private:
1424  bool _internal_diversify_lns_params() const;
1425  void _internal_set_diversify_lns_params(bool value);
1426  public:
1427 
1428  // optional bool randomize_search = 103 [default = false];
1429  bool has_randomize_search() const;
1430  private:
1431  bool _internal_has_randomize_search() const;
1432  public:
1433  void clear_randomize_search();
1434  bool randomize_search() const;
1435  void set_randomize_search(bool value);
1436  private:
1437  bool _internal_randomize_search() const;
1438  void _internal_set_randomize_search(bool value);
1439  public:
1440 
1441  // optional bool use_branching_in_lp = 139 [default = false];
1442  bool has_use_branching_in_lp() const;
1443  private:
1444  bool _internal_has_use_branching_in_lp() const;
1445  public:
1446  void clear_use_branching_in_lp();
1447  bool use_branching_in_lp() const;
1448  void set_use_branching_in_lp(bool value);
1449  private:
1450  bool _internal_use_branching_in_lp() const;
1451  void _internal_set_use_branching_in_lp(bool value);
1452  public:
1453 
1454  // optional bool use_combined_no_overlap = 133 [default = false];
1455  bool has_use_combined_no_overlap() const;
1456  private:
1457  bool _internal_has_use_combined_no_overlap() const;
1458  public:
1459  void clear_use_combined_no_overlap();
1460  bool use_combined_no_overlap() const;
1461  void set_use_combined_no_overlap(bool value);
1462  private:
1463  bool _internal_use_combined_no_overlap() const;
1464  void _internal_set_use_combined_no_overlap(bool value);
1465  public:
1466 
1467  // optional bool stop_after_first_solution = 98 [default = false];
1468  bool has_stop_after_first_solution() const;
1469  private:
1470  bool _internal_has_stop_after_first_solution() const;
1471  public:
1472  void clear_stop_after_first_solution();
1473  bool stop_after_first_solution() const;
1474  void set_stop_after_first_solution(bool value);
1475  private:
1476  bool _internal_stop_after_first_solution() const;
1477  void _internal_set_stop_after_first_solution(bool value);
1478  public:
1479 
1480  // optional bool stop_after_presolve = 149 [default = false];
1481  bool has_stop_after_presolve() const;
1482  private:
1483  bool _internal_has_stop_after_presolve() const;
1484  public:
1485  void clear_stop_after_presolve();
1486  bool stop_after_presolve() const;
1487  void set_stop_after_presolve(bool value);
1488  private:
1489  bool _internal_stop_after_presolve() const;
1490  void _internal_set_stop_after_presolve(bool value);
1491  public:
1492 
1493  // optional bool interleave_search = 136 [default = false];
1494  bool has_interleave_search() const;
1495  private:
1496  bool _internal_has_interleave_search() const;
1497  public:
1498  void clear_interleave_search();
1499  bool interleave_search() const;
1500  void set_interleave_search(bool value);
1501  private:
1502  bool _internal_interleave_search() const;
1503  void _internal_set_interleave_search(bool value);
1504  public:
1505 
1506  // optional bool reduce_memory_usage_in_interleave_mode = 141 [default = false];
1507  bool has_reduce_memory_usage_in_interleave_mode() const;
1508  private:
1509  bool _internal_has_reduce_memory_usage_in_interleave_mode() const;
1510  public:
1511  void clear_reduce_memory_usage_in_interleave_mode();
1512  bool reduce_memory_usage_in_interleave_mode() const;
1513  void set_reduce_memory_usage_in_interleave_mode(bool value);
1514  private:
1515  bool _internal_reduce_memory_usage_in_interleave_mode() const;
1516  void _internal_set_reduce_memory_usage_in_interleave_mode(bool value);
1517  public:
1518 
1519  // optional bool add_knapsack_cuts = 111 [default = false];
1520  bool has_add_knapsack_cuts() const;
1521  private:
1522  bool _internal_has_add_knapsack_cuts() const;
1523  public:
1524  void clear_add_knapsack_cuts();
1525  bool add_knapsack_cuts() const;
1526  void set_add_knapsack_cuts(bool value);
1527  private:
1528  bool _internal_add_knapsack_cuts() const;
1529  void _internal_set_add_knapsack_cuts(bool value);
1530  public:
1531 
1532  // optional bool repair_hint = 167 [default = false];
1533  bool has_repair_hint() const;
1534  private:
1535  bool _internal_has_repair_hint() const;
1536  public:
1537  void clear_repair_hint();
1538  bool repair_hint() const;
1539  void set_repair_hint(bool value);
1540  private:
1541  bool _internal_repair_hint() const;
1542  void _internal_set_repair_hint(bool value);
1543  public:
1544 
1545  // optional bool exploit_best_solution = 130 [default = false];
1546  bool has_exploit_best_solution() const;
1547  private:
1548  bool _internal_has_exploit_best_solution() const;
1549  public:
1550  void clear_exploit_best_solution();
1551  bool exploit_best_solution() const;
1552  void set_exploit_best_solution(bool value);
1553  private:
1554  bool _internal_exploit_best_solution() const;
1555  void _internal_set_exploit_best_solution(bool value);
1556  public:
1557 
1558  // optional bool exploit_relaxation_solution = 161 [default = false];
1559  bool has_exploit_relaxation_solution() const;
1560  private:
1561  bool _internal_has_exploit_relaxation_solution() const;
1562  public:
1563  void clear_exploit_relaxation_solution();
1564  bool exploit_relaxation_solution() const;
1565  void set_exploit_relaxation_solution(bool value);
1566  private:
1567  bool _internal_exploit_relaxation_solution() const;
1568  void _internal_set_exploit_relaxation_solution(bool value);
1569  public:
1570 
1571  // optional int64 probing_period_at_root = 142 [default = 0];
1572  bool has_probing_period_at_root() const;
1573  private:
1574  bool _internal_has_probing_period_at_root() const;
1575  public:
1576  void clear_probing_period_at_root();
1577  ::PROTOBUF_NAMESPACE_ID::int64 probing_period_at_root() const;
1578  void set_probing_period_at_root(::PROTOBUF_NAMESPACE_ID::int64 value);
1579  private:
1580  ::PROTOBUF_NAMESPACE_ID::int64 _internal_probing_period_at_root() const;
1581  void _internal_set_probing_period_at_root(::PROTOBUF_NAMESPACE_ID::int64 value);
1582  public:
1583 
1584  // optional int32 cp_model_max_num_presolve_operations = 151 [default = 0];
1585  bool has_cp_model_max_num_presolve_operations() const;
1586  private:
1587  bool _internal_has_cp_model_max_num_presolve_operations() const;
1588  public:
1589  void clear_cp_model_max_num_presolve_operations();
1590  ::PROTOBUF_NAMESPACE_ID::int32 cp_model_max_num_presolve_operations() const;
1591  void set_cp_model_max_num_presolve_operations(::PROTOBUF_NAMESPACE_ID::int32 value);
1592  private:
1593  ::PROTOBUF_NAMESPACE_ID::int32 _internal_cp_model_max_num_presolve_operations() const;
1594  void _internal_set_cp_model_max_num_presolve_operations(::PROTOBUF_NAMESPACE_ID::int32 value);
1595  public:
1596 
1597  // optional double absolute_gap_limit = 159 [default = 0];
1598  bool has_absolute_gap_limit() const;
1599  private:
1600  bool _internal_has_absolute_gap_limit() const;
1601  public:
1602  void clear_absolute_gap_limit();
1603  double absolute_gap_limit() const;
1604  void set_absolute_gap_limit(double value);
1605  private:
1606  double _internal_absolute_gap_limit() const;
1607  void _internal_set_absolute_gap_limit(double value);
1608  public:
1609 
1610  // optional double relative_gap_limit = 160 [default = 0];
1611  bool has_relative_gap_limit() const;
1612  private:
1613  bool _internal_has_relative_gap_limit() const;
1614  public:
1615  void clear_relative_gap_limit();
1616  double relative_gap_limit() const;
1617  void set_relative_gap_limit(double value);
1618  private:
1619  double _internal_relative_gap_limit() const;
1620  void _internal_set_relative_gap_limit(double value);
1621  public:
1622 
1623  // optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
1624  bool has_initial_polarity() const;
1625  private:
1626  bool _internal_has_initial_polarity() const;
1627  public:
1628  void clear_initial_polarity();
1629  ::operations_research::sat::SatParameters_Polarity initial_polarity() const;
1630  void set_initial_polarity(::operations_research::sat::SatParameters_Polarity value);
1631  private:
1632  ::operations_research::sat::SatParameters_Polarity _internal_initial_polarity() const;
1633  void _internal_set_initial_polarity(::operations_research::sat::SatParameters_Polarity value);
1634  public:
1635 
1636  // optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
1637  bool has_minimization_algorithm() const;
1638  private:
1639  bool _internal_has_minimization_algorithm() const;
1640  public:
1641  void clear_minimization_algorithm();
1642  ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm minimization_algorithm() const;
1643  void set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value);
1644  private:
1645  ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm _internal_minimization_algorithm() const;
1646  void _internal_set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value);
1647  public:
1648 
1649  // optional int32 clause_cleanup_period = 11 [default = 10000];
1650  bool has_clause_cleanup_period() const;
1651  private:
1652  bool _internal_has_clause_cleanup_period() const;
1653  public:
1654  void clear_clause_cleanup_period();
1655  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_period() const;
1656  void set_clause_cleanup_period(::PROTOBUF_NAMESPACE_ID::int32 value);
1657  private:
1658  ::PROTOBUF_NAMESPACE_ID::int32 _internal_clause_cleanup_period() const;
1659  void _internal_set_clause_cleanup_period(::PROTOBUF_NAMESPACE_ID::int32 value);
1660  public:
1661 
1662  // optional int32 clause_cleanup_target = 13 [default = 10000];
1663  bool has_clause_cleanup_target() const;
1664  private:
1665  bool _internal_has_clause_cleanup_target() const;
1666  public:
1667  void clear_clause_cleanup_target();
1668  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_target() const;
1669  void set_clause_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value);
1670  private:
1671  ::PROTOBUF_NAMESPACE_ID::int32 _internal_clause_cleanup_target() const;
1672  void _internal_set_clause_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value);
1673  public:
1674 
1675  // optional double variable_activity_decay = 15 [default = 0.8];
1676  bool has_variable_activity_decay() const;
1677  private:
1678  bool _internal_has_variable_activity_decay() const;
1679  public:
1680  void clear_variable_activity_decay();
1681  double variable_activity_decay() const;
1682  void set_variable_activity_decay(double value);
1683  private:
1684  double _internal_variable_activity_decay() const;
1685  void _internal_set_variable_activity_decay(double value);
1686  public:
1687 
1688  // optional double max_variable_activity_value = 16 [default = 1e+100];
1689  bool has_max_variable_activity_value() const;
1690  private:
1691  bool _internal_has_max_variable_activity_value() const;
1692  public:
1693  void clear_max_variable_activity_value();
1694  double max_variable_activity_value() const;
1695  void set_max_variable_activity_value(double value);
1696  private:
1697  double _internal_max_variable_activity_value() const;
1698  void _internal_set_max_variable_activity_value(double value);
1699  public:
1700 
1701  // optional double clause_activity_decay = 17 [default = 0.999];
1702  bool has_clause_activity_decay() const;
1703  private:
1704  bool _internal_has_clause_activity_decay() const;
1705  public:
1706  void clear_clause_activity_decay();
1707  double clause_activity_decay() const;
1708  void set_clause_activity_decay(double value);
1709  private:
1710  double _internal_clause_activity_decay() const;
1711  void _internal_set_clause_activity_decay(double value);
1712  public:
1713 
1714  // optional double max_clause_activity_value = 18 [default = 1e+20];
1715  bool has_max_clause_activity_value() const;
1716  private:
1717  bool _internal_has_max_clause_activity_value() const;
1718  public:
1719  void clear_max_clause_activity_value();
1720  double max_clause_activity_value() const;
1721  void set_max_clause_activity_value(double value);
1722  private:
1723  double _internal_max_clause_activity_value() const;
1724  void _internal_set_max_clause_activity_value(double value);
1725  public:
1726 
1727  // optional double glucose_max_decay = 22 [default = 0.95];
1728  bool has_glucose_max_decay() const;
1729  private:
1730  bool _internal_has_glucose_max_decay() const;
1731  public:
1732  void clear_glucose_max_decay();
1733  double glucose_max_decay() const;
1734  void set_glucose_max_decay(double value);
1735  private:
1736  double _internal_glucose_max_decay() const;
1737  void _internal_set_glucose_max_decay(double value);
1738  public:
1739 
1740  // optional double glucose_decay_increment = 23 [default = 0.01];
1741  bool has_glucose_decay_increment() const;
1742  private:
1743  bool _internal_has_glucose_decay_increment() const;
1744  public:
1745  void clear_glucose_decay_increment();
1746  double glucose_decay_increment() const;
1747  void set_glucose_decay_increment(double value);
1748  private:
1749  double _internal_glucose_decay_increment() const;
1750  void _internal_set_glucose_decay_increment(double value);
1751  public:
1752 
1753  // optional int32 glucose_decay_increment_period = 24 [default = 5000];
1754  bool has_glucose_decay_increment_period() const;
1755  private:
1756  bool _internal_has_glucose_decay_increment_period() const;
1757  public:
1758  void clear_glucose_decay_increment_period();
1759  ::PROTOBUF_NAMESPACE_ID::int32 glucose_decay_increment_period() const;
1760  void set_glucose_decay_increment_period(::PROTOBUF_NAMESPACE_ID::int32 value);
1761  private:
1762  ::PROTOBUF_NAMESPACE_ID::int32 _internal_glucose_decay_increment_period() const;
1763  void _internal_set_glucose_decay_increment_period(::PROTOBUF_NAMESPACE_ID::int32 value);
1764  public:
1765 
1766  // optional int32 restart_period = 30 [default = 50];
1767  bool has_restart_period() const;
1768  private:
1769  bool _internal_has_restart_period() const;
1770  public:
1771  void clear_restart_period();
1772  ::PROTOBUF_NAMESPACE_ID::int32 restart_period() const;
1773  void set_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value);
1774  private:
1775  ::PROTOBUF_NAMESPACE_ID::int32 _internal_restart_period() const;
1776  void _internal_set_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value);
1777  public:
1778 
1779  // optional int32 random_seed = 31 [default = 1];
1780  bool has_random_seed() const;
1781  private:
1782  bool _internal_has_random_seed() const;
1783  public:
1784  void clear_random_seed();
1785  ::PROTOBUF_NAMESPACE_ID::int32 random_seed() const;
1786  void set_random_seed(::PROTOBUF_NAMESPACE_ID::int32 value);
1787  private:
1788  ::PROTOBUF_NAMESPACE_ID::int32 _internal_random_seed() const;
1789  void _internal_set_random_seed(::PROTOBUF_NAMESPACE_ID::int32 value);
1790  public:
1791 
1792  // optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];
1793  bool has_binary_minimization_algorithm() const;
1794  private:
1795  bool _internal_has_binary_minimization_algorithm() const;
1796  public:
1797  void clear_binary_minimization_algorithm();
1798  ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm binary_minimization_algorithm() const;
1799  void set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value);
1800  private:
1801  ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm _internal_binary_minimization_algorithm() const;
1802  void _internal_set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value);
1803  public:
1804 
1805  // optional double max_time_in_seconds = 36 [default = inf];
1806  bool has_max_time_in_seconds() const;
1807  private:
1808  bool _internal_has_max_time_in_seconds() const;
1809  public:
1810  void clear_max_time_in_seconds();
1811  double max_time_in_seconds() const;
1812  void set_max_time_in_seconds(double value);
1813  private:
1814  double _internal_max_time_in_seconds() const;
1815  void _internal_set_max_time_in_seconds(double value);
1816  public:
1817 
1818  // optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
1819  bool has_max_number_of_conflicts() const;
1820  private:
1821  bool _internal_has_max_number_of_conflicts() const;
1822  public:
1823  void clear_max_number_of_conflicts();
1824  ::PROTOBUF_NAMESPACE_ID::int64 max_number_of_conflicts() const;
1825  void set_max_number_of_conflicts(::PROTOBUF_NAMESPACE_ID::int64 value);
1826  private:
1827  ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_number_of_conflicts() const;
1828  void _internal_set_max_number_of_conflicts(::PROTOBUF_NAMESPACE_ID::int64 value);
1829  public:
1830 
1831  // optional int64 max_memory_in_mb = 40 [default = 10000];
1832  bool has_max_memory_in_mb() const;
1833  private:
1834  bool _internal_has_max_memory_in_mb() const;
1835  public:
1836  void clear_max_memory_in_mb();
1837  ::PROTOBUF_NAMESPACE_ID::int64 max_memory_in_mb() const;
1838  void set_max_memory_in_mb(::PROTOBUF_NAMESPACE_ID::int64 value);
1839  private:
1840  ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_memory_in_mb() const;
1841  void _internal_set_max_memory_in_mb(::PROTOBUF_NAMESPACE_ID::int64 value);
1842  public:
1843 
1844  // optional bool use_phase_saving = 44 [default = true];
1845  bool has_use_phase_saving() const;
1846  private:
1847  bool _internal_has_use_phase_saving() const;
1848  public:
1849  void clear_use_phase_saving();
1850  bool use_phase_saving() const;
1851  void set_use_phase_saving(bool value);
1852  private:
1853  bool _internal_use_phase_saving() const;
1854  void _internal_set_use_phase_saving(bool value);
1855  public:
1856 
1857  // optional bool subsumption_during_conflict_analysis = 56 [default = true];
1858  bool has_subsumption_during_conflict_analysis() const;
1859  private:
1860  bool _internal_has_subsumption_during_conflict_analysis() const;
1861  public:
1862  void clear_subsumption_during_conflict_analysis();
1863  bool subsumption_during_conflict_analysis() const;
1864  void set_subsumption_during_conflict_analysis(bool value);
1865  private:
1866  bool _internal_subsumption_during_conflict_analysis() const;
1867  void _internal_set_subsumption_during_conflict_analysis(bool value);
1868  public:
1869 
1870  // optional bool treat_binary_clauses_separately = 33 [default = true];
1871  bool has_treat_binary_clauses_separately() const;
1872  private:
1873  bool _internal_has_treat_binary_clauses_separately() const;
1874  public:
1875  void clear_treat_binary_clauses_separately();
1876  bool treat_binary_clauses_separately() const;
1877  void set_treat_binary_clauses_separately(bool value);
1878  private:
1879  bool _internal_treat_binary_clauses_separately() const;
1880  void _internal_set_treat_binary_clauses_separately(bool value);
1881  public:
1882 
1883  // optional bool count_assumption_levels_in_lbd = 49 [default = true];
1884  bool has_count_assumption_levels_in_lbd() const;
1885  private:
1886  bool _internal_has_count_assumption_levels_in_lbd() const;
1887  public:
1888  void clear_count_assumption_levels_in_lbd();
1889  bool count_assumption_levels_in_lbd() const;
1890  void set_count_assumption_levels_in_lbd(bool value);
1891  private:
1892  bool _internal_count_assumption_levels_in_lbd() const;
1893  void _internal_set_count_assumption_levels_in_lbd(bool value);
1894  public:
1895 
1896  // optional int32 pb_cleanup_increment = 46 [default = 200];
1897  bool has_pb_cleanup_increment() const;
1898  private:
1899  bool _internal_has_pb_cleanup_increment() const;
1900  public:
1901  void clear_pb_cleanup_increment();
1902  ::PROTOBUF_NAMESPACE_ID::int32 pb_cleanup_increment() const;
1903  void set_pb_cleanup_increment(::PROTOBUF_NAMESPACE_ID::int32 value);
1904  private:
1905  ::PROTOBUF_NAMESPACE_ID::int32 _internal_pb_cleanup_increment() const;
1906  void _internal_set_pb_cleanup_increment(::PROTOBUF_NAMESPACE_ID::int32 value);
1907  public:
1908 
1909  // optional double pb_cleanup_ratio = 47 [default = 0.5];
1910  bool has_pb_cleanup_ratio() const;
1911  private:
1912  bool _internal_has_pb_cleanup_ratio() const;
1913  public:
1914  void clear_pb_cleanup_ratio();
1915  double pb_cleanup_ratio() const;
1916  void set_pb_cleanup_ratio(double value);
1917  private:
1918  double _internal_pb_cleanup_ratio() const;
1919  void _internal_set_pb_cleanup_ratio(double value);
1920  public:
1921 
1922  // optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
1923  bool has_max_sat_stratification() const;
1924  private:
1925  bool _internal_has_max_sat_stratification() const;
1926  public:
1927  void clear_max_sat_stratification();
1928  ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm max_sat_stratification() const;
1929  void set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value);
1930  private:
1931  ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm _internal_max_sat_stratification() const;
1932  void _internal_set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value);
1933  public:
1934 
1935  // optional int32 presolve_bve_threshold = 54 [default = 500];
1936  bool has_presolve_bve_threshold() const;
1937  private:
1938  bool _internal_has_presolve_bve_threshold() const;
1939  public:
1940  void clear_presolve_bve_threshold();
1941  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_threshold() const;
1942  void set_presolve_bve_threshold(::PROTOBUF_NAMESPACE_ID::int32 value);
1943  private:
1944  ::PROTOBUF_NAMESPACE_ID::int32 _internal_presolve_bve_threshold() const;
1945  void _internal_set_presolve_bve_threshold(::PROTOBUF_NAMESPACE_ID::int32 value);
1946  public:
1947 
1948  // optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
1949  bool has_presolve_probing_deterministic_time_limit() const;
1950  private:
1951  bool _internal_has_presolve_probing_deterministic_time_limit() const;
1952  public:
1953  void clear_presolve_probing_deterministic_time_limit();
1954  double presolve_probing_deterministic_time_limit() const;
1955  void set_presolve_probing_deterministic_time_limit(double value);
1956  private:
1957  double _internal_presolve_probing_deterministic_time_limit() const;
1958  void _internal_set_presolve_probing_deterministic_time_limit(double value);
1959  public:
1960 
1961  // optional int32 presolve_bve_clause_weight = 55 [default = 3];
1962  bool has_presolve_bve_clause_weight() const;
1963  private:
1964  bool _internal_has_presolve_bve_clause_weight() const;
1965  public:
1966  void clear_presolve_bve_clause_weight();
1967  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_clause_weight() const;
1968  void set_presolve_bve_clause_weight(::PROTOBUF_NAMESPACE_ID::int32 value);
1969  private:
1970  ::PROTOBUF_NAMESPACE_ID::int32 _internal_presolve_bve_clause_weight() const;
1971  void _internal_set_presolve_bve_clause_weight(::PROTOBUF_NAMESPACE_ID::int32 value);
1972  public:
1973 
1974  // optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
1975  bool has_clause_cleanup_lbd_bound() const;
1976  private:
1977  bool _internal_has_clause_cleanup_lbd_bound() const;
1978  public:
1979  void clear_clause_cleanup_lbd_bound();
1980  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_lbd_bound() const;
1981  void set_clause_cleanup_lbd_bound(::PROTOBUF_NAMESPACE_ID::int32 value);
1982  private:
1983  ::PROTOBUF_NAMESPACE_ID::int32 _internal_clause_cleanup_lbd_bound() const;
1984  void _internal_set_clause_cleanup_lbd_bound(::PROTOBUF_NAMESPACE_ID::int32 value);
1985  public:
1986 
1987  // optional double restart_dl_average_ratio = 63 [default = 1];
1988  bool has_restart_dl_average_ratio() const;
1989  private:
1990  bool _internal_has_restart_dl_average_ratio() const;
1991  public:
1992  void clear_restart_dl_average_ratio();
1993  double restart_dl_average_ratio() const;
1994  void set_restart_dl_average_ratio(double value);
1995  private:
1996  double _internal_restart_dl_average_ratio() const;
1997  void _internal_set_restart_dl_average_ratio(double value);
1998  public:
1999 
2000  // optional int32 restart_running_window_size = 62 [default = 50];
2001  bool has_restart_running_window_size() const;
2002  private:
2003  bool _internal_has_restart_running_window_size() const;
2004  public:
2005  void clear_restart_running_window_size();
2006  ::PROTOBUF_NAMESPACE_ID::int32 restart_running_window_size() const;
2007  void set_restart_running_window_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2008  private:
2009  ::PROTOBUF_NAMESPACE_ID::int32 _internal_restart_running_window_size() const;
2010  void _internal_set_restart_running_window_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2011  public:
2012 
2013  // optional int32 blocking_restart_window_size = 65 [default = 5000];
2014  bool has_blocking_restart_window_size() const;
2015  private:
2016  bool _internal_has_blocking_restart_window_size() const;
2017  public:
2018  void clear_blocking_restart_window_size();
2019  ::PROTOBUF_NAMESPACE_ID::int32 blocking_restart_window_size() const;
2020  void set_blocking_restart_window_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2021  private:
2022  ::PROTOBUF_NAMESPACE_ID::int32 _internal_blocking_restart_window_size() const;
2023  void _internal_set_blocking_restart_window_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2024  public:
2025 
2026  // optional double blocking_restart_multiplier = 66 [default = 1.4];
2027  bool has_blocking_restart_multiplier() const;
2028  private:
2029  bool _internal_has_blocking_restart_multiplier() const;
2030  public:
2031  void clear_blocking_restart_multiplier();
2032  double blocking_restart_multiplier() const;
2033  void set_blocking_restart_multiplier(double value);
2034  private:
2035  double _internal_blocking_restart_multiplier() const;
2036  void _internal_set_blocking_restart_multiplier(double value);
2037  public:
2038 
2039  // optional double max_deterministic_time = 67 [default = inf];
2040  bool has_max_deterministic_time() const;
2041  private:
2042  bool _internal_has_max_deterministic_time() const;
2043  public:
2044  void clear_max_deterministic_time();
2045  double max_deterministic_time() const;
2046  void set_max_deterministic_time(double value);
2047  private:
2048  double _internal_max_deterministic_time() const;
2049  void _internal_set_max_deterministic_time(double value);
2050  public:
2051 
2052  // optional double restart_lbd_average_ratio = 71 [default = 1];
2053  bool has_restart_lbd_average_ratio() const;
2054  private:
2055  bool _internal_has_restart_lbd_average_ratio() const;
2056  public:
2057  void clear_restart_lbd_average_ratio();
2058  double restart_lbd_average_ratio() const;
2059  void set_restart_lbd_average_ratio(double value);
2060  private:
2061  double _internal_restart_lbd_average_ratio() const;
2062  void _internal_set_restart_lbd_average_ratio(double value);
2063  public:
2064 
2065  // optional int32 presolve_bva_threshold = 73 [default = 1];
2066  bool has_presolve_bva_threshold() const;
2067  private:
2068  bool _internal_has_presolve_bva_threshold() const;
2069  public:
2070  void clear_presolve_bva_threshold();
2071  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bva_threshold() const;
2072  void set_presolve_bva_threshold(::PROTOBUF_NAMESPACE_ID::int32 value);
2073  private:
2074  ::PROTOBUF_NAMESPACE_ID::int32 _internal_presolve_bva_threshold() const;
2075  void _internal_set_presolve_bva_threshold(::PROTOBUF_NAMESPACE_ID::int32 value);
2076  public:
2077 
2078  // optional bool minimize_core = 50 [default = true];
2079  bool has_minimize_core() const;
2080  private:
2081  bool _internal_has_minimize_core() const;
2082  public:
2083  void clear_minimize_core();
2084  bool minimize_core() const;
2085  void set_minimize_core(bool value);
2086  private:
2087  bool _internal_minimize_core() const;
2088  void _internal_set_minimize_core(bool value);
2089  public:
2090 
2091  // optional bool find_multiple_cores = 84 [default = true];
2092  bool has_find_multiple_cores() const;
2093  private:
2094  bool _internal_has_find_multiple_cores() const;
2095  public:
2096  void clear_find_multiple_cores();
2097  bool find_multiple_cores() const;
2098  void set_find_multiple_cores(bool value);
2099  private:
2100  bool _internal_find_multiple_cores() const;
2101  void _internal_set_find_multiple_cores(bool value);
2102  public:
2103 
2104  // optional bool cover_optimization = 89 [default = true];
2105  bool has_cover_optimization() const;
2106  private:
2107  bool _internal_has_cover_optimization() const;
2108  public:
2109  void clear_cover_optimization();
2110  bool cover_optimization() const;
2111  void set_cover_optimization(bool value);
2112  private:
2113  bool _internal_cover_optimization() const;
2114  void _internal_set_cover_optimization(bool value);
2115  public:
2116 
2117  // optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
2118  bool has_use_precedences_in_disjunctive_constraint() const;
2119  private:
2120  bool _internal_has_use_precedences_in_disjunctive_constraint() const;
2121  public:
2122  void clear_use_precedences_in_disjunctive_constraint();
2123  bool use_precedences_in_disjunctive_constraint() const;
2124  void set_use_precedences_in_disjunctive_constraint(bool value);
2125  private:
2126  bool _internal_use_precedences_in_disjunctive_constraint() const;
2127  void _internal_set_use_precedences_in_disjunctive_constraint(bool value);
2128  public:
2129 
2130  // optional bool presolve_blocked_clause = 88 [default = true];
2131  bool has_presolve_blocked_clause() const;
2132  private:
2133  bool _internal_has_presolve_blocked_clause() const;
2134  public:
2135  void clear_presolve_blocked_clause();
2136  bool presolve_blocked_clause() const;
2137  void set_presolve_blocked_clause(bool value);
2138  private:
2139  bool _internal_presolve_blocked_clause() const;
2140  void _internal_set_presolve_blocked_clause(bool value);
2141  public:
2142 
2143  // optional bool presolve_use_bva = 72 [default = true];
2144  bool has_presolve_use_bva() const;
2145  private:
2146  bool _internal_has_presolve_use_bva() const;
2147  public:
2148  void clear_presolve_use_bva();
2149  bool presolve_use_bva() const;
2150  void set_presolve_use_bva(bool value);
2151  private:
2152  bool _internal_presolve_use_bva() const;
2153  void _internal_set_presolve_use_bva(bool value);
2154  public:
2155 
2156  // optional bool cp_model_presolve = 86 [default = true];
2157  bool has_cp_model_presolve() const;
2158  private:
2159  bool _internal_has_cp_model_presolve() const;
2160  public:
2161  void clear_cp_model_presolve();
2162  bool cp_model_presolve() const;
2163  void set_cp_model_presolve(bool value);
2164  private:
2165  bool _internal_cp_model_presolve() const;
2166  void _internal_set_cp_model_presolve(bool value);
2167  public:
2168 
2169  // optional bool cp_model_use_sat_presolve = 93 [default = true];
2170  bool has_cp_model_use_sat_presolve() const;
2171  private:
2172  bool _internal_has_cp_model_use_sat_presolve() const;
2173  public:
2174  void clear_cp_model_use_sat_presolve();
2175  bool cp_model_use_sat_presolve() const;
2176  void set_cp_model_use_sat_presolve(bool value);
2177  private:
2178  bool _internal_cp_model_use_sat_presolve() const;
2179  void _internal_set_cp_model_use_sat_presolve(bool value);
2180  public:
2181 
2182  // optional int32 linearization_level = 90 [default = 1];
2183  bool has_linearization_level() const;
2184  private:
2185  bool _internal_has_linearization_level() const;
2186  public:
2187  void clear_linearization_level();
2188  ::PROTOBUF_NAMESPACE_ID::int32 linearization_level() const;
2189  void set_linearization_level(::PROTOBUF_NAMESPACE_ID::int32 value);
2190  private:
2191  ::PROTOBUF_NAMESPACE_ID::int32 _internal_linearization_level() const;
2192  void _internal_set_linearization_level(::PROTOBUF_NAMESPACE_ID::int32 value);
2193  public:
2194 
2195  // optional int32 max_num_cuts = 91 [default = 10000];
2196  bool has_max_num_cuts() const;
2197  private:
2198  bool _internal_has_max_num_cuts() const;
2199  public:
2200  void clear_max_num_cuts();
2201  ::PROTOBUF_NAMESPACE_ID::int32 max_num_cuts() const;
2202  void set_max_num_cuts(::PROTOBUF_NAMESPACE_ID::int32 value);
2203  private:
2204  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_num_cuts() const;
2205  void _internal_set_max_num_cuts(::PROTOBUF_NAMESPACE_ID::int32 value);
2206  public:
2207 
2208  // optional int32 minimize_with_propagation_restart_period = 96 [default = 10];
2209  bool has_minimize_with_propagation_restart_period() const;
2210  private:
2211  bool _internal_has_minimize_with_propagation_restart_period() const;
2212  public:
2213  void clear_minimize_with_propagation_restart_period();
2214  ::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_restart_period() const;
2215  void set_minimize_with_propagation_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value);
2216  private:
2217  ::PROTOBUF_NAMESPACE_ID::int32 _internal_minimize_with_propagation_restart_period() const;
2218  void _internal_set_minimize_with_propagation_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value);
2219  public:
2220 
2221  // optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];
2222  bool has_minimize_with_propagation_num_decisions() const;
2223  private:
2224  bool _internal_has_minimize_with_propagation_num_decisions() const;
2225  public:
2226  void clear_minimize_with_propagation_num_decisions();
2227  ::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_num_decisions() const;
2228  void set_minimize_with_propagation_num_decisions(::PROTOBUF_NAMESPACE_ID::int32 value);
2229  private:
2230  ::PROTOBUF_NAMESPACE_ID::int32 _internal_minimize_with_propagation_num_decisions() const;
2231  void _internal_set_minimize_with_propagation_num_decisions(::PROTOBUF_NAMESPACE_ID::int32 value);
2232  public:
2233 
2234  // optional int32 binary_search_num_conflicts = 99 [default = -1];
2235  bool has_binary_search_num_conflicts() const;
2236  private:
2237  bool _internal_has_binary_search_num_conflicts() const;
2238  public:
2239  void clear_binary_search_num_conflicts();
2240  ::PROTOBUF_NAMESPACE_ID::int32 binary_search_num_conflicts() const;
2241  void set_binary_search_num_conflicts(::PROTOBUF_NAMESPACE_ID::int32 value);
2242  private:
2243  ::PROTOBUF_NAMESPACE_ID::int32 _internal_binary_search_num_conflicts() const;
2244  void _internal_set_binary_search_num_conflicts(::PROTOBUF_NAMESPACE_ID::int32 value);
2245  public:
2246 
2247  // optional int32 num_search_workers = 100 [default = 1];
2248  bool has_num_search_workers() const;
2249  private:
2250  bool _internal_has_num_search_workers() const;
2251  public:
2252  void clear_num_search_workers();
2253  ::PROTOBUF_NAMESPACE_ID::int32 num_search_workers() const;
2254  void set_num_search_workers(::PROTOBUF_NAMESPACE_ID::int32 value);
2255  private:
2256  ::PROTOBUF_NAMESPACE_ID::int32 _internal_num_search_workers() const;
2257  void _internal_set_num_search_workers(::PROTOBUF_NAMESPACE_ID::int32 value);
2258  public:
2259 
2260  // optional int32 boolean_encoding_level = 107 [default = 1];
2261  bool has_boolean_encoding_level() const;
2262  private:
2263  bool _internal_has_boolean_encoding_level() const;
2264  public:
2265  void clear_boolean_encoding_level();
2266  ::PROTOBUF_NAMESPACE_ID::int32 boolean_encoding_level() const;
2267  void set_boolean_encoding_level(::PROTOBUF_NAMESPACE_ID::int32 value);
2268  private:
2269  ::PROTOBUF_NAMESPACE_ID::int32 _internal_boolean_encoding_level() const;
2270  void _internal_set_boolean_encoding_level(::PROTOBUF_NAMESPACE_ID::int32 value);
2271  public:
2272 
2273  // optional bool instantiate_all_variables = 106 [default = true];
2274  bool has_instantiate_all_variables() const;
2275  private:
2276  bool _internal_has_instantiate_all_variables() const;
2277  public:
2278  void clear_instantiate_all_variables();
2279  bool instantiate_all_variables() const;
2280  void set_instantiate_all_variables(bool value);
2281  private:
2282  bool _internal_instantiate_all_variables() const;
2283  void _internal_set_instantiate_all_variables(bool value);
2284  public:
2285 
2286  // optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
2287  bool has_auto_detect_greater_than_at_least_one_of() const;
2288  private:
2289  bool _internal_has_auto_detect_greater_than_at_least_one_of() const;
2290  public:
2291  void clear_auto_detect_greater_than_at_least_one_of();
2292  bool auto_detect_greater_than_at_least_one_of() const;
2293  void set_auto_detect_greater_than_at_least_one_of(bool value);
2294  private:
2295  bool _internal_auto_detect_greater_than_at_least_one_of() const;
2296  void _internal_set_auto_detect_greater_than_at_least_one_of(bool value);
2297  public:
2298 
2299  // optional bool share_objective_bounds = 113 [default = true];
2300  bool has_share_objective_bounds() const;
2301  private:
2302  bool _internal_has_share_objective_bounds() const;
2303  public:
2304  void clear_share_objective_bounds();
2305  bool share_objective_bounds() const;
2306  void set_share_objective_bounds(bool value);
2307  private:
2308  bool _internal_share_objective_bounds() const;
2309  void _internal_set_share_objective_bounds(bool value);
2310  public:
2311 
2312  // optional bool share_level_zero_bounds = 114 [default = true];
2313  bool has_share_level_zero_bounds() const;
2314  private:
2315  bool _internal_has_share_level_zero_bounds() const;
2316  public:
2317  void clear_share_level_zero_bounds();
2318  bool share_level_zero_bounds() const;
2319  void set_share_level_zero_bounds(bool value);
2320  private:
2321  bool _internal_share_level_zero_bounds() const;
2322  void _internal_set_share_level_zero_bounds(bool value);
2323  public:
2324 
2325  // optional int32 cp_model_probing_level = 110 [default = 2];
2326  bool has_cp_model_probing_level() const;
2327  private:
2328  bool _internal_has_cp_model_probing_level() const;
2329  public:
2330  void clear_cp_model_probing_level();
2331  ::PROTOBUF_NAMESPACE_ID::int32 cp_model_probing_level() const;
2332  void set_cp_model_probing_level(::PROTOBUF_NAMESPACE_ID::int32 value);
2333  private:
2334  ::PROTOBUF_NAMESPACE_ID::int32 _internal_cp_model_probing_level() const;
2335  void _internal_set_cp_model_probing_level(::PROTOBUF_NAMESPACE_ID::int32 value);
2336  public:
2337 
2338  // optional double min_orthogonality_for_lp_constraints = 115 [default = 0.05];
2339  bool has_min_orthogonality_for_lp_constraints() const;
2340  private:
2341  bool _internal_has_min_orthogonality_for_lp_constraints() const;
2342  public:
2343  void clear_min_orthogonality_for_lp_constraints();
2344  double min_orthogonality_for_lp_constraints() const;
2345  void set_min_orthogonality_for_lp_constraints(double value);
2346  private:
2347  double _internal_min_orthogonality_for_lp_constraints() const;
2348  void _internal_set_min_orthogonality_for_lp_constraints(double value);
2349  public:
2350 
2351  // optional bool add_lp_constraints_lazily = 112 [default = true];
2352  bool has_add_lp_constraints_lazily() const;
2353  private:
2354  bool _internal_has_add_lp_constraints_lazily() const;
2355  public:
2356  void clear_add_lp_constraints_lazily();
2357  bool add_lp_constraints_lazily() const;
2358  void set_add_lp_constraints_lazily(bool value);
2359  private:
2360  bool _internal_add_lp_constraints_lazily() const;
2361  void _internal_set_add_lp_constraints_lazily(bool value);
2362  public:
2363 
2364  // optional bool exploit_integer_lp_solution = 94 [default = true];
2365  bool has_exploit_integer_lp_solution() const;
2366  private:
2367  bool _internal_has_exploit_integer_lp_solution() const;
2368  public:
2369  void clear_exploit_integer_lp_solution();
2370  bool exploit_integer_lp_solution() const;
2371  void set_exploit_integer_lp_solution(bool value);
2372  private:
2373  bool _internal_exploit_integer_lp_solution() const;
2374  void _internal_set_exploit_integer_lp_solution(bool value);
2375  public:
2376 
2377  // optional bool exploit_all_lp_solution = 116 [default = true];
2378  bool has_exploit_all_lp_solution() const;
2379  private:
2380  bool _internal_has_exploit_all_lp_solution() const;
2381  public:
2382  void clear_exploit_all_lp_solution();
2383  bool exploit_all_lp_solution() const;
2384  void set_exploit_all_lp_solution(bool value);
2385  private:
2386  bool _internal_exploit_all_lp_solution() const;
2387  void _internal_set_exploit_all_lp_solution(bool value);
2388  public:
2389 
2390  // optional bool exploit_objective = 131 [default = true];
2391  bool has_exploit_objective() const;
2392  private:
2393  bool _internal_has_exploit_objective() const;
2394  public:
2395  void clear_exploit_objective();
2396  bool exploit_objective() const;
2397  void set_exploit_objective(bool value);
2398  private:
2399  bool _internal_exploit_objective() const;
2400  void _internal_set_exploit_objective(bool value);
2401  public:
2402 
2403  // optional bool use_disjunctive_constraint_in_cumulative_constraint = 80 [default = true];
2404  bool has_use_disjunctive_constraint_in_cumulative_constraint() const;
2405  private:
2406  bool _internal_has_use_disjunctive_constraint_in_cumulative_constraint() const;
2407  public:
2408  void clear_use_disjunctive_constraint_in_cumulative_constraint();
2409  bool use_disjunctive_constraint_in_cumulative_constraint() const;
2410  void set_use_disjunctive_constraint_in_cumulative_constraint(bool value);
2411  private:
2412  bool _internal_use_disjunctive_constraint_in_cumulative_constraint() const;
2413  void _internal_set_use_disjunctive_constraint_in_cumulative_constraint(bool value);
2414  public:
2415 
2416  // optional bool add_cg_cuts = 117 [default = true];
2417  bool has_add_cg_cuts() const;
2418  private:
2419  bool _internal_has_add_cg_cuts() const;
2420  public:
2421  void clear_add_cg_cuts();
2422  bool add_cg_cuts() const;
2423  void set_add_cg_cuts(bool value);
2424  private:
2425  bool _internal_add_cg_cuts() const;
2426  void _internal_set_add_cg_cuts(bool value);
2427  public:
2428 
2429  // optional bool add_mir_cuts = 120 [default = true];
2430  bool has_add_mir_cuts() const;
2431  private:
2432  bool _internal_has_add_mir_cuts() const;
2433  public:
2434  void clear_add_mir_cuts();
2435  bool add_mir_cuts() const;
2436  void set_add_mir_cuts(bool value);
2437  private:
2438  bool _internal_add_mir_cuts() const;
2439  void _internal_set_add_mir_cuts(bool value);
2440  public:
2441 
2442  // optional bool add_lin_max_cuts = 152 [default = true];
2443  bool has_add_lin_max_cuts() const;
2444  private:
2445  bool _internal_has_add_lin_max_cuts() const;
2446  public:
2447  void clear_add_lin_max_cuts();
2448  bool add_lin_max_cuts() const;
2449  void set_add_lin_max_cuts(bool value);
2450  private:
2451  bool _internal_add_lin_max_cuts() const;
2452  void _internal_set_add_lin_max_cuts(bool value);
2453  public:
2454 
2455  // optional int32 max_integer_rounding_scaling = 119 [default = 600];
2456  bool has_max_integer_rounding_scaling() const;
2457  private:
2458  bool _internal_has_max_integer_rounding_scaling() const;
2459  public:
2460  void clear_max_integer_rounding_scaling();
2461  ::PROTOBUF_NAMESPACE_ID::int32 max_integer_rounding_scaling() const;
2462  void set_max_integer_rounding_scaling(::PROTOBUF_NAMESPACE_ID::int32 value);
2463  private:
2464  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_integer_rounding_scaling() const;
2465  void _internal_set_max_integer_rounding_scaling(::PROTOBUF_NAMESPACE_ID::int32 value);
2466  public:
2467 
2468  // optional bool expand_element_constraints = 140 [default = true];
2469  bool has_expand_element_constraints() const;
2470  private:
2471  bool _internal_has_expand_element_constraints() const;
2472  public:
2473  void clear_expand_element_constraints();
2474  bool expand_element_constraints() const;
2475  void set_expand_element_constraints(bool value);
2476  private:
2477  bool _internal_expand_element_constraints() const;
2478  void _internal_set_expand_element_constraints(bool value);
2479  public:
2480 
2481  // optional bool expand_automaton_constraints = 143 [default = true];
2482  bool has_expand_automaton_constraints() const;
2483  private:
2484  bool _internal_has_expand_automaton_constraints() const;
2485  public:
2486  void clear_expand_automaton_constraints();
2487  bool expand_automaton_constraints() const;
2488  void set_expand_automaton_constraints(bool value);
2489  private:
2490  bool _internal_expand_automaton_constraints() const;
2491  void _internal_set_expand_automaton_constraints(bool value);
2492  public:
2493 
2494  // optional bool expand_table_constraints = 158 [default = true];
2495  bool has_expand_table_constraints() const;
2496  private:
2497  bool _internal_has_expand_table_constraints() const;
2498  public:
2499  void clear_expand_table_constraints();
2500  bool expand_table_constraints() const;
2501  void set_expand_table_constraints(bool value);
2502  private:
2503  bool _internal_expand_table_constraints() const;
2504  void _internal_set_expand_table_constraints(bool value);
2505  public:
2506 
2507  // optional bool use_optimization_hints = 35 [default = true];
2508  bool has_use_optimization_hints() const;
2509  private:
2510  bool _internal_has_use_optimization_hints() const;
2511  public:
2512  void clear_use_optimization_hints();
2513  bool use_optimization_hints() const;
2514  void set_use_optimization_hints(bool value);
2515  private:
2516  bool _internal_use_optimization_hints() const;
2517  void _internal_set_use_optimization_hints(bool value);
2518  public:
2519 
2520  // optional int32 max_consecutive_inactive_count = 121 [default = 100];
2521  bool has_max_consecutive_inactive_count() const;
2522  private:
2523  bool _internal_has_max_consecutive_inactive_count() const;
2524  public:
2525  void clear_max_consecutive_inactive_count();
2526  ::PROTOBUF_NAMESPACE_ID::int32 max_consecutive_inactive_count() const;
2527  void set_max_consecutive_inactive_count(::PROTOBUF_NAMESPACE_ID::int32 value);
2528  private:
2529  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_consecutive_inactive_count() const;
2530  void _internal_set_max_consecutive_inactive_count(::PROTOBUF_NAMESPACE_ID::int32 value);
2531  public:
2532 
2533  // optional int32 new_constraints_batch_size = 122 [default = 50];
2534  bool has_new_constraints_batch_size() const;
2535  private:
2536  bool _internal_has_new_constraints_batch_size() const;
2537  public:
2538  void clear_new_constraints_batch_size();
2539  ::PROTOBUF_NAMESPACE_ID::int32 new_constraints_batch_size() const;
2540  void set_new_constraints_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2541  private:
2542  ::PROTOBUF_NAMESPACE_ID::int32 _internal_new_constraints_batch_size() const;
2543  void _internal_set_new_constraints_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2544  public:
2545 
2546  // optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
2547  bool has_pseudo_cost_reliability_threshold() const;
2548  private:
2549  bool _internal_has_pseudo_cost_reliability_threshold() const;
2550  public:
2551  void clear_pseudo_cost_reliability_threshold();
2552  ::PROTOBUF_NAMESPACE_ID::int64 pseudo_cost_reliability_threshold() const;
2553  void set_pseudo_cost_reliability_threshold(::PROTOBUF_NAMESPACE_ID::int64 value);
2554  private:
2555  ::PROTOBUF_NAMESPACE_ID::int64 _internal_pseudo_cost_reliability_threshold() const;
2556  void _internal_set_pseudo_cost_reliability_threshold(::PROTOBUF_NAMESPACE_ID::int64 value);
2557  public:
2558 
2559  // optional double mip_max_bound = 124 [default = 10000000];
2560  bool has_mip_max_bound() const;
2561  private:
2562  bool _internal_has_mip_max_bound() const;
2563  public:
2564  void clear_mip_max_bound();
2565  double mip_max_bound() const;
2566  void set_mip_max_bound(double value);
2567  private:
2568  double _internal_mip_max_bound() const;
2569  void _internal_set_mip_max_bound(double value);
2570  public:
2571 
2572  // optional double mip_var_scaling = 125 [default = 1];
2573  bool has_mip_var_scaling() const;
2574  private:
2575  bool _internal_has_mip_var_scaling() const;
2576  public:
2577  void clear_mip_var_scaling();
2578  double mip_var_scaling() const;
2579  void set_mip_var_scaling(double value);
2580  private:
2581  double _internal_mip_var_scaling() const;
2582  void _internal_set_mip_var_scaling(double value);
2583  public:
2584 
2585  // optional double mip_wanted_precision = 126 [default = 1e-06];
2586  bool has_mip_wanted_precision() const;
2587  private:
2588  bool _internal_has_mip_wanted_precision() const;
2589  public:
2590  void clear_mip_wanted_precision();
2591  double mip_wanted_precision() const;
2592  void set_mip_wanted_precision(double value);
2593  private:
2594  double _internal_mip_wanted_precision() const;
2595  void _internal_set_mip_wanted_precision(double value);
2596  public:
2597 
2598  // optional int32 mip_max_activity_exponent = 127 [default = 53];
2599  bool has_mip_max_activity_exponent() const;
2600  private:
2601  bool _internal_has_mip_max_activity_exponent() const;
2602  public:
2603  void clear_mip_max_activity_exponent();
2604  ::PROTOBUF_NAMESPACE_ID::int32 mip_max_activity_exponent() const;
2605  void set_mip_max_activity_exponent(::PROTOBUF_NAMESPACE_ID::int32 value);
2606  private:
2607  ::PROTOBUF_NAMESPACE_ID::int32 _internal_mip_max_activity_exponent() const;
2608  void _internal_set_mip_max_activity_exponent(::PROTOBUF_NAMESPACE_ID::int32 value);
2609  public:
2610 
2611  // optional bool use_rins_lns = 129 [default = true];
2612  bool has_use_rins_lns() const;
2613  private:
2614  bool _internal_has_use_rins_lns() const;
2615  public:
2616  void clear_use_rins_lns();
2617  bool use_rins_lns() const;
2618  void set_use_rins_lns(bool value);
2619  private:
2620  bool _internal_use_rins_lns() const;
2621  void _internal_set_use_rins_lns(bool value);
2622  public:
2623 
2624  // optional bool use_feasibility_pump = 164 [default = true];
2625  bool has_use_feasibility_pump() const;
2626  private:
2627  bool _internal_has_use_feasibility_pump() const;
2628  public:
2629  void clear_use_feasibility_pump();
2630  bool use_feasibility_pump() const;
2631  void set_use_feasibility_pump(bool value);
2632  private:
2633  bool _internal_use_feasibility_pump() const;
2634  void _internal_set_use_feasibility_pump(bool value);
2635  public:
2636 
2637  // optional bool use_optional_variables = 108 [default = true];
2638  bool has_use_optional_variables() const;
2639  private:
2640  bool _internal_has_use_optional_variables() const;
2641  public:
2642  void clear_use_optional_variables();
2643  bool use_optional_variables() const;
2644  void set_use_optional_variables(bool value);
2645  private:
2646  bool _internal_use_optional_variables() const;
2647  void _internal_set_use_optional_variables(bool value);
2648  public:
2649 
2650  // optional bool use_exact_lp_reason = 109 [default = true];
2651  bool has_use_exact_lp_reason() const;
2652  private:
2653  bool _internal_has_use_exact_lp_reason() const;
2654  public:
2655  void clear_use_exact_lp_reason();
2656  bool use_exact_lp_reason() const;
2657  void set_use_exact_lp_reason(bool value);
2658  private:
2659  bool _internal_use_exact_lp_reason() const;
2660  void _internal_set_use_exact_lp_reason(bool value);
2661  public:
2662 
2663  // optional double mip_check_precision = 128 [default = 0.0001];
2664  bool has_mip_check_precision() const;
2665  private:
2666  bool _internal_has_mip_check_precision() const;
2667  public:
2668  void clear_mip_check_precision();
2669  double mip_check_precision() const;
2670  void set_mip_check_precision(double value);
2671  private:
2672  double _internal_mip_check_precision() const;
2673  void _internal_set_mip_check_precision(double value);
2674  public:
2675 
2676  // optional int32 interleave_batch_size = 134 [default = 1];
2677  bool has_interleave_batch_size() const;
2678  private:
2679  bool _internal_has_interleave_batch_size() const;
2680  public:
2681  void clear_interleave_batch_size();
2682  ::PROTOBUF_NAMESPACE_ID::int32 interleave_batch_size() const;
2683  void set_interleave_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2684  private:
2685  ::PROTOBUF_NAMESPACE_ID::int32 _internal_interleave_batch_size() const;
2686  void _internal_set_interleave_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2687  public:
2688 
2689  // optional int32 max_presolve_iterations = 138 [default = 3];
2690  bool has_max_presolve_iterations() const;
2691  private:
2692  bool _internal_has_max_presolve_iterations() const;
2693  public:
2694  void clear_max_presolve_iterations();
2695  ::PROTOBUF_NAMESPACE_ID::int32 max_presolve_iterations() const;
2696  void set_max_presolve_iterations(::PROTOBUF_NAMESPACE_ID::int32 value);
2697  private:
2698  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_presolve_iterations() const;
2699  void _internal_set_max_presolve_iterations(::PROTOBUF_NAMESPACE_ID::int32 value);
2700  public:
2701 
2702  // optional double merge_no_overlap_work_limit = 145 [default = 1000000000000];
2703  bool has_merge_no_overlap_work_limit() const;
2704  private:
2705  bool _internal_has_merge_no_overlap_work_limit() const;
2706  public:
2707  void clear_merge_no_overlap_work_limit();
2708  double merge_no_overlap_work_limit() const;
2709  void set_merge_no_overlap_work_limit(double value);
2710  private:
2711  double _internal_merge_no_overlap_work_limit() const;
2712  void _internal_set_merge_no_overlap_work_limit(double value);
2713  public:
2714 
2715  // optional double merge_at_most_one_work_limit = 146 [default = 100000000];
2716  bool has_merge_at_most_one_work_limit() const;
2717  private:
2718  bool _internal_has_merge_at_most_one_work_limit() const;
2719  public:
2720  void clear_merge_at_most_one_work_limit();
2721  double merge_at_most_one_work_limit() const;
2722  void set_merge_at_most_one_work_limit(double value);
2723  private:
2724  double _internal_merge_at_most_one_work_limit() const;
2725  void _internal_set_merge_at_most_one_work_limit(double value);
2726  public:
2727 
2728  // optional int32 presolve_substitution_level = 147 [default = 1];
2729  bool has_presolve_substitution_level() const;
2730  private:
2731  bool _internal_has_presolve_substitution_level() const;
2732  public:
2733  void clear_presolve_substitution_level();
2734  ::PROTOBUF_NAMESPACE_ID::int32 presolve_substitution_level() const;
2735  void set_presolve_substitution_level(::PROTOBUF_NAMESPACE_ID::int32 value);
2736  private:
2737  ::PROTOBUF_NAMESPACE_ID::int32 _internal_presolve_substitution_level() const;
2738  void _internal_set_presolve_substitution_level(::PROTOBUF_NAMESPACE_ID::int32 value);
2739  public:
2740 
2741  // optional int32 max_all_diff_cut_size = 148 [default = 7];
2742  bool has_max_all_diff_cut_size() const;
2743  private:
2744  bool _internal_has_max_all_diff_cut_size() const;
2745  public:
2746  void clear_max_all_diff_cut_size();
2747  ::PROTOBUF_NAMESPACE_ID::int32 max_all_diff_cut_size() const;
2748  void set_max_all_diff_cut_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2749  private:
2750  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_all_diff_cut_size() const;
2751  void _internal_set_max_all_diff_cut_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2752  public:
2753 
2754  // optional bool catch_sigint_signal = 135 [default = true];
2755  bool has_catch_sigint_signal() const;
2756  private:
2757  bool _internal_has_catch_sigint_signal() const;
2758  public:
2759  void clear_catch_sigint_signal();
2760  bool catch_sigint_signal() const;
2761  void set_catch_sigint_signal(bool value);
2762  private:
2763  bool _internal_catch_sigint_signal() const;
2764  void _internal_set_catch_sigint_signal(bool value);
2765  public:
2766 
2767  // optional bool use_implied_bounds = 144 [default = true];
2768  bool has_use_implied_bounds() const;
2769  private:
2770  bool _internal_has_use_implied_bounds() const;
2771  public:
2772  void clear_use_implied_bounds();
2773  bool use_implied_bounds() const;
2774  void set_use_implied_bounds(bool value);
2775  private:
2776  bool _internal_use_implied_bounds() const;
2777  void _internal_set_use_implied_bounds(bool value);
2778  public:
2779 
2780  // optional bool mip_automatically_scale_variables = 166 [default = true];
2781  bool has_mip_automatically_scale_variables() const;
2782  private:
2783  bool _internal_has_mip_automatically_scale_variables() const;
2784  public:
2785  void clear_mip_automatically_scale_variables();
2786  bool mip_automatically_scale_variables() const;
2787  void set_mip_automatically_scale_variables(bool value);
2788  private:
2789  bool _internal_mip_automatically_scale_variables() const;
2790  void _internal_set_mip_automatically_scale_variables(bool value);
2791  public:
2792 
2793  // optional int32 hint_conflict_limit = 153 [default = 10];
2794  bool has_hint_conflict_limit() const;
2795  private:
2796  bool _internal_has_hint_conflict_limit() const;
2797  public:
2798  void clear_hint_conflict_limit();
2799  ::PROTOBUF_NAMESPACE_ID::int32 hint_conflict_limit() const;
2800  void set_hint_conflict_limit(::PROTOBUF_NAMESPACE_ID::int32 value);
2801  private:
2802  ::PROTOBUF_NAMESPACE_ID::int32 _internal_hint_conflict_limit() const;
2803  void _internal_set_hint_conflict_limit(::PROTOBUF_NAMESPACE_ID::int32 value);
2804  public:
2805 
2806  // optional double cut_max_active_count_value = 155 [default = 10000000000];
2807  bool has_cut_max_active_count_value() const;
2808  private:
2809  bool _internal_has_cut_max_active_count_value() const;
2810  public:
2811  void clear_cut_max_active_count_value();
2812  double cut_max_active_count_value() const;
2813  void set_cut_max_active_count_value(double value);
2814  private:
2815  double _internal_cut_max_active_count_value() const;
2816  void _internal_set_cut_max_active_count_value(double value);
2817  public:
2818 
2819  // optional int32 max_cut_rounds_at_level_zero = 154 [default = 1];
2820  bool has_max_cut_rounds_at_level_zero() const;
2821  private:
2822  bool _internal_has_max_cut_rounds_at_level_zero() const;
2823  public:
2824  void clear_max_cut_rounds_at_level_zero();
2825  ::PROTOBUF_NAMESPACE_ID::int32 max_cut_rounds_at_level_zero() const;
2826  void set_max_cut_rounds_at_level_zero(::PROTOBUF_NAMESPACE_ID::int32 value);
2827  private:
2828  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_cut_rounds_at_level_zero() const;
2829  void _internal_set_max_cut_rounds_at_level_zero(::PROTOBUF_NAMESPACE_ID::int32 value);
2830  public:
2831 
2832  // optional int32 cut_cleanup_target = 157 [default = 1000];
2833  bool has_cut_cleanup_target() const;
2834  private:
2835  bool _internal_has_cut_cleanup_target() const;
2836  public:
2837  void clear_cut_cleanup_target();
2838  ::PROTOBUF_NAMESPACE_ID::int32 cut_cleanup_target() const;
2839  void set_cut_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value);
2840  private:
2841  ::PROTOBUF_NAMESPACE_ID::int32 _internal_cut_cleanup_target() const;
2842  void _internal_set_cut_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value);
2843  public:
2844 
2845  // optional double cut_active_count_decay = 156 [default = 0.8];
2846  bool has_cut_active_count_decay() const;
2847  private:
2848  bool _internal_has_cut_active_count_decay() const;
2849  public:
2850  void clear_cut_active_count_decay();
2851  double cut_active_count_decay() const;
2852  void set_cut_active_count_decay(double value);
2853  private:
2854  double _internal_cut_active_count_decay() const;
2855  void _internal_set_cut_active_count_decay(double value);
2856  public:
2857 
2858  // optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
2859  bool has_fp_rounding() const;
2860  private:
2861  bool _internal_has_fp_rounding() const;
2862  public:
2863  void clear_fp_rounding();
2864  ::operations_research::sat::SatParameters_FPRoundingMethod fp_rounding() const;
2865  void set_fp_rounding(::operations_research::sat::SatParameters_FPRoundingMethod value);
2866  private:
2867  ::operations_research::sat::SatParameters_FPRoundingMethod _internal_fp_rounding() const;
2868  void _internal_set_fp_rounding(::operations_research::sat::SatParameters_FPRoundingMethod value);
2869  public:
2870 
2871  // optional int32 polarity_rephase_increment = 168 [default = 1000];
2872  bool has_polarity_rephase_increment() const;
2873  private:
2874  bool _internal_has_polarity_rephase_increment() const;
2875  public:
2876  void clear_polarity_rephase_increment();
2877  ::PROTOBUF_NAMESPACE_ID::int32 polarity_rephase_increment() const;
2878  void set_polarity_rephase_increment(::PROTOBUF_NAMESPACE_ID::int32 value);
2879  private:
2880  ::PROTOBUF_NAMESPACE_ID::int32 _internal_polarity_rephase_increment() const;
2881  void _internal_set_polarity_rephase_increment(::PROTOBUF_NAMESPACE_ID::int32 value);
2882  public:
2883 
2884  // @@protoc_insertion_point(class_scope:operations_research.sat.SatParameters)
2885  private:
2886  class _Internal;
2887 
2888  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2889  typedef void InternalArenaConstructable_;
2890  typedef void DestructorSkippable_;
2891  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<5> _has_bits_;
2892  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2893  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> restart_algorithms_;
2894  public:
2895  static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> _i_give_permission_to_break_this_code_default_default_restart_algorithms_;
2896  private:
2897  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default_restart_algorithms_;
2898  int preferred_variable_order_;
2899  int max_sat_assumption_order_;
2900  double random_branches_ratio_;
2901  double random_polarity_ratio_;
2902  int clause_cleanup_protection_;
2903  int clause_cleanup_ordering_;
2904  bool use_erwa_heuristic_;
2905  bool also_bump_variables_in_conflict_reasons_;
2906  bool use_blocking_restart_;
2907  bool log_search_progress_;
2908  ::PROTOBUF_NAMESPACE_ID::int32 num_conflicts_before_strategy_changes_;
2909  double strategy_change_increase_ratio_;
2910  double initial_variables_activity_;
2911  bool max_sat_reverse_assumption_order_;
2912  bool use_overload_checker_in_cumulative_constraint_;
2913  bool use_timetable_edge_finding_in_cumulative_constraint_;
2914  bool only_add_cuts_at_level_zero_;
2915  int search_branching_;
2916  bool optimize_with_core_;
2917  bool optimize_with_max_hs_;
2918  bool enumerate_all_solutions_;
2919  bool fill_tightened_domains_in_response_;
2920  bool use_pb_resolution_;
2921  bool minimize_reduction_during_pb_resolution_;
2922  bool cp_model_postsolve_with_full_solver_;
2923  bool use_sat_inprocessing_;
2924  ::PROTOBUF_NAMESPACE_ID::int64 search_randomization_tolerance_;
2925  bool use_lns_only_;
2926  bool lns_focus_on_decision_variables_;
2927  bool use_relaxation_lns_;
2928  bool diversify_lns_params_;
2929  bool randomize_search_;
2930  bool use_branching_in_lp_;
2931  bool use_combined_no_overlap_;
2932  bool stop_after_first_solution_;
2933  bool stop_after_presolve_;
2934  bool interleave_search_;
2935  bool reduce_memory_usage_in_interleave_mode_;
2936  bool add_knapsack_cuts_;
2937  bool repair_hint_;
2938  bool exploit_best_solution_;
2939  bool exploit_relaxation_solution_;
2940  ::PROTOBUF_NAMESPACE_ID::int64 probing_period_at_root_;
2941  ::PROTOBUF_NAMESPACE_ID::int32 cp_model_max_num_presolve_operations_;
2942  double absolute_gap_limit_;
2943  double relative_gap_limit_;
2944  int initial_polarity_;
2945  int minimization_algorithm_;
2946  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_period_;
2947  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_target_;
2948  double variable_activity_decay_;
2949  double max_variable_activity_value_;
2950  double clause_activity_decay_;
2951  double max_clause_activity_value_;
2952  double glucose_max_decay_;
2953  double glucose_decay_increment_;
2954  ::PROTOBUF_NAMESPACE_ID::int32 glucose_decay_increment_period_;
2955  ::PROTOBUF_NAMESPACE_ID::int32 restart_period_;
2956  ::PROTOBUF_NAMESPACE_ID::int32 random_seed_;
2957  int binary_minimization_algorithm_;
2958  double max_time_in_seconds_;
2959  ::PROTOBUF_NAMESPACE_ID::int64 max_number_of_conflicts_;
2960  ::PROTOBUF_NAMESPACE_ID::int64 max_memory_in_mb_;
2961  bool use_phase_saving_;
2962  bool subsumption_during_conflict_analysis_;
2963  bool treat_binary_clauses_separately_;
2964  bool count_assumption_levels_in_lbd_;
2965  ::PROTOBUF_NAMESPACE_ID::int32 pb_cleanup_increment_;
2966  double pb_cleanup_ratio_;
2967  int max_sat_stratification_;
2968  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_threshold_;
2969  double presolve_probing_deterministic_time_limit_;
2970  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_clause_weight_;
2971  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_lbd_bound_;
2972  double restart_dl_average_ratio_;
2973  ::PROTOBUF_NAMESPACE_ID::int32 restart_running_window_size_;
2974  ::PROTOBUF_NAMESPACE_ID::int32 blocking_restart_window_size_;
2975  double blocking_restart_multiplier_;
2976  double max_deterministic_time_;
2977  double restart_lbd_average_ratio_;
2978  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bva_threshold_;
2979  bool minimize_core_;
2980  bool find_multiple_cores_;
2981  bool cover_optimization_;
2982  bool use_precedences_in_disjunctive_constraint_;
2983  bool presolve_blocked_clause_;
2984  bool presolve_use_bva_;
2985  bool cp_model_presolve_;
2986  bool cp_model_use_sat_presolve_;
2987  ::PROTOBUF_NAMESPACE_ID::int32 linearization_level_;
2988  ::PROTOBUF_NAMESPACE_ID::int32 max_num_cuts_;
2989  ::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_restart_period_;
2990  ::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_num_decisions_;
2991  ::PROTOBUF_NAMESPACE_ID::int32 binary_search_num_conflicts_;
2992  ::PROTOBUF_NAMESPACE_ID::int32 num_search_workers_;
2993  ::PROTOBUF_NAMESPACE_ID::int32 boolean_encoding_level_;
2994  bool instantiate_all_variables_;
2995  bool auto_detect_greater_than_at_least_one_of_;
2996  bool share_objective_bounds_;
2997  bool share_level_zero_bounds_;
2998  ::PROTOBUF_NAMESPACE_ID::int32 cp_model_probing_level_;
2999  double min_orthogonality_for_lp_constraints_;
3000  bool add_lp_constraints_lazily_;
3001  bool exploit_integer_lp_solution_;
3002  bool exploit_all_lp_solution_;
3003  bool exploit_objective_;
3004  bool use_disjunctive_constraint_in_cumulative_constraint_;
3005  bool add_cg_cuts_;
3006  bool add_mir_cuts_;
3007  bool add_lin_max_cuts_;
3008  ::PROTOBUF_NAMESPACE_ID::int32 max_integer_rounding_scaling_;
3009  bool expand_element_constraints_;
3010  bool expand_automaton_constraints_;
3011  bool expand_table_constraints_;
3012  bool use_optimization_hints_;
3013  ::PROTOBUF_NAMESPACE_ID::int32 max_consecutive_inactive_count_;
3014  ::PROTOBUF_NAMESPACE_ID::int32 new_constraints_batch_size_;
3015  ::PROTOBUF_NAMESPACE_ID::int64 pseudo_cost_reliability_threshold_;
3016  double mip_max_bound_;
3017  double mip_var_scaling_;
3018  double mip_wanted_precision_;
3019  ::PROTOBUF_NAMESPACE_ID::int32 mip_max_activity_exponent_;
3020  bool use_rins_lns_;
3021  bool use_feasibility_pump_;
3022  bool use_optional_variables_;
3023  bool use_exact_lp_reason_;
3024  double mip_check_precision_;
3025  ::PROTOBUF_NAMESPACE_ID::int32 interleave_batch_size_;
3026  ::PROTOBUF_NAMESPACE_ID::int32 max_presolve_iterations_;
3027  double merge_no_overlap_work_limit_;
3028  double merge_at_most_one_work_limit_;
3029  ::PROTOBUF_NAMESPACE_ID::int32 presolve_substitution_level_;
3030  ::PROTOBUF_NAMESPACE_ID::int32 max_all_diff_cut_size_;
3031  bool catch_sigint_signal_;
3032  bool use_implied_bounds_;
3033  bool mip_automatically_scale_variables_;
3034  ::PROTOBUF_NAMESPACE_ID::int32 hint_conflict_limit_;
3035  double cut_max_active_count_value_;
3036  ::PROTOBUF_NAMESPACE_ID::int32 max_cut_rounds_at_level_zero_;
3037  ::PROTOBUF_NAMESPACE_ID::int32 cut_cleanup_target_;
3038  double cut_active_count_decay_;
3039  int fp_rounding_;
3040  ::PROTOBUF_NAMESPACE_ID::int32 polarity_rephase_increment_;
3041  friend struct ::TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto;
3042 };
3043 // ===================================================================
3044 
3045 
3046 // ===================================================================
3047 
3048 #ifdef __GNUC__
3049  #pragma GCC diagnostic push
3050  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
3051 #endif // __GNUC__
3052 // SatParameters
3053 
3054 // optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
3055 inline bool SatParameters::_internal_has_preferred_variable_order() const {
3056  bool value = (_has_bits_[0] & 0x00000002u) != 0;
3057  return value;
3058 }
3059 inline bool SatParameters::has_preferred_variable_order() const {
3060  return _internal_has_preferred_variable_order();
3061 }
3062 inline void SatParameters::clear_preferred_variable_order() {
3063  preferred_variable_order_ = 0;
3064  _has_bits_[0] &= ~0x00000002u;
3065 }
3066 inline ::operations_research::sat::SatParameters_VariableOrder SatParameters::_internal_preferred_variable_order() const {
3067  return static_cast< ::operations_research::sat::SatParameters_VariableOrder >(preferred_variable_order_);
3068 }
3069 inline ::operations_research::sat::SatParameters_VariableOrder SatParameters::preferred_variable_order() const {
3070  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.preferred_variable_order)
3071  return _internal_preferred_variable_order();
3072 }
3073 inline void SatParameters::_internal_set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value) {
3074  assert(::operations_research::sat::SatParameters_VariableOrder_IsValid(value));
3075  _has_bits_[0] |= 0x00000002u;
3076  preferred_variable_order_ = value;
3077 }
3078 inline void SatParameters::set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value) {
3079  _internal_set_preferred_variable_order(value);
3080  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.preferred_variable_order)
3081 }
3082 
3083 // optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
3084 inline bool SatParameters::_internal_has_initial_polarity() const {
3085  bool value = (_has_bits_[1] & 0x00008000u) != 0;
3086  return value;
3087 }
3088 inline bool SatParameters::has_initial_polarity() const {
3089  return _internal_has_initial_polarity();
3090 }
3091 inline void SatParameters::clear_initial_polarity() {
3092  initial_polarity_ = 1;
3093  _has_bits_[1] &= ~0x00008000u;
3094 }
3095 inline ::operations_research::sat::SatParameters_Polarity SatParameters::_internal_initial_polarity() const {
3096  return static_cast< ::operations_research::sat::SatParameters_Polarity >(initial_polarity_);
3097 }
3098 inline ::operations_research::sat::SatParameters_Polarity SatParameters::initial_polarity() const {
3099  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.initial_polarity)
3100  return _internal_initial_polarity();
3101 }
3102 inline void SatParameters::_internal_set_initial_polarity(::operations_research::sat::SatParameters_Polarity value) {
3103  assert(::operations_research::sat::SatParameters_Polarity_IsValid(value));
3104  _has_bits_[1] |= 0x00008000u;
3105  initial_polarity_ = value;
3106 }
3107 inline void SatParameters::set_initial_polarity(::operations_research::sat::SatParameters_Polarity value) {
3108  _internal_set_initial_polarity(value);
3109  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.initial_polarity)
3110 }
3111 
3112 // optional bool use_phase_saving = 44 [default = true];
3113 inline bool SatParameters::_internal_has_use_phase_saving() const {
3114  bool value = (_has_bits_[2] & 0x00000001u) != 0;
3115  return value;
3116 }
3117 inline bool SatParameters::has_use_phase_saving() const {
3118  return _internal_has_use_phase_saving();
3119 }
3120 inline void SatParameters::clear_use_phase_saving() {
3121  use_phase_saving_ = true;
3122  _has_bits_[2] &= ~0x00000001u;
3123 }
3124 inline bool SatParameters::_internal_use_phase_saving() const {
3125  return use_phase_saving_;
3126 }
3127 inline bool SatParameters::use_phase_saving() const {
3128  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_phase_saving)
3129  return _internal_use_phase_saving();
3130 }
3131 inline void SatParameters::_internal_set_use_phase_saving(bool value) {
3132  _has_bits_[2] |= 0x00000001u;
3133  use_phase_saving_ = value;
3134 }
3135 inline void SatParameters::set_use_phase_saving(bool value) {
3136  _internal_set_use_phase_saving(value);
3137  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_phase_saving)
3138 }
3139 
3140 // optional int32 polarity_rephase_increment = 168 [default = 1000];
3141 inline bool SatParameters::_internal_has_polarity_rephase_increment() const {
3142  bool value = (_has_bits_[4] & 0x00008000u) != 0;
3143  return value;
3144 }
3145 inline bool SatParameters::has_polarity_rephase_increment() const {
3146  return _internal_has_polarity_rephase_increment();
3147 }
3148 inline void SatParameters::clear_polarity_rephase_increment() {
3149  polarity_rephase_increment_ = 1000;
3150  _has_bits_[4] &= ~0x00008000u;
3151 }
3152 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_polarity_rephase_increment() const {
3153  return polarity_rephase_increment_;
3154 }
3155 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::polarity_rephase_increment() const {
3156  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.polarity_rephase_increment)
3157  return _internal_polarity_rephase_increment();
3158 }
3159 inline void SatParameters::_internal_set_polarity_rephase_increment(::PROTOBUF_NAMESPACE_ID::int32 value) {
3160  _has_bits_[4] |= 0x00008000u;
3161  polarity_rephase_increment_ = value;
3162 }
3163 inline void SatParameters::set_polarity_rephase_increment(::PROTOBUF_NAMESPACE_ID::int32 value) {
3164  _internal_set_polarity_rephase_increment(value);
3165  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.polarity_rephase_increment)
3166 }
3167 
3168 // optional double random_polarity_ratio = 45 [default = 0];
3169 inline bool SatParameters::_internal_has_random_polarity_ratio() const {
3170  bool value = (_has_bits_[0] & 0x00000010u) != 0;
3171  return value;
3172 }
3173 inline bool SatParameters::has_random_polarity_ratio() const {
3174  return _internal_has_random_polarity_ratio();
3175 }
3176 inline void SatParameters::clear_random_polarity_ratio() {
3177  random_polarity_ratio_ = 0;
3178  _has_bits_[0] &= ~0x00000010u;
3179 }
3180 inline double SatParameters::_internal_random_polarity_ratio() const {
3181  return random_polarity_ratio_;
3182 }
3183 inline double SatParameters::random_polarity_ratio() const {
3184  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.random_polarity_ratio)
3185  return _internal_random_polarity_ratio();
3186 }
3187 inline void SatParameters::_internal_set_random_polarity_ratio(double value) {
3188  _has_bits_[0] |= 0x00000010u;
3189  random_polarity_ratio_ = value;
3190 }
3191 inline void SatParameters::set_random_polarity_ratio(double value) {
3192  _internal_set_random_polarity_ratio(value);
3193  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.random_polarity_ratio)
3194 }
3195 
3196 // optional double random_branches_ratio = 32 [default = 0];
3197 inline bool SatParameters::_internal_has_random_branches_ratio() const {
3198  bool value = (_has_bits_[0] & 0x00000008u) != 0;
3199  return value;
3200 }
3201 inline bool SatParameters::has_random_branches_ratio() const {
3202  return _internal_has_random_branches_ratio();
3203 }
3204 inline void SatParameters::clear_random_branches_ratio() {
3205  random_branches_ratio_ = 0;
3206  _has_bits_[0] &= ~0x00000008u;
3207 }
3208 inline double SatParameters::_internal_random_branches_ratio() const {
3209  return random_branches_ratio_;
3210 }
3211 inline double SatParameters::random_branches_ratio() const {
3212  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.random_branches_ratio)
3213  return _internal_random_branches_ratio();
3214 }
3215 inline void SatParameters::_internal_set_random_branches_ratio(double value) {
3216  _has_bits_[0] |= 0x00000008u;
3217  random_branches_ratio_ = value;
3218 }
3219 inline void SatParameters::set_random_branches_ratio(double value) {
3220  _internal_set_random_branches_ratio(value);
3221  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.random_branches_ratio)
3222 }
3223 
3224 // optional bool use_erwa_heuristic = 75 [default = false];
3225 inline bool SatParameters::_internal_has_use_erwa_heuristic() const {
3226  bool value = (_has_bits_[0] & 0x00000080u) != 0;
3227  return value;
3228 }
3229 inline bool SatParameters::has_use_erwa_heuristic() const {
3230  return _internal_has_use_erwa_heuristic();
3231 }
3232 inline void SatParameters::clear_use_erwa_heuristic() {
3233  use_erwa_heuristic_ = false;
3234  _has_bits_[0] &= ~0x00000080u;
3235 }
3236 inline bool SatParameters::_internal_use_erwa_heuristic() const {
3237  return use_erwa_heuristic_;
3238 }
3239 inline bool SatParameters::use_erwa_heuristic() const {
3240  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_erwa_heuristic)
3241  return _internal_use_erwa_heuristic();
3242 }
3243 inline void SatParameters::_internal_set_use_erwa_heuristic(bool value) {
3244  _has_bits_[0] |= 0x00000080u;
3245  use_erwa_heuristic_ = value;
3246 }
3247 inline void SatParameters::set_use_erwa_heuristic(bool value) {
3248  _internal_set_use_erwa_heuristic(value);
3249  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_erwa_heuristic)
3250 }
3251 
3252 // optional double initial_variables_activity = 76 [default = 0];
3253 inline bool SatParameters::_internal_has_initial_variables_activity() const {
3254  bool value = (_has_bits_[0] & 0x00002000u) != 0;
3255  return value;
3256 }
3257 inline bool SatParameters::has_initial_variables_activity() const {
3258  return _internal_has_initial_variables_activity();
3259 }
3260 inline void SatParameters::clear_initial_variables_activity() {
3261  initial_variables_activity_ = 0;
3262  _has_bits_[0] &= ~0x00002000u;
3263 }
3264 inline double SatParameters::_internal_initial_variables_activity() const {
3265  return initial_variables_activity_;
3266 }
3267 inline double SatParameters::initial_variables_activity() const {
3268  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.initial_variables_activity)
3269  return _internal_initial_variables_activity();
3270 }
3271 inline void SatParameters::_internal_set_initial_variables_activity(double value) {
3272  _has_bits_[0] |= 0x00002000u;
3273  initial_variables_activity_ = value;
3274 }
3275 inline void SatParameters::set_initial_variables_activity(double value) {
3276  _internal_set_initial_variables_activity(value);
3277  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.initial_variables_activity)
3278 }
3279 
3280 // optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
3281 inline bool SatParameters::_internal_has_also_bump_variables_in_conflict_reasons() const {
3282  bool value = (_has_bits_[0] & 0x00000100u) != 0;
3283  return value;
3284 }
3285 inline bool SatParameters::has_also_bump_variables_in_conflict_reasons() const {
3286  return _internal_has_also_bump_variables_in_conflict_reasons();
3287 }
3288 inline void SatParameters::clear_also_bump_variables_in_conflict_reasons() {
3289  also_bump_variables_in_conflict_reasons_ = false;
3290  _has_bits_[0] &= ~0x00000100u;
3291 }
3292 inline bool SatParameters::_internal_also_bump_variables_in_conflict_reasons() const {
3293  return also_bump_variables_in_conflict_reasons_;
3294 }
3295 inline bool SatParameters::also_bump_variables_in_conflict_reasons() const {
3296  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.also_bump_variables_in_conflict_reasons)
3297  return _internal_also_bump_variables_in_conflict_reasons();
3298 }
3299 inline void SatParameters::_internal_set_also_bump_variables_in_conflict_reasons(bool value) {
3300  _has_bits_[0] |= 0x00000100u;
3301  also_bump_variables_in_conflict_reasons_ = value;
3302 }
3303 inline void SatParameters::set_also_bump_variables_in_conflict_reasons(bool value) {
3304  _internal_set_also_bump_variables_in_conflict_reasons(value);
3305  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.also_bump_variables_in_conflict_reasons)
3306 }
3307 
3308 // optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
3309 inline bool SatParameters::_internal_has_minimization_algorithm() const {
3310  bool value = (_has_bits_[1] & 0x00010000u) != 0;
3311  return value;
3312 }
3313 inline bool SatParameters::has_minimization_algorithm() const {
3314  return _internal_has_minimization_algorithm();
3315 }
3316 inline void SatParameters::clear_minimization_algorithm() {
3317  minimization_algorithm_ = 2;
3318  _has_bits_[1] &= ~0x00010000u;
3319 }
3320 inline ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm SatParameters::_internal_minimization_algorithm() const {
3321  return static_cast< ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm >(minimization_algorithm_);
3322 }
3323 inline ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm SatParameters::minimization_algorithm() const {
3324  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimization_algorithm)
3325  return _internal_minimization_algorithm();
3326 }
3327 inline void SatParameters::_internal_set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value) {
3328  assert(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_IsValid(value));
3329  _has_bits_[1] |= 0x00010000u;
3330  minimization_algorithm_ = value;
3331 }
3332 inline void SatParameters::set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value) {
3333  _internal_set_minimization_algorithm(value);
3334  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimization_algorithm)
3335 }
3336 
3337 // optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];
3338 inline bool SatParameters::_internal_has_binary_minimization_algorithm() const {
3339  bool value = (_has_bits_[1] & 0x10000000u) != 0;
3340  return value;
3341 }
3342 inline bool SatParameters::has_binary_minimization_algorithm() const {
3343  return _internal_has_binary_minimization_algorithm();
3344 }
3345 inline void SatParameters::clear_binary_minimization_algorithm() {
3346  binary_minimization_algorithm_ = 1;
3347  _has_bits_[1] &= ~0x10000000u;
3348 }
3349 inline ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm SatParameters::_internal_binary_minimization_algorithm() const {
3350  return static_cast< ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm >(binary_minimization_algorithm_);
3351 }
3352 inline ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm SatParameters::binary_minimization_algorithm() const {
3353  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.binary_minimization_algorithm)
3354  return _internal_binary_minimization_algorithm();
3355 }
3356 inline void SatParameters::_internal_set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value) {
3357  assert(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm_IsValid(value));
3358  _has_bits_[1] |= 0x10000000u;
3359  binary_minimization_algorithm_ = value;
3360 }
3361 inline void SatParameters::set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value) {
3362  _internal_set_binary_minimization_algorithm(value);
3363  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.binary_minimization_algorithm)
3364 }
3365 
3366 // optional bool subsumption_during_conflict_analysis = 56 [default = true];
3367 inline bool SatParameters::_internal_has_subsumption_during_conflict_analysis() const {
3368  bool value = (_has_bits_[2] & 0x00000002u) != 0;
3369  return value;
3370 }
3371 inline bool SatParameters::has_subsumption_during_conflict_analysis() const {
3372  return _internal_has_subsumption_during_conflict_analysis();
3373 }
3374 inline void SatParameters::clear_subsumption_during_conflict_analysis() {
3375  subsumption_during_conflict_analysis_ = true;
3376  _has_bits_[2] &= ~0x00000002u;
3377 }
3378 inline bool SatParameters::_internal_subsumption_during_conflict_analysis() const {
3379  return subsumption_during_conflict_analysis_;
3380 }
3381 inline bool SatParameters::subsumption_during_conflict_analysis() const {
3382  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.subsumption_during_conflict_analysis)
3383  return _internal_subsumption_during_conflict_analysis();
3384 }
3385 inline void SatParameters::_internal_set_subsumption_during_conflict_analysis(bool value) {
3386  _has_bits_[2] |= 0x00000002u;
3387  subsumption_during_conflict_analysis_ = value;
3388 }
3389 inline void SatParameters::set_subsumption_during_conflict_analysis(bool value) {
3390  _internal_set_subsumption_during_conflict_analysis(value);
3391  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.subsumption_during_conflict_analysis)
3392 }
3393 
3394 // optional int32 clause_cleanup_period = 11 [default = 10000];
3395 inline bool SatParameters::_internal_has_clause_cleanup_period() const {
3396  bool value = (_has_bits_[1] & 0x00020000u) != 0;
3397  return value;
3398 }
3399 inline bool SatParameters::has_clause_cleanup_period() const {
3400  return _internal_has_clause_cleanup_period();
3401 }
3402 inline void SatParameters::clear_clause_cleanup_period() {
3403  clause_cleanup_period_ = 10000;
3404  _has_bits_[1] &= ~0x00020000u;
3405 }
3406 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_clause_cleanup_period() const {
3407  return clause_cleanup_period_;
3408 }
3409 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::clause_cleanup_period() const {
3410  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_period)
3411  return _internal_clause_cleanup_period();
3412 }
3413 inline void SatParameters::_internal_set_clause_cleanup_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
3414  _has_bits_[1] |= 0x00020000u;
3415  clause_cleanup_period_ = value;
3416 }
3417 inline void SatParameters::set_clause_cleanup_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
3418  _internal_set_clause_cleanup_period(value);
3419  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_period)
3420 }
3421 
3422 // optional int32 clause_cleanup_target = 13 [default = 10000];
3423 inline bool SatParameters::_internal_has_clause_cleanup_target() const {
3424  bool value = (_has_bits_[1] & 0x00040000u) != 0;
3425  return value;
3426 }
3427 inline bool SatParameters::has_clause_cleanup_target() const {
3428  return _internal_has_clause_cleanup_target();
3429 }
3430 inline void SatParameters::clear_clause_cleanup_target() {
3431  clause_cleanup_target_ = 10000;
3432  _has_bits_[1] &= ~0x00040000u;
3433 }
3434 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_clause_cleanup_target() const {
3435  return clause_cleanup_target_;
3436 }
3437 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::clause_cleanup_target() const {
3438  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_target)
3439  return _internal_clause_cleanup_target();
3440 }
3441 inline void SatParameters::_internal_set_clause_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value) {
3442  _has_bits_[1] |= 0x00040000u;
3443  clause_cleanup_target_ = value;
3444 }
3445 inline void SatParameters::set_clause_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value) {
3446  _internal_set_clause_cleanup_target(value);
3447  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_target)
3448 }
3449 
3450 // optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];
3451 inline bool SatParameters::_internal_has_clause_cleanup_protection() const {
3452  bool value = (_has_bits_[0] & 0x00000020u) != 0;
3453  return value;
3454 }
3455 inline bool SatParameters::has_clause_cleanup_protection() const {
3456  return _internal_has_clause_cleanup_protection();
3457 }
3458 inline void SatParameters::clear_clause_cleanup_protection() {
3459  clause_cleanup_protection_ = 0;
3460  _has_bits_[0] &= ~0x00000020u;
3461 }
3462 inline ::operations_research::sat::SatParameters_ClauseProtection SatParameters::_internal_clause_cleanup_protection() const {
3463  return static_cast< ::operations_research::sat::SatParameters_ClauseProtection >(clause_cleanup_protection_);
3464 }
3465 inline ::operations_research::sat::SatParameters_ClauseProtection SatParameters::clause_cleanup_protection() const {
3466  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_protection)
3467  return _internal_clause_cleanup_protection();
3468 }
3469 inline void SatParameters::_internal_set_clause_cleanup_protection(::operations_research::sat::SatParameters_ClauseProtection value) {
3470  assert(::operations_research::sat::SatParameters_ClauseProtection_IsValid(value));
3471  _has_bits_[0] |= 0x00000020u;
3472  clause_cleanup_protection_ = value;
3473 }
3474 inline void SatParameters::set_clause_cleanup_protection(::operations_research::sat::SatParameters_ClauseProtection value) {
3475  _internal_set_clause_cleanup_protection(value);
3476  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_protection)
3477 }
3478 
3479 // optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
3480 inline bool SatParameters::_internal_has_clause_cleanup_lbd_bound() const {
3481  bool value = (_has_bits_[2] & 0x00000400u) != 0;
3482  return value;
3483 }
3484 inline bool SatParameters::has_clause_cleanup_lbd_bound() const {
3485  return _internal_has_clause_cleanup_lbd_bound();
3486 }
3487 inline void SatParameters::clear_clause_cleanup_lbd_bound() {
3488  clause_cleanup_lbd_bound_ = 5;
3489  _has_bits_[2] &= ~0x00000400u;
3490 }
3491 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_clause_cleanup_lbd_bound() const {
3492  return clause_cleanup_lbd_bound_;
3493 }
3494 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::clause_cleanup_lbd_bound() const {
3495  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_lbd_bound)
3496  return _internal_clause_cleanup_lbd_bound();
3497 }
3498 inline void SatParameters::_internal_set_clause_cleanup_lbd_bound(::PROTOBUF_NAMESPACE_ID::int32 value) {
3499  _has_bits_[2] |= 0x00000400u;
3500  clause_cleanup_lbd_bound_ = value;
3501 }
3502 inline void SatParameters::set_clause_cleanup_lbd_bound(::PROTOBUF_NAMESPACE_ID::int32 value) {
3503  _internal_set_clause_cleanup_lbd_bound(value);
3504  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_lbd_bound)
3505 }
3506 
3507 // optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
3508 inline bool SatParameters::_internal_has_clause_cleanup_ordering() const {
3509  bool value = (_has_bits_[0] & 0x00000040u) != 0;
3510  return value;
3511 }
3512 inline bool SatParameters::has_clause_cleanup_ordering() const {
3513  return _internal_has_clause_cleanup_ordering();
3514 }
3515 inline void SatParameters::clear_clause_cleanup_ordering() {
3516  clause_cleanup_ordering_ = 0;
3517  _has_bits_[0] &= ~0x00000040u;
3518 }
3519 inline ::operations_research::sat::SatParameters_ClauseOrdering SatParameters::_internal_clause_cleanup_ordering() const {
3520  return static_cast< ::operations_research::sat::SatParameters_ClauseOrdering >(clause_cleanup_ordering_);
3521 }
3522 inline ::operations_research::sat::SatParameters_ClauseOrdering SatParameters::clause_cleanup_ordering() const {
3523  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_ordering)
3524  return _internal_clause_cleanup_ordering();
3525 }
3526 inline void SatParameters::_internal_set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value) {
3527  assert(::operations_research::sat::SatParameters_ClauseOrdering_IsValid(value));
3528  _has_bits_[0] |= 0x00000040u;
3529  clause_cleanup_ordering_ = value;
3530 }
3531 inline void SatParameters::set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value) {
3532  _internal_set_clause_cleanup_ordering(value);
3533  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_ordering)
3534 }
3535 
3536 // optional int32 pb_cleanup_increment = 46 [default = 200];
3537 inline bool SatParameters::_internal_has_pb_cleanup_increment() const {
3538  bool value = (_has_bits_[2] & 0x00000010u) != 0;
3539  return value;
3540 }
3541 inline bool SatParameters::has_pb_cleanup_increment() const {
3542  return _internal_has_pb_cleanup_increment();
3543 }
3544 inline void SatParameters::clear_pb_cleanup_increment() {
3545  pb_cleanup_increment_ = 200;
3546  _has_bits_[2] &= ~0x00000010u;
3547 }
3548 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_pb_cleanup_increment() const {
3549  return pb_cleanup_increment_;
3550 }
3551 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::pb_cleanup_increment() const {
3552  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.pb_cleanup_increment)
3553  return _internal_pb_cleanup_increment();
3554 }
3555 inline void SatParameters::_internal_set_pb_cleanup_increment(::PROTOBUF_NAMESPACE_ID::int32 value) {
3556  _has_bits_[2] |= 0x00000010u;
3557  pb_cleanup_increment_ = value;
3558 }
3559 inline void SatParameters::set_pb_cleanup_increment(::PROTOBUF_NAMESPACE_ID::int32 value) {
3560  _internal_set_pb_cleanup_increment(value);
3561  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.pb_cleanup_increment)
3562 }
3563 
3564 // optional double pb_cleanup_ratio = 47 [default = 0.5];
3565 inline bool SatParameters::_internal_has_pb_cleanup_ratio() const {
3566  bool value = (_has_bits_[2] & 0x00000020u) != 0;
3567  return value;
3568 }
3569 inline bool SatParameters::has_pb_cleanup_ratio() const {
3570  return _internal_has_pb_cleanup_ratio();
3571 }
3572 inline void SatParameters::clear_pb_cleanup_ratio() {
3573  pb_cleanup_ratio_ = 0.5;
3574  _has_bits_[2] &= ~0x00000020u;
3575 }
3576 inline double SatParameters::_internal_pb_cleanup_ratio() const {
3577  return pb_cleanup_ratio_;
3578 }
3579 inline double SatParameters::pb_cleanup_ratio() const {
3580  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.pb_cleanup_ratio)
3581  return _internal_pb_cleanup_ratio();
3582 }
3583 inline void SatParameters::_internal_set_pb_cleanup_ratio(double value) {
3584  _has_bits_[2] |= 0x00000020u;
3585  pb_cleanup_ratio_ = value;
3586 }
3587 inline void SatParameters::set_pb_cleanup_ratio(double value) {
3588  _internal_set_pb_cleanup_ratio(value);
3589  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.pb_cleanup_ratio)
3590 }
3591 
3592 // optional int32 minimize_with_propagation_restart_period = 96 [default = 10];
3593 inline bool SatParameters::_internal_has_minimize_with_propagation_restart_period() const {
3594  bool value = (_has_bits_[2] & 0x10000000u) != 0;
3595  return value;
3596 }
3597 inline bool SatParameters::has_minimize_with_propagation_restart_period() const {
3598  return _internal_has_minimize_with_propagation_restart_period();
3599 }
3600 inline void SatParameters::clear_minimize_with_propagation_restart_period() {
3601  minimize_with_propagation_restart_period_ = 10;
3602  _has_bits_[2] &= ~0x10000000u;
3603 }
3604 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_minimize_with_propagation_restart_period() const {
3605  return minimize_with_propagation_restart_period_;
3606 }
3607 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::minimize_with_propagation_restart_period() const {
3608  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimize_with_propagation_restart_period)
3609  return _internal_minimize_with_propagation_restart_period();
3610 }
3611 inline void SatParameters::_internal_set_minimize_with_propagation_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
3612  _has_bits_[2] |= 0x10000000u;
3613  minimize_with_propagation_restart_period_ = value;
3614 }
3615 inline void SatParameters::set_minimize_with_propagation_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
3616  _internal_set_minimize_with_propagation_restart_period(value);
3617  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimize_with_propagation_restart_period)
3618 }
3619 
3620 // optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];
3621 inline bool SatParameters::_internal_has_minimize_with_propagation_num_decisions() const {
3622  bool value = (_has_bits_[2] & 0x20000000u) != 0;
3623  return value;
3624 }
3625 inline bool SatParameters::has_minimize_with_propagation_num_decisions() const {
3626  return _internal_has_minimize_with_propagation_num_decisions();
3627 }
3628 inline void SatParameters::clear_minimize_with_propagation_num_decisions() {
3629  minimize_with_propagation_num_decisions_ = 1000;
3630  _has_bits_[2] &= ~0x20000000u;
3631 }
3632 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_minimize_with_propagation_num_decisions() const {
3633  return minimize_with_propagation_num_decisions_;
3634 }
3635 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::minimize_with_propagation_num_decisions() const {
3636  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimize_with_propagation_num_decisions)
3637  return _internal_minimize_with_propagation_num_decisions();
3638 }
3639 inline void SatParameters::_internal_set_minimize_with_propagation_num_decisions(::PROTOBUF_NAMESPACE_ID::int32 value) {
3640  _has_bits_[2] |= 0x20000000u;
3641  minimize_with_propagation_num_decisions_ = value;
3642 }
3643 inline void SatParameters::set_minimize_with_propagation_num_decisions(::PROTOBUF_NAMESPACE_ID::int32 value) {
3644  _internal_set_minimize_with_propagation_num_decisions(value);
3645  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimize_with_propagation_num_decisions)
3646 }
3647 
3648 // optional double variable_activity_decay = 15 [default = 0.8];
3649 inline bool SatParameters::_internal_has_variable_activity_decay() const {
3650  bool value = (_has_bits_[1] & 0x00080000u) != 0;
3651  return value;
3652 }
3653 inline bool SatParameters::has_variable_activity_decay() const {
3654  return _internal_has_variable_activity_decay();
3655 }
3656 inline void SatParameters::clear_variable_activity_decay() {
3657  variable_activity_decay_ = 0.8;
3658  _has_bits_[1] &= ~0x00080000u;
3659 }
3660 inline double SatParameters::_internal_variable_activity_decay() const {
3661  return variable_activity_decay_;
3662 }
3663 inline double SatParameters::variable_activity_decay() const {
3664  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.variable_activity_decay)
3665  return _internal_variable_activity_decay();
3666 }
3667 inline void SatParameters::_internal_set_variable_activity_decay(double value) {
3668  _has_bits_[1] |= 0x00080000u;
3669  variable_activity_decay_ = value;
3670 }
3671 inline void SatParameters::set_variable_activity_decay(double value) {
3672  _internal_set_variable_activity_decay(value);
3673  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.variable_activity_decay)
3674 }
3675 
3676 // optional double max_variable_activity_value = 16 [default = 1e+100];
3677 inline bool SatParameters::_internal_has_max_variable_activity_value() const {
3678  bool value = (_has_bits_[1] & 0x00100000u) != 0;
3679  return value;
3680 }
3681 inline bool SatParameters::has_max_variable_activity_value() const {
3682  return _internal_has_max_variable_activity_value();
3683 }
3684 inline void SatParameters::clear_max_variable_activity_value() {
3685  max_variable_activity_value_ = 1e+100;
3686  _has_bits_[1] &= ~0x00100000u;
3687 }
3688 inline double SatParameters::_internal_max_variable_activity_value() const {
3689  return max_variable_activity_value_;
3690 }
3691 inline double SatParameters::max_variable_activity_value() const {
3692  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_variable_activity_value)
3693  return _internal_max_variable_activity_value();
3694 }
3695 inline void SatParameters::_internal_set_max_variable_activity_value(double value) {
3696  _has_bits_[1] |= 0x00100000u;
3697  max_variable_activity_value_ = value;
3698 }
3699 inline void SatParameters::set_max_variable_activity_value(double value) {
3700  _internal_set_max_variable_activity_value(value);
3701  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_variable_activity_value)
3702 }
3703 
3704 // optional double glucose_max_decay = 22 [default = 0.95];
3705 inline bool SatParameters::_internal_has_glucose_max_decay() const {
3706  bool value = (_has_bits_[1] & 0x00800000u) != 0;
3707  return value;
3708 }
3709 inline bool SatParameters::has_glucose_max_decay() const {
3710  return _internal_has_glucose_max_decay();
3711 }
3712 inline void SatParameters::clear_glucose_max_decay() {
3713  glucose_max_decay_ = 0.95;
3714  _has_bits_[1] &= ~0x00800000u;
3715 }
3716 inline double SatParameters::_internal_glucose_max_decay() const {
3717  return glucose_max_decay_;
3718 }
3719 inline double SatParameters::glucose_max_decay() const {
3720  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.glucose_max_decay)
3721  return _internal_glucose_max_decay();
3722 }
3723 inline void SatParameters::_internal_set_glucose_max_decay(double value) {
3724  _has_bits_[1] |= 0x00800000u;
3725  glucose_max_decay_ = value;
3726 }
3727 inline void SatParameters::set_glucose_max_decay(double value) {
3728  _internal_set_glucose_max_decay(value);
3729  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.glucose_max_decay)
3730 }
3731 
3732 // optional double glucose_decay_increment = 23 [default = 0.01];
3733 inline bool SatParameters::_internal_has_glucose_decay_increment() const {
3734  bool value = (_has_bits_[1] & 0x01000000u) != 0;
3735  return value;
3736 }
3737 inline bool SatParameters::has_glucose_decay_increment() const {
3738  return _internal_has_glucose_decay_increment();
3739 }
3740 inline void SatParameters::clear_glucose_decay_increment() {
3741  glucose_decay_increment_ = 0.01;
3742  _has_bits_[1] &= ~0x01000000u;
3743 }
3744 inline double SatParameters::_internal_glucose_decay_increment() const {
3745  return glucose_decay_increment_;
3746 }
3747 inline double SatParameters::glucose_decay_increment() const {
3748  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.glucose_decay_increment)
3749  return _internal_glucose_decay_increment();
3750 }
3751 inline void SatParameters::_internal_set_glucose_decay_increment(double value) {
3752  _has_bits_[1] |= 0x01000000u;
3753  glucose_decay_increment_ = value;
3754 }
3755 inline void SatParameters::set_glucose_decay_increment(double value) {
3756  _internal_set_glucose_decay_increment(value);
3757  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.glucose_decay_increment)
3758 }
3759 
3760 // optional int32 glucose_decay_increment_period = 24 [default = 5000];
3761 inline bool SatParameters::_internal_has_glucose_decay_increment_period() const {
3762  bool value = (_has_bits_[1] & 0x02000000u) != 0;
3763  return value;
3764 }
3765 inline bool SatParameters::has_glucose_decay_increment_period() const {
3766  return _internal_has_glucose_decay_increment_period();
3767 }
3768 inline void SatParameters::clear_glucose_decay_increment_period() {
3769  glucose_decay_increment_period_ = 5000;
3770  _has_bits_[1] &= ~0x02000000u;
3771 }
3772 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_glucose_decay_increment_period() const {
3773  return glucose_decay_increment_period_;
3774 }
3775 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::glucose_decay_increment_period() const {
3776  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.glucose_decay_increment_period)
3777  return _internal_glucose_decay_increment_period();
3778 }
3779 inline void SatParameters::_internal_set_glucose_decay_increment_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
3780  _has_bits_[1] |= 0x02000000u;
3781  glucose_decay_increment_period_ = value;
3782 }
3783 inline void SatParameters::set_glucose_decay_increment_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
3784  _internal_set_glucose_decay_increment_period(value);
3785  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.glucose_decay_increment_period)
3786 }
3787 
3788 // optional double clause_activity_decay = 17 [default = 0.999];
3789 inline bool SatParameters::_internal_has_clause_activity_decay() const {
3790  bool value = (_has_bits_[1] & 0x00200000u) != 0;
3791  return value;
3792 }
3793 inline bool SatParameters::has_clause_activity_decay() const {
3794  return _internal_has_clause_activity_decay();
3795 }
3796 inline void SatParameters::clear_clause_activity_decay() {
3797  clause_activity_decay_ = 0.999;
3798  _has_bits_[1] &= ~0x00200000u;
3799 }
3800 inline double SatParameters::_internal_clause_activity_decay() const {
3801  return clause_activity_decay_;
3802 }
3803 inline double SatParameters::clause_activity_decay() const {
3804  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_activity_decay)
3805  return _internal_clause_activity_decay();
3806 }
3807 inline void SatParameters::_internal_set_clause_activity_decay(double value) {
3808  _has_bits_[1] |= 0x00200000u;
3809  clause_activity_decay_ = value;
3810 }
3811 inline void SatParameters::set_clause_activity_decay(double value) {
3812  _internal_set_clause_activity_decay(value);
3813  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_activity_decay)
3814 }
3815 
3816 // optional double max_clause_activity_value = 18 [default = 1e+20];
3817 inline bool SatParameters::_internal_has_max_clause_activity_value() const {
3818  bool value = (_has_bits_[1] & 0x00400000u) != 0;
3819  return value;
3820 }
3821 inline bool SatParameters::has_max_clause_activity_value() const {
3822  return _internal_has_max_clause_activity_value();
3823 }
3824 inline void SatParameters::clear_max_clause_activity_value() {
3825  max_clause_activity_value_ = 1e+20;
3826  _has_bits_[1] &= ~0x00400000u;
3827 }
3828 inline double SatParameters::_internal_max_clause_activity_value() const {
3829  return max_clause_activity_value_;
3830 }
3831 inline double SatParameters::max_clause_activity_value() const {
3832  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_clause_activity_value)
3833  return _internal_max_clause_activity_value();
3834 }
3835 inline void SatParameters::_internal_set_max_clause_activity_value(double value) {
3836  _has_bits_[1] |= 0x00400000u;
3837  max_clause_activity_value_ = value;
3838 }
3839 inline void SatParameters::set_max_clause_activity_value(double value) {
3840  _internal_set_max_clause_activity_value(value);
3841  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_clause_activity_value)
3842 }
3843 
3844 // repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
3845 inline int SatParameters::_internal_restart_algorithms_size() const {
3846  return restart_algorithms_.size();
3847 }
3848 inline int SatParameters::restart_algorithms_size() const {
3849  return _internal_restart_algorithms_size();
3850 }
3851 inline void SatParameters::clear_restart_algorithms() {
3852  restart_algorithms_.Clear();
3853 }
3854 inline ::operations_research::sat::SatParameters_RestartAlgorithm SatParameters::_internal_restart_algorithms(int index) const {
3855  return static_cast< ::operations_research::sat::SatParameters_RestartAlgorithm >(restart_algorithms_.Get(index));
3856 }
3857 inline ::operations_research::sat::SatParameters_RestartAlgorithm SatParameters::restart_algorithms(int index) const {
3858  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_algorithms)
3859  return _internal_restart_algorithms(index);
3860 }
3861 inline void SatParameters::set_restart_algorithms(int index, ::operations_research::sat::SatParameters_RestartAlgorithm value) {
3862  assert(::operations_research::sat::SatParameters_RestartAlgorithm_IsValid(value));
3863  restart_algorithms_.Set(index, value);
3864  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_algorithms)
3865 }
3866 inline void SatParameters::_internal_add_restart_algorithms(::operations_research::sat::SatParameters_RestartAlgorithm value) {
3867  assert(::operations_research::sat::SatParameters_RestartAlgorithm_IsValid(value));
3868  restart_algorithms_.Add(value);
3869 }
3870 inline void SatParameters::add_restart_algorithms(::operations_research::sat::SatParameters_RestartAlgorithm value) {
3871  // @@protoc_insertion_point(field_add:operations_research.sat.SatParameters.restart_algorithms)
3872  _internal_add_restart_algorithms(value);
3873 }
3874 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
3875 SatParameters::restart_algorithms() const {
3876  // @@protoc_insertion_point(field_list:operations_research.sat.SatParameters.restart_algorithms)
3877  return restart_algorithms_;
3878 }
3879 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
3880 SatParameters::_internal_mutable_restart_algorithms() {
3881  return &restart_algorithms_;
3882 }
3883 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
3884 SatParameters::mutable_restart_algorithms() {
3885  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.SatParameters.restart_algorithms)
3886  return _internal_mutable_restart_algorithms();
3887 }
3888 
3889 // optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
3890 inline bool SatParameters::_internal_has_default_restart_algorithms() const {
3891  bool value = (_has_bits_[0] & 0x00000001u) != 0;
3892  return value;
3893 }
3894 inline bool SatParameters::has_default_restart_algorithms() const {
3895  return _internal_has_default_restart_algorithms();
3896 }
3897 inline void SatParameters::clear_default_restart_algorithms() {
3898  default_restart_algorithms_.ClearToDefault(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), GetArena());
3899  _has_bits_[0] &= ~0x00000001u;
3900 }
3901 inline const std::string& SatParameters::default_restart_algorithms() const {
3902  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.default_restart_algorithms)
3903  return _internal_default_restart_algorithms();
3904 }
3905 inline void SatParameters::set_default_restart_algorithms(const std::string& value) {
3906  _internal_set_default_restart_algorithms(value);
3907  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.default_restart_algorithms)
3908 }
3909 inline std::string* SatParameters::mutable_default_restart_algorithms() {
3910  // @@protoc_insertion_point(field_mutable:operations_research.sat.SatParameters.default_restart_algorithms)
3911  return _internal_mutable_default_restart_algorithms();
3912 }
3913 inline const std::string& SatParameters::_internal_default_restart_algorithms() const {
3914  return default_restart_algorithms_.Get();
3915 }
3916 inline void SatParameters::_internal_set_default_restart_algorithms(const std::string& value) {
3917  _has_bits_[0] |= 0x00000001u;
3918  default_restart_algorithms_.Set(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), value, GetArena());
3919 }
3920 inline void SatParameters::set_default_restart_algorithms(std::string&& value) {
3921  _has_bits_[0] |= 0x00000001u;
3922  default_restart_algorithms_.Set(
3923  &::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), ::std::move(value), GetArena());
3924  // @@protoc_insertion_point(field_set_rvalue:operations_research.sat.SatParameters.default_restart_algorithms)
3925 }
3926 inline void SatParameters::set_default_restart_algorithms(const char* value) {
3927  GOOGLE_DCHECK(value != nullptr);
3928  _has_bits_[0] |= 0x00000001u;
3929  default_restart_algorithms_.Set(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), ::std::string(value),
3930  GetArena());
3931  // @@protoc_insertion_point(field_set_char:operations_research.sat.SatParameters.default_restart_algorithms)
3932 }
3933 inline void SatParameters::set_default_restart_algorithms(const char* value,
3934  size_t size) {
3935  _has_bits_[0] |= 0x00000001u;
3936  default_restart_algorithms_.Set(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), ::std::string(
3937  reinterpret_cast<const char*>(value), size), GetArena());
3938  // @@protoc_insertion_point(field_set_pointer:operations_research.sat.SatParameters.default_restart_algorithms)
3939 }
3940 inline std::string* SatParameters::_internal_mutable_default_restart_algorithms() {
3941  _has_bits_[0] |= 0x00000001u;
3942  return default_restart_algorithms_.Mutable(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), GetArena());
3943 }
3944 inline std::string* SatParameters::release_default_restart_algorithms() {
3945  // @@protoc_insertion_point(field_release:operations_research.sat.SatParameters.default_restart_algorithms)
3946  if (!_internal_has_default_restart_algorithms()) {
3947  return nullptr;
3948  }
3949  _has_bits_[0] &= ~0x00000001u;
3950  return default_restart_algorithms_.ReleaseNonDefault(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), GetArena());
3951 }
3952 inline void SatParameters::set_allocated_default_restart_algorithms(std::string* default_restart_algorithms) {
3953  if (default_restart_algorithms != nullptr) {
3954  _has_bits_[0] |= 0x00000001u;
3955  } else {
3956  _has_bits_[0] &= ~0x00000001u;
3957  }
3958  default_restart_algorithms_.SetAllocated(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), default_restart_algorithms,
3959  GetArena());
3960  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.SatParameters.default_restart_algorithms)
3961 }
3962 
3963 // optional int32 restart_period = 30 [default = 50];
3964 inline bool SatParameters::_internal_has_restart_period() const {
3965  bool value = (_has_bits_[1] & 0x04000000u) != 0;
3966  return value;
3967 }
3968 inline bool SatParameters::has_restart_period() const {
3969  return _internal_has_restart_period();
3970 }
3971 inline void SatParameters::clear_restart_period() {
3972  restart_period_ = 50;
3973  _has_bits_[1] &= ~0x04000000u;
3974 }
3975 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_restart_period() const {
3976  return restart_period_;
3977 }
3978 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::restart_period() const {
3979  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_period)
3980  return _internal_restart_period();
3981 }
3982 inline void SatParameters::_internal_set_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
3983  _has_bits_[1] |= 0x04000000u;
3984  restart_period_ = value;
3985 }
3986 inline void SatParameters::set_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
3987  _internal_set_restart_period(value);
3988  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_period)
3989 }
3990 
3991 // optional int32 restart_running_window_size = 62 [default = 50];
3992 inline bool SatParameters::_internal_has_restart_running_window_size() const {
3993  bool value = (_has_bits_[2] & 0x00001000u) != 0;
3994  return value;
3995 }
3996 inline bool SatParameters::has_restart_running_window_size() const {
3997  return _internal_has_restart_running_window_size();
3998 }
3999 inline void SatParameters::clear_restart_running_window_size() {
4000  restart_running_window_size_ = 50;
4001  _has_bits_[2] &= ~0x00001000u;
4002 }
4003 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_restart_running_window_size() const {
4004  return restart_running_window_size_;
4005 }
4006 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::restart_running_window_size() const {
4007  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_running_window_size)
4008  return _internal_restart_running_window_size();
4009 }
4010 inline void SatParameters::_internal_set_restart_running_window_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
4011  _has_bits_[2] |= 0x00001000u;
4012  restart_running_window_size_ = value;
4013 }
4014 inline void SatParameters::set_restart_running_window_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
4015  _internal_set_restart_running_window_size(value);
4016  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_running_window_size)
4017 }
4018 
4019 // optional double restart_dl_average_ratio = 63 [default = 1];
4020 inline bool SatParameters::_internal_has_restart_dl_average_ratio() const {
4021  bool value = (_has_bits_[2] & 0x00000800u) != 0;
4022  return value;
4023 }
4024 inline bool SatParameters::has_restart_dl_average_ratio() const {
4025  return _internal_has_restart_dl_average_ratio();
4026 }
4027 inline void SatParameters::clear_restart_dl_average_ratio() {
4028  restart_dl_average_ratio_ = 1;
4029  _has_bits_[2] &= ~0x00000800u;
4030 }
4031 inline double SatParameters::_internal_restart_dl_average_ratio() const {
4032  return restart_dl_average_ratio_;
4033 }
4034 inline double SatParameters::restart_dl_average_ratio() const {
4035  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_dl_average_ratio)
4036  return _internal_restart_dl_average_ratio();
4037 }
4038 inline void SatParameters::_internal_set_restart_dl_average_ratio(double value) {
4039  _has_bits_[2] |= 0x00000800u;
4040  restart_dl_average_ratio_ = value;
4041 }
4042 inline void SatParameters::set_restart_dl_average_ratio(double value) {
4043  _internal_set_restart_dl_average_ratio(value);
4044  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_dl_average_ratio)
4045 }
4046 
4047 // optional double restart_lbd_average_ratio = 71 [default = 1];
4048 inline bool SatParameters::_internal_has_restart_lbd_average_ratio() const {
4049  bool value = (_has_bits_[2] & 0x00010000u) != 0;
4050  return value;
4051 }
4052 inline bool SatParameters::has_restart_lbd_average_ratio() const {
4053  return _internal_has_restart_lbd_average_ratio();
4054 }
4055 inline void SatParameters::clear_restart_lbd_average_ratio() {
4056  restart_lbd_average_ratio_ = 1;
4057  _has_bits_[2] &= ~0x00010000u;
4058 }
4059 inline double SatParameters::_internal_restart_lbd_average_ratio() const {
4060  return restart_lbd_average_ratio_;
4061 }
4062 inline double SatParameters::restart_lbd_average_ratio() const {
4063  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_lbd_average_ratio)
4064  return _internal_restart_lbd_average_ratio();
4065 }
4066 inline void SatParameters::_internal_set_restart_lbd_average_ratio(double value) {
4067  _has_bits_[2] |= 0x00010000u;
4068  restart_lbd_average_ratio_ = value;
4069 }
4070 inline void SatParameters::set_restart_lbd_average_ratio(double value) {
4071  _internal_set_restart_lbd_average_ratio(value);
4072  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_lbd_average_ratio)
4073 }
4074 
4075 // optional bool use_blocking_restart = 64 [default = false];
4076 inline bool SatParameters::_internal_has_use_blocking_restart() const {
4077  bool value = (_has_bits_[0] & 0x00000200u) != 0;
4078  return value;
4079 }
4080 inline bool SatParameters::has_use_blocking_restart() const {
4081  return _internal_has_use_blocking_restart();
4082 }
4083 inline void SatParameters::clear_use_blocking_restart() {
4084  use_blocking_restart_ = false;
4085  _has_bits_[0] &= ~0x00000200u;
4086 }
4087 inline bool SatParameters::_internal_use_blocking_restart() const {
4088  return use_blocking_restart_;
4089 }
4090 inline bool SatParameters::use_blocking_restart() const {
4091  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_blocking_restart)
4092  return _internal_use_blocking_restart();
4093 }
4094 inline void SatParameters::_internal_set_use_blocking_restart(bool value) {
4095  _has_bits_[0] |= 0x00000200u;
4096  use_blocking_restart_ = value;
4097 }
4098 inline void SatParameters::set_use_blocking_restart(bool value) {
4099  _internal_set_use_blocking_restart(value);
4100  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_blocking_restart)
4101 }
4102 
4103 // optional int32 blocking_restart_window_size = 65 [default = 5000];
4104 inline bool SatParameters::_internal_has_blocking_restart_window_size() const {
4105  bool value = (_has_bits_[2] & 0x00002000u) != 0;
4106  return value;
4107 }
4108 inline bool SatParameters::has_blocking_restart_window_size() const {
4109  return _internal_has_blocking_restart_window_size();
4110 }
4111 inline void SatParameters::clear_blocking_restart_window_size() {
4112  blocking_restart_window_size_ = 5000;
4113  _has_bits_[2] &= ~0x00002000u;
4114 }
4115 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_blocking_restart_window_size() const {
4116  return blocking_restart_window_size_;
4117 }
4118 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::blocking_restart_window_size() const {
4119  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.blocking_restart_window_size)
4120  return _internal_blocking_restart_window_size();
4121 }
4122 inline void SatParameters::_internal_set_blocking_restart_window_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
4123  _has_bits_[2] |= 0x00002000u;
4124  blocking_restart_window_size_ = value;
4125 }
4126 inline void SatParameters::set_blocking_restart_window_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
4127  _internal_set_blocking_restart_window_size(value);
4128  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.blocking_restart_window_size)
4129 }
4130 
4131 // optional double blocking_restart_multiplier = 66 [default = 1.4];
4132 inline bool SatParameters::_internal_has_blocking_restart_multiplier() const {
4133  bool value = (_has_bits_[2] & 0x00004000u) != 0;
4134  return value;
4135 }
4136 inline bool SatParameters::has_blocking_restart_multiplier() const {
4137  return _internal_has_blocking_restart_multiplier();
4138 }
4139 inline void SatParameters::clear_blocking_restart_multiplier() {
4140  blocking_restart_multiplier_ = 1.4;
4141  _has_bits_[2] &= ~0x00004000u;
4142 }
4143 inline double SatParameters::_internal_blocking_restart_multiplier() const {
4144  return blocking_restart_multiplier_;
4145 }
4146 inline double SatParameters::blocking_restart_multiplier() const {
4147  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.blocking_restart_multiplier)
4148  return _internal_blocking_restart_multiplier();
4149 }
4150 inline void SatParameters::_internal_set_blocking_restart_multiplier(double value) {
4151  _has_bits_[2] |= 0x00004000u;
4152  blocking_restart_multiplier_ = value;
4153 }
4154 inline void SatParameters::set_blocking_restart_multiplier(double value) {
4155  _internal_set_blocking_restart_multiplier(value);
4156  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.blocking_restart_multiplier)
4157 }
4158 
4159 // optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
4160 inline bool SatParameters::_internal_has_num_conflicts_before_strategy_changes() const {
4161  bool value = (_has_bits_[0] & 0x00000800u) != 0;
4162  return value;
4163 }
4164 inline bool SatParameters::has_num_conflicts_before_strategy_changes() const {
4165  return _internal_has_num_conflicts_before_strategy_changes();
4166 }
4167 inline void SatParameters::clear_num_conflicts_before_strategy_changes() {
4168  num_conflicts_before_strategy_changes_ = 0;
4169  _has_bits_[0] &= ~0x00000800u;
4170 }
4171 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_num_conflicts_before_strategy_changes() const {
4172  return num_conflicts_before_strategy_changes_;
4173 }
4174 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::num_conflicts_before_strategy_changes() const {
4175  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.num_conflicts_before_strategy_changes)
4176  return _internal_num_conflicts_before_strategy_changes();
4177 }
4178 inline void SatParameters::_internal_set_num_conflicts_before_strategy_changes(::PROTOBUF_NAMESPACE_ID::int32 value) {
4179  _has_bits_[0] |= 0x00000800u;
4180  num_conflicts_before_strategy_changes_ = value;
4181 }
4182 inline void SatParameters::set_num_conflicts_before_strategy_changes(::PROTOBUF_NAMESPACE_ID::int32 value) {
4183  _internal_set_num_conflicts_before_strategy_changes(value);
4184  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.num_conflicts_before_strategy_changes)
4185 }
4186 
4187 // optional double strategy_change_increase_ratio = 69 [default = 0];
4188 inline bool SatParameters::_internal_has_strategy_change_increase_ratio() const {
4189  bool value = (_has_bits_[0] & 0x00001000u) != 0;
4190  return value;
4191 }
4192 inline bool SatParameters::has_strategy_change_increase_ratio() const {
4193  return _internal_has_strategy_change_increase_ratio();
4194 }
4195 inline void SatParameters::clear_strategy_change_increase_ratio() {
4196  strategy_change_increase_ratio_ = 0;
4197  _has_bits_[0] &= ~0x00001000u;
4198 }
4199 inline double SatParameters::_internal_strategy_change_increase_ratio() const {
4200  return strategy_change_increase_ratio_;
4201 }
4202 inline double SatParameters::strategy_change_increase_ratio() const {
4203  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.strategy_change_increase_ratio)
4204  return _internal_strategy_change_increase_ratio();
4205 }
4206 inline void SatParameters::_internal_set_strategy_change_increase_ratio(double value) {
4207  _has_bits_[0] |= 0x00001000u;
4208  strategy_change_increase_ratio_ = value;
4209 }
4210 inline void SatParameters::set_strategy_change_increase_ratio(double value) {
4211  _internal_set_strategy_change_increase_ratio(value);
4212  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.strategy_change_increase_ratio)
4213 }
4214 
4215 // optional double max_time_in_seconds = 36 [default = inf];
4216 inline bool SatParameters::_internal_has_max_time_in_seconds() const {
4217  bool value = (_has_bits_[1] & 0x20000000u) != 0;
4218  return value;
4219 }
4220 inline bool SatParameters::has_max_time_in_seconds() const {
4221  return _internal_has_max_time_in_seconds();
4222 }
4223 inline void SatParameters::clear_max_time_in_seconds() {
4224  max_time_in_seconds_ = std::numeric_limits<double>::infinity();
4225  _has_bits_[1] &= ~0x20000000u;
4226 }
4227 inline double SatParameters::_internal_max_time_in_seconds() const {
4228  return max_time_in_seconds_;
4229 }
4230 inline double SatParameters::max_time_in_seconds() const {
4231  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_time_in_seconds)
4232  return _internal_max_time_in_seconds();
4233 }
4234 inline void SatParameters::_internal_set_max_time_in_seconds(double value) {
4235  _has_bits_[1] |= 0x20000000u;
4236  max_time_in_seconds_ = value;
4237 }
4238 inline void SatParameters::set_max_time_in_seconds(double value) {
4239  _internal_set_max_time_in_seconds(value);
4240  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_time_in_seconds)
4241 }
4242 
4243 // optional double max_deterministic_time = 67 [default = inf];
4244 inline bool SatParameters::_internal_has_max_deterministic_time() const {
4245  bool value = (_has_bits_[2] & 0x00008000u) != 0;
4246  return value;
4247 }
4248 inline bool SatParameters::has_max_deterministic_time() const {
4249  return _internal_has_max_deterministic_time();
4250 }
4251 inline void SatParameters::clear_max_deterministic_time() {
4252  max_deterministic_time_ = std::numeric_limits<double>::infinity();
4253  _has_bits_[2] &= ~0x00008000u;
4254 }
4255 inline double SatParameters::_internal_max_deterministic_time() const {
4256  return max_deterministic_time_;
4257 }
4258 inline double SatParameters::max_deterministic_time() const {
4259  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_deterministic_time)
4260  return _internal_max_deterministic_time();
4261 }
4262 inline void SatParameters::_internal_set_max_deterministic_time(double value) {
4263  _has_bits_[2] |= 0x00008000u;
4264  max_deterministic_time_ = value;
4265 }
4266 inline void SatParameters::set_max_deterministic_time(double value) {
4267  _internal_set_max_deterministic_time(value);
4268  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_deterministic_time)
4269 }
4270 
4271 // optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
4272 inline bool SatParameters::_internal_has_max_number_of_conflicts() const {
4273  bool value = (_has_bits_[1] & 0x40000000u) != 0;
4274  return value;
4275 }
4276 inline bool SatParameters::has_max_number_of_conflicts() const {
4277  return _internal_has_max_number_of_conflicts();
4278 }
4279 inline void SatParameters::clear_max_number_of_conflicts() {
4280  max_number_of_conflicts_ = PROTOBUF_LONGLONG(9223372036854775807);
4281  _has_bits_[1] &= ~0x40000000u;
4282 }
4283 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::_internal_max_number_of_conflicts() const {
4284  return max_number_of_conflicts_;
4285 }
4286 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::max_number_of_conflicts() const {
4287  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_number_of_conflicts)
4288  return _internal_max_number_of_conflicts();
4289 }
4290 inline void SatParameters::_internal_set_max_number_of_conflicts(::PROTOBUF_NAMESPACE_ID::int64 value) {
4291  _has_bits_[1] |= 0x40000000u;
4292  max_number_of_conflicts_ = value;
4293 }
4294 inline void SatParameters::set_max_number_of_conflicts(::PROTOBUF_NAMESPACE_ID::int64 value) {
4295  _internal_set_max_number_of_conflicts(value);
4296  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_number_of_conflicts)
4297 }
4298 
4299 // optional int64 max_memory_in_mb = 40 [default = 10000];
4300 inline bool SatParameters::_internal_has_max_memory_in_mb() const {
4301  bool value = (_has_bits_[1] & 0x80000000u) != 0;
4302  return value;
4303 }
4304 inline bool SatParameters::has_max_memory_in_mb() const {
4305  return _internal_has_max_memory_in_mb();
4306 }
4307 inline void SatParameters::clear_max_memory_in_mb() {
4308  max_memory_in_mb_ = PROTOBUF_LONGLONG(10000);
4309  _has_bits_[1] &= ~0x80000000u;
4310 }
4311 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::_internal_max_memory_in_mb() const {
4312  return max_memory_in_mb_;
4313 }
4314 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::max_memory_in_mb() const {
4315  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_memory_in_mb)
4316  return _internal_max_memory_in_mb();
4317 }
4318 inline void SatParameters::_internal_set_max_memory_in_mb(::PROTOBUF_NAMESPACE_ID::int64 value) {
4319  _has_bits_[1] |= 0x80000000u;
4320  max_memory_in_mb_ = value;
4321 }
4322 inline void SatParameters::set_max_memory_in_mb(::PROTOBUF_NAMESPACE_ID::int64 value) {
4323  _internal_set_max_memory_in_mb(value);
4324  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_memory_in_mb)
4325 }
4326 
4327 // optional double absolute_gap_limit = 159 [default = 0];
4328 inline bool SatParameters::_internal_has_absolute_gap_limit() const {
4329  bool value = (_has_bits_[1] & 0x00002000u) != 0;
4330  return value;
4331 }
4332 inline bool SatParameters::has_absolute_gap_limit() const {
4333  return _internal_has_absolute_gap_limit();
4334 }
4335 inline void SatParameters::clear_absolute_gap_limit() {
4336  absolute_gap_limit_ = 0;
4337  _has_bits_[1] &= ~0x00002000u;
4338 }
4339 inline double SatParameters::_internal_absolute_gap_limit() const {
4340  return absolute_gap_limit_;
4341 }
4342 inline double SatParameters::absolute_gap_limit() const {
4343  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.absolute_gap_limit)
4344  return _internal_absolute_gap_limit();
4345 }
4346 inline void SatParameters::_internal_set_absolute_gap_limit(double value) {
4347  _has_bits_[1] |= 0x00002000u;
4348  absolute_gap_limit_ = value;
4349 }
4350 inline void SatParameters::set_absolute_gap_limit(double value) {
4351  _internal_set_absolute_gap_limit(value);
4352  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.absolute_gap_limit)
4353 }
4354 
4355 // optional double relative_gap_limit = 160 [default = 0];
4356 inline bool SatParameters::_internal_has_relative_gap_limit() const {
4357  bool value = (_has_bits_[1] & 0x00004000u) != 0;
4358  return value;
4359 }
4360 inline bool SatParameters::has_relative_gap_limit() const {
4361  return _internal_has_relative_gap_limit();
4362 }
4363 inline void SatParameters::clear_relative_gap_limit() {
4364  relative_gap_limit_ = 0;
4365  _has_bits_[1] &= ~0x00004000u;
4366 }
4367 inline double SatParameters::_internal_relative_gap_limit() const {
4368  return relative_gap_limit_;
4369 }
4370 inline double SatParameters::relative_gap_limit() const {
4371  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.relative_gap_limit)
4372  return _internal_relative_gap_limit();
4373 }
4374 inline void SatParameters::_internal_set_relative_gap_limit(double value) {
4375  _has_bits_[1] |= 0x00004000u;
4376  relative_gap_limit_ = value;
4377 }
4378 inline void SatParameters::set_relative_gap_limit(double value) {
4379  _internal_set_relative_gap_limit(value);
4380  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.relative_gap_limit)
4381 }
4382 
4383 // optional bool treat_binary_clauses_separately = 33 [default = true];
4384 inline bool SatParameters::_internal_has_treat_binary_clauses_separately() const {
4385  bool value = (_has_bits_[2] & 0x00000004u) != 0;
4386  return value;
4387 }
4388 inline bool SatParameters::has_treat_binary_clauses_separately() const {
4389  return _internal_has_treat_binary_clauses_separately();
4390 }
4391 inline void SatParameters::clear_treat_binary_clauses_separately() {
4392  treat_binary_clauses_separately_ = true;
4393  _has_bits_[2] &= ~0x00000004u;
4394 }
4395 inline bool SatParameters::_internal_treat_binary_clauses_separately() const {
4396  return treat_binary_clauses_separately_;
4397 }
4398 inline bool SatParameters::treat_binary_clauses_separately() const {
4399  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.treat_binary_clauses_separately)
4400  return _internal_treat_binary_clauses_separately();
4401 }
4402 inline void SatParameters::_internal_set_treat_binary_clauses_separately(bool value) {
4403  _has_bits_[2] |= 0x00000004u;
4404  treat_binary_clauses_separately_ = value;
4405 }
4406 inline void SatParameters::set_treat_binary_clauses_separately(bool value) {
4407  _internal_set_treat_binary_clauses_separately(value);
4408  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.treat_binary_clauses_separately)
4409 }
4410 
4411 // optional int32 random_seed = 31 [default = 1];
4412 inline bool SatParameters::_internal_has_random_seed() const {
4413  bool value = (_has_bits_[1] & 0x08000000u) != 0;
4414  return value;
4415 }
4416 inline bool SatParameters::has_random_seed() const {
4417  return _internal_has_random_seed();
4418 }
4419 inline void SatParameters::clear_random_seed() {
4420  random_seed_ = 1;
4421  _has_bits_[1] &= ~0x08000000u;
4422 }
4423 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_random_seed() const {
4424  return random_seed_;
4425 }
4426 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::random_seed() const {
4427  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.random_seed)
4428  return _internal_random_seed();
4429 }
4430 inline void SatParameters::_internal_set_random_seed(::PROTOBUF_NAMESPACE_ID::int32 value) {
4431  _has_bits_[1] |= 0x08000000u;
4432  random_seed_ = value;
4433 }
4434 inline void SatParameters::set_random_seed(::PROTOBUF_NAMESPACE_ID::int32 value) {
4435  _internal_set_random_seed(value);
4436  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.random_seed)
4437 }
4438 
4439 // optional bool log_search_progress = 41 [default = false];
4440 inline bool SatParameters::_internal_has_log_search_progress() const {
4441  bool value = (_has_bits_[0] & 0x00000400u) != 0;
4442  return value;
4443 }
4444 inline bool SatParameters::has_log_search_progress() const {
4445  return _internal_has_log_search_progress();
4446 }
4447 inline void SatParameters::clear_log_search_progress() {
4448  log_search_progress_ = false;
4449  _has_bits_[0] &= ~0x00000400u;
4450 }
4451 inline bool SatParameters::_internal_log_search_progress() const {
4452  return log_search_progress_;
4453 }
4454 inline bool SatParameters::log_search_progress() const {
4455  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.log_search_progress)
4456  return _internal_log_search_progress();
4457 }
4458 inline void SatParameters::_internal_set_log_search_progress(bool value) {
4459  _has_bits_[0] |= 0x00000400u;
4460  log_search_progress_ = value;
4461 }
4462 inline void SatParameters::set_log_search_progress(bool value) {
4463  _internal_set_log_search_progress(value);
4464  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.log_search_progress)
4465 }
4466 
4467 // optional bool use_pb_resolution = 43 [default = false];
4468 inline bool SatParameters::_internal_has_use_pb_resolution() const {
4469  bool value = (_has_bits_[0] & 0x00800000u) != 0;
4470  return value;
4471 }
4472 inline bool SatParameters::has_use_pb_resolution() const {
4473  return _internal_has_use_pb_resolution();
4474 }
4475 inline void SatParameters::clear_use_pb_resolution() {
4476  use_pb_resolution_ = false;
4477  _has_bits_[0] &= ~0x00800000u;
4478 }
4479 inline bool SatParameters::_internal_use_pb_resolution() const {
4480  return use_pb_resolution_;
4481 }
4482 inline bool SatParameters::use_pb_resolution() const {
4483  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_pb_resolution)
4484  return _internal_use_pb_resolution();
4485 }
4486 inline void SatParameters::_internal_set_use_pb_resolution(bool value) {
4487  _has_bits_[0] |= 0x00800000u;
4488  use_pb_resolution_ = value;
4489 }
4490 inline void SatParameters::set_use_pb_resolution(bool value) {
4491  _internal_set_use_pb_resolution(value);
4492  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_pb_resolution)
4493 }
4494 
4495 // optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
4496 inline bool SatParameters::_internal_has_minimize_reduction_during_pb_resolution() const {
4497  bool value = (_has_bits_[0] & 0x01000000u) != 0;
4498  return value;
4499 }
4500 inline bool SatParameters::has_minimize_reduction_during_pb_resolution() const {
4501  return _internal_has_minimize_reduction_during_pb_resolution();
4502 }
4503 inline void SatParameters::clear_minimize_reduction_during_pb_resolution() {
4504  minimize_reduction_during_pb_resolution_ = false;
4505  _has_bits_[0] &= ~0x01000000u;
4506 }
4507 inline bool SatParameters::_internal_minimize_reduction_during_pb_resolution() const {
4508  return minimize_reduction_during_pb_resolution_;
4509 }
4510 inline bool SatParameters::minimize_reduction_during_pb_resolution() const {
4511  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimize_reduction_during_pb_resolution)
4512  return _internal_minimize_reduction_during_pb_resolution();
4513 }
4514 inline void SatParameters::_internal_set_minimize_reduction_during_pb_resolution(bool value) {
4515  _has_bits_[0] |= 0x01000000u;
4516  minimize_reduction_during_pb_resolution_ = value;
4517 }
4518 inline void SatParameters::set_minimize_reduction_during_pb_resolution(bool value) {
4519  _internal_set_minimize_reduction_during_pb_resolution(value);
4520  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimize_reduction_during_pb_resolution)
4521 }
4522 
4523 // optional bool count_assumption_levels_in_lbd = 49 [default = true];
4524 inline bool SatParameters::_internal_has_count_assumption_levels_in_lbd() const {
4525  bool value = (_has_bits_[2] & 0x00000008u) != 0;
4526  return value;
4527 }
4528 inline bool SatParameters::has_count_assumption_levels_in_lbd() const {
4529  return _internal_has_count_assumption_levels_in_lbd();
4530 }
4531 inline void SatParameters::clear_count_assumption_levels_in_lbd() {
4532  count_assumption_levels_in_lbd_ = true;
4533  _has_bits_[2] &= ~0x00000008u;
4534 }
4535 inline bool SatParameters::_internal_count_assumption_levels_in_lbd() const {
4536  return count_assumption_levels_in_lbd_;
4537 }
4538 inline bool SatParameters::count_assumption_levels_in_lbd() const {
4539  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.count_assumption_levels_in_lbd)
4540  return _internal_count_assumption_levels_in_lbd();
4541 }
4542 inline void SatParameters::_internal_set_count_assumption_levels_in_lbd(bool value) {
4543  _has_bits_[2] |= 0x00000008u;
4544  count_assumption_levels_in_lbd_ = value;
4545 }
4546 inline void SatParameters::set_count_assumption_levels_in_lbd(bool value) {
4547  _internal_set_count_assumption_levels_in_lbd(value);
4548  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.count_assumption_levels_in_lbd)
4549 }
4550 
4551 // optional int32 presolve_bve_threshold = 54 [default = 500];
4552 inline bool SatParameters::_internal_has_presolve_bve_threshold() const {
4553  bool value = (_has_bits_[2] & 0x00000080u) != 0;
4554  return value;
4555 }
4556 inline bool SatParameters::has_presolve_bve_threshold() const {
4557  return _internal_has_presolve_bve_threshold();
4558 }
4559 inline void SatParameters::clear_presolve_bve_threshold() {
4560  presolve_bve_threshold_ = 500;
4561  _has_bits_[2] &= ~0x00000080u;
4562 }
4563 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_presolve_bve_threshold() const {
4564  return presolve_bve_threshold_;
4565 }
4566 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::presolve_bve_threshold() const {
4567  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_bve_threshold)
4568  return _internal_presolve_bve_threshold();
4569 }
4570 inline void SatParameters::_internal_set_presolve_bve_threshold(::PROTOBUF_NAMESPACE_ID::int32 value) {
4571  _has_bits_[2] |= 0x00000080u;
4572  presolve_bve_threshold_ = value;
4573 }
4574 inline void SatParameters::set_presolve_bve_threshold(::PROTOBUF_NAMESPACE_ID::int32 value) {
4575  _internal_set_presolve_bve_threshold(value);
4576  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_bve_threshold)
4577 }
4578 
4579 // optional int32 presolve_bve_clause_weight = 55 [default = 3];
4580 inline bool SatParameters::_internal_has_presolve_bve_clause_weight() const {
4581  bool value = (_has_bits_[2] & 0x00000200u) != 0;
4582  return value;
4583 }
4584 inline bool SatParameters::has_presolve_bve_clause_weight() const {
4585  return _internal_has_presolve_bve_clause_weight();
4586 }
4587 inline void SatParameters::clear_presolve_bve_clause_weight() {
4588  presolve_bve_clause_weight_ = 3;
4589  _has_bits_[2] &= ~0x00000200u;
4590 }
4591 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_presolve_bve_clause_weight() const {
4592  return presolve_bve_clause_weight_;
4593 }
4594 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::presolve_bve_clause_weight() const {
4595  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_bve_clause_weight)
4596  return _internal_presolve_bve_clause_weight();
4597 }
4598 inline void SatParameters::_internal_set_presolve_bve_clause_weight(::PROTOBUF_NAMESPACE_ID::int32 value) {
4599  _has_bits_[2] |= 0x00000200u;
4600  presolve_bve_clause_weight_ = value;
4601 }
4602 inline void SatParameters::set_presolve_bve_clause_weight(::PROTOBUF_NAMESPACE_ID::int32 value) {
4603  _internal_set_presolve_bve_clause_weight(value);
4604  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_bve_clause_weight)
4605 }
4606 
4607 // optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
4608 inline bool SatParameters::_internal_has_presolve_probing_deterministic_time_limit() const {
4609  bool value = (_has_bits_[2] & 0x00000100u) != 0;
4610  return value;
4611 }
4612 inline bool SatParameters::has_presolve_probing_deterministic_time_limit() const {
4613  return _internal_has_presolve_probing_deterministic_time_limit();
4614 }
4615 inline void SatParameters::clear_presolve_probing_deterministic_time_limit() {
4616  presolve_probing_deterministic_time_limit_ = 30;
4617  _has_bits_[2] &= ~0x00000100u;
4618 }
4619 inline double SatParameters::_internal_presolve_probing_deterministic_time_limit() const {
4620  return presolve_probing_deterministic_time_limit_;
4621 }
4622 inline double SatParameters::presolve_probing_deterministic_time_limit() const {
4623  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_probing_deterministic_time_limit)
4624  return _internal_presolve_probing_deterministic_time_limit();
4625 }
4626 inline void SatParameters::_internal_set_presolve_probing_deterministic_time_limit(double value) {
4627  _has_bits_[2] |= 0x00000100u;
4628  presolve_probing_deterministic_time_limit_ = value;
4629 }
4630 inline void SatParameters::set_presolve_probing_deterministic_time_limit(double value) {
4631  _internal_set_presolve_probing_deterministic_time_limit(value);
4632  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_probing_deterministic_time_limit)
4633 }
4634 
4635 // optional bool presolve_blocked_clause = 88 [default = true];
4636 inline bool SatParameters::_internal_has_presolve_blocked_clause() const {
4637  bool value = (_has_bits_[2] & 0x00400000u) != 0;
4638  return value;
4639 }
4640 inline bool SatParameters::has_presolve_blocked_clause() const {
4641  return _internal_has_presolve_blocked_clause();
4642 }
4643 inline void SatParameters::clear_presolve_blocked_clause() {
4644  presolve_blocked_clause_ = true;
4645  _has_bits_[2] &= ~0x00400000u;
4646 }
4647 inline bool SatParameters::_internal_presolve_blocked_clause() const {
4648  return presolve_blocked_clause_;
4649 }
4650 inline bool SatParameters::presolve_blocked_clause() const {
4651  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_blocked_clause)
4652  return _internal_presolve_blocked_clause();
4653 }
4654 inline void SatParameters::_internal_set_presolve_blocked_clause(bool value) {
4655  _has_bits_[2] |= 0x00400000u;
4656  presolve_blocked_clause_ = value;
4657 }
4658 inline void SatParameters::set_presolve_blocked_clause(bool value) {
4659  _internal_set_presolve_blocked_clause(value);
4660  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_blocked_clause)
4661 }
4662 
4663 // optional bool presolve_use_bva = 72 [default = true];
4664 inline bool SatParameters::_internal_has_presolve_use_bva() const {
4665  bool value = (_has_bits_[2] & 0x00800000u) != 0;
4666  return value;
4667 }
4668 inline bool SatParameters::has_presolve_use_bva() const {
4669  return _internal_has_presolve_use_bva();
4670 }
4671 inline void SatParameters::clear_presolve_use_bva() {
4672  presolve_use_bva_ = true;
4673  _has_bits_[2] &= ~0x00800000u;
4674 }
4675 inline bool SatParameters::_internal_presolve_use_bva() const {
4676  return presolve_use_bva_;
4677 }
4678 inline bool SatParameters::presolve_use_bva() const {
4679  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_use_bva)
4680  return _internal_presolve_use_bva();
4681 }
4682 inline void SatParameters::_internal_set_presolve_use_bva(bool value) {
4683  _has_bits_[2] |= 0x00800000u;
4684  presolve_use_bva_ = value;
4685 }
4686 inline void SatParameters::set_presolve_use_bva(bool value) {
4687  _internal_set_presolve_use_bva(value);
4688  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_use_bva)
4689 }
4690 
4691 // optional int32 presolve_bva_threshold = 73 [default = 1];
4692 inline bool SatParameters::_internal_has_presolve_bva_threshold() const {
4693  bool value = (_has_bits_[2] & 0x00020000u) != 0;
4694  return value;
4695 }
4696 inline bool SatParameters::has_presolve_bva_threshold() const {
4697  return _internal_has_presolve_bva_threshold();
4698 }
4699 inline void SatParameters::clear_presolve_bva_threshold() {
4700  presolve_bva_threshold_ = 1;
4701  _has_bits_[2] &= ~0x00020000u;
4702 }
4703 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_presolve_bva_threshold() const {
4704  return presolve_bva_threshold_;
4705 }
4706 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::presolve_bva_threshold() const {
4707  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_bva_threshold)
4708  return _internal_presolve_bva_threshold();
4709 }
4710 inline void SatParameters::_internal_set_presolve_bva_threshold(::PROTOBUF_NAMESPACE_ID::int32 value) {
4711  _has_bits_[2] |= 0x00020000u;
4712  presolve_bva_threshold_ = value;
4713 }
4714 inline void SatParameters::set_presolve_bva_threshold(::PROTOBUF_NAMESPACE_ID::int32 value) {
4715  _internal_set_presolve_bva_threshold(value);
4716  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_bva_threshold)
4717 }
4718 
4719 // optional int32 max_presolve_iterations = 138 [default = 3];
4720 inline bool SatParameters::_internal_has_max_presolve_iterations() const {
4721  bool value = (_has_bits_[4] & 0x00000002u) != 0;
4722  return value;
4723 }
4724 inline bool SatParameters::has_max_presolve_iterations() const {
4725  return _internal_has_max_presolve_iterations();
4726 }
4727 inline void SatParameters::clear_max_presolve_iterations() {
4728  max_presolve_iterations_ = 3;
4729  _has_bits_[4] &= ~0x00000002u;
4730 }
4731 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_presolve_iterations() const {
4732  return max_presolve_iterations_;
4733 }
4734 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_presolve_iterations() const {
4735  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_presolve_iterations)
4736  return _internal_max_presolve_iterations();
4737 }
4738 inline void SatParameters::_internal_set_max_presolve_iterations(::PROTOBUF_NAMESPACE_ID::int32 value) {
4739  _has_bits_[4] |= 0x00000002u;
4740  max_presolve_iterations_ = value;
4741 }
4742 inline void SatParameters::set_max_presolve_iterations(::PROTOBUF_NAMESPACE_ID::int32 value) {
4743  _internal_set_max_presolve_iterations(value);
4744  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_presolve_iterations)
4745 }
4746 
4747 // optional bool cp_model_presolve = 86 [default = true];
4748 inline bool SatParameters::_internal_has_cp_model_presolve() const {
4749  bool value = (_has_bits_[2] & 0x01000000u) != 0;
4750  return value;
4751 }
4752 inline bool SatParameters::has_cp_model_presolve() const {
4753  return _internal_has_cp_model_presolve();
4754 }
4755 inline void SatParameters::clear_cp_model_presolve() {
4756  cp_model_presolve_ = true;
4757  _has_bits_[2] &= ~0x01000000u;
4758 }
4759 inline bool SatParameters::_internal_cp_model_presolve() const {
4760  return cp_model_presolve_;
4761 }
4762 inline bool SatParameters::cp_model_presolve() const {
4763  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cp_model_presolve)
4764  return _internal_cp_model_presolve();
4765 }
4766 inline void SatParameters::_internal_set_cp_model_presolve(bool value) {
4767  _has_bits_[2] |= 0x01000000u;
4768  cp_model_presolve_ = value;
4769 }
4770 inline void SatParameters::set_cp_model_presolve(bool value) {
4771  _internal_set_cp_model_presolve(value);
4772  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_presolve)
4773 }
4774 
4775 // optional bool cp_model_postsolve_with_full_solver = 162 [default = false];
4776 inline bool SatParameters::_internal_has_cp_model_postsolve_with_full_solver() const {
4777  bool value = (_has_bits_[0] & 0x02000000u) != 0;
4778  return value;
4779 }
4780 inline bool SatParameters::has_cp_model_postsolve_with_full_solver() const {
4781  return _internal_has_cp_model_postsolve_with_full_solver();
4782 }
4783 inline void SatParameters::clear_cp_model_postsolve_with_full_solver() {
4784  cp_model_postsolve_with_full_solver_ = false;
4785  _has_bits_[0] &= ~0x02000000u;
4786 }
4787 inline bool SatParameters::_internal_cp_model_postsolve_with_full_solver() const {
4788  return cp_model_postsolve_with_full_solver_;
4789 }
4790 inline bool SatParameters::cp_model_postsolve_with_full_solver() const {
4791  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cp_model_postsolve_with_full_solver)
4792  return _internal_cp_model_postsolve_with_full_solver();
4793 }
4794 inline void SatParameters::_internal_set_cp_model_postsolve_with_full_solver(bool value) {
4795  _has_bits_[0] |= 0x02000000u;
4796  cp_model_postsolve_with_full_solver_ = value;
4797 }
4798 inline void SatParameters::set_cp_model_postsolve_with_full_solver(bool value) {
4799  _internal_set_cp_model_postsolve_with_full_solver(value);
4800  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_postsolve_with_full_solver)
4801 }
4802 
4803 // optional int32 cp_model_max_num_presolve_operations = 151 [default = 0];
4804 inline bool SatParameters::_internal_has_cp_model_max_num_presolve_operations() const {
4805  bool value = (_has_bits_[1] & 0x00001000u) != 0;
4806  return value;
4807 }
4808 inline bool SatParameters::has_cp_model_max_num_presolve_operations() const {
4809  return _internal_has_cp_model_max_num_presolve_operations();
4810 }
4811 inline void SatParameters::clear_cp_model_max_num_presolve_operations() {
4812  cp_model_max_num_presolve_operations_ = 0;
4813  _has_bits_[1] &= ~0x00001000u;
4814 }
4815 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_cp_model_max_num_presolve_operations() const {
4816  return cp_model_max_num_presolve_operations_;
4817 }
4818 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::cp_model_max_num_presolve_operations() const {
4819  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cp_model_max_num_presolve_operations)
4820  return _internal_cp_model_max_num_presolve_operations();
4821 }
4822 inline void SatParameters::_internal_set_cp_model_max_num_presolve_operations(::PROTOBUF_NAMESPACE_ID::int32 value) {
4823  _has_bits_[1] |= 0x00001000u;
4824  cp_model_max_num_presolve_operations_ = value;
4825 }
4826 inline void SatParameters::set_cp_model_max_num_presolve_operations(::PROTOBUF_NAMESPACE_ID::int32 value) {
4827  _internal_set_cp_model_max_num_presolve_operations(value);
4828  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_max_num_presolve_operations)
4829 }
4830 
4831 // optional int32 cp_model_probing_level = 110 [default = 2];
4832 inline bool SatParameters::_internal_has_cp_model_probing_level() const {
4833  bool value = (_has_bits_[3] & 0x00000020u) != 0;
4834  return value;
4835 }
4836 inline bool SatParameters::has_cp_model_probing_level() const {
4837  return _internal_has_cp_model_probing_level();
4838 }
4839 inline void SatParameters::clear_cp_model_probing_level() {
4840  cp_model_probing_level_ = 2;
4841  _has_bits_[3] &= ~0x00000020u;
4842 }
4843 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_cp_model_probing_level() const {
4844  return cp_model_probing_level_;
4845 }
4846 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::cp_model_probing_level() const {
4847  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cp_model_probing_level)
4848  return _internal_cp_model_probing_level();
4849 }
4850 inline void SatParameters::_internal_set_cp_model_probing_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
4851  _has_bits_[3] |= 0x00000020u;
4852  cp_model_probing_level_ = value;
4853 }
4854 inline void SatParameters::set_cp_model_probing_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
4855  _internal_set_cp_model_probing_level(value);
4856  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_probing_level)
4857 }
4858 
4859 // optional bool cp_model_use_sat_presolve = 93 [default = true];
4860 inline bool SatParameters::_internal_has_cp_model_use_sat_presolve() const {
4861  bool value = (_has_bits_[2] & 0x02000000u) != 0;
4862  return value;
4863 }
4864 inline bool SatParameters::has_cp_model_use_sat_presolve() const {
4865  return _internal_has_cp_model_use_sat_presolve();
4866 }
4867 inline void SatParameters::clear_cp_model_use_sat_presolve() {
4868  cp_model_use_sat_presolve_ = true;
4869  _has_bits_[2] &= ~0x02000000u;
4870 }
4871 inline bool SatParameters::_internal_cp_model_use_sat_presolve() const {
4872  return cp_model_use_sat_presolve_;
4873 }
4874 inline bool SatParameters::cp_model_use_sat_presolve() const {
4875  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cp_model_use_sat_presolve)
4876  return _internal_cp_model_use_sat_presolve();
4877 }
4878 inline void SatParameters::_internal_set_cp_model_use_sat_presolve(bool value) {
4879  _has_bits_[2] |= 0x02000000u;
4880  cp_model_use_sat_presolve_ = value;
4881 }
4882 inline void SatParameters::set_cp_model_use_sat_presolve(bool value) {
4883  _internal_set_cp_model_use_sat_presolve(value);
4884  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_use_sat_presolve)
4885 }
4886 
4887 // optional bool use_sat_inprocessing = 163 [default = false];
4888 inline bool SatParameters::_internal_has_use_sat_inprocessing() const {
4889  bool value = (_has_bits_[0] & 0x04000000u) != 0;
4890  return value;
4891 }
4892 inline bool SatParameters::has_use_sat_inprocessing() const {
4893  return _internal_has_use_sat_inprocessing();
4894 }
4895 inline void SatParameters::clear_use_sat_inprocessing() {
4896  use_sat_inprocessing_ = false;
4897  _has_bits_[0] &= ~0x04000000u;
4898 }
4899 inline bool SatParameters::_internal_use_sat_inprocessing() const {
4900  return use_sat_inprocessing_;
4901 }
4902 inline bool SatParameters::use_sat_inprocessing() const {
4903  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_sat_inprocessing)
4904  return _internal_use_sat_inprocessing();
4905 }
4906 inline void SatParameters::_internal_set_use_sat_inprocessing(bool value) {
4907  _has_bits_[0] |= 0x04000000u;
4908  use_sat_inprocessing_ = value;
4909 }
4910 inline void SatParameters::set_use_sat_inprocessing(bool value) {
4911  _internal_set_use_sat_inprocessing(value);
4912  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_sat_inprocessing)
4913 }
4914 
4915 // optional bool expand_element_constraints = 140 [default = true];
4916 inline bool SatParameters::_internal_has_expand_element_constraints() const {
4917  bool value = (_has_bits_[3] & 0x00010000u) != 0;
4918  return value;
4919 }
4920 inline bool SatParameters::has_expand_element_constraints() const {
4921  return _internal_has_expand_element_constraints();
4922 }
4923 inline void SatParameters::clear_expand_element_constraints() {
4924  expand_element_constraints_ = true;
4925  _has_bits_[3] &= ~0x00010000u;
4926 }
4927 inline bool SatParameters::_internal_expand_element_constraints() const {
4928  return expand_element_constraints_;
4929 }
4930 inline bool SatParameters::expand_element_constraints() const {
4931  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.expand_element_constraints)
4932  return _internal_expand_element_constraints();
4933 }
4934 inline void SatParameters::_internal_set_expand_element_constraints(bool value) {
4935  _has_bits_[3] |= 0x00010000u;
4936  expand_element_constraints_ = value;
4937 }
4938 inline void SatParameters::set_expand_element_constraints(bool value) {
4939  _internal_set_expand_element_constraints(value);
4940  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.expand_element_constraints)
4941 }
4942 
4943 // optional bool expand_automaton_constraints = 143 [default = true];
4944 inline bool SatParameters::_internal_has_expand_automaton_constraints() const {
4945  bool value = (_has_bits_[3] & 0x00020000u) != 0;
4946  return value;
4947 }
4948 inline bool SatParameters::has_expand_automaton_constraints() const {
4949  return _internal_has_expand_automaton_constraints();
4950 }
4951 inline void SatParameters::clear_expand_automaton_constraints() {
4952  expand_automaton_constraints_ = true;
4953  _has_bits_[3] &= ~0x00020000u;
4954 }
4955 inline bool SatParameters::_internal_expand_automaton_constraints() const {
4956  return expand_automaton_constraints_;
4957 }
4958 inline bool SatParameters::expand_automaton_constraints() const {
4959  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.expand_automaton_constraints)
4960  return _internal_expand_automaton_constraints();
4961 }
4962 inline void SatParameters::_internal_set_expand_automaton_constraints(bool value) {
4963  _has_bits_[3] |= 0x00020000u;
4964  expand_automaton_constraints_ = value;
4965 }
4966 inline void SatParameters::set_expand_automaton_constraints(bool value) {
4967  _internal_set_expand_automaton_constraints(value);
4968  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.expand_automaton_constraints)
4969 }
4970 
4971 // optional bool expand_table_constraints = 158 [default = true];
4972 inline bool SatParameters::_internal_has_expand_table_constraints() const {
4973  bool value = (_has_bits_[3] & 0x00040000u) != 0;
4974  return value;
4975 }
4976 inline bool SatParameters::has_expand_table_constraints() const {
4977  return _internal_has_expand_table_constraints();
4978 }
4979 inline void SatParameters::clear_expand_table_constraints() {
4980  expand_table_constraints_ = true;
4981  _has_bits_[3] &= ~0x00040000u;
4982 }
4983 inline bool SatParameters::_internal_expand_table_constraints() const {
4984  return expand_table_constraints_;
4985 }
4986 inline bool SatParameters::expand_table_constraints() const {
4987  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.expand_table_constraints)
4988  return _internal_expand_table_constraints();
4989 }
4990 inline void SatParameters::_internal_set_expand_table_constraints(bool value) {
4991  _has_bits_[3] |= 0x00040000u;
4992  expand_table_constraints_ = value;
4993 }
4994 inline void SatParameters::set_expand_table_constraints(bool value) {
4995  _internal_set_expand_table_constraints(value);
4996  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.expand_table_constraints)
4997 }
4998 
4999 // optional double merge_no_overlap_work_limit = 145 [default = 1000000000000];
5000 inline bool SatParameters::_internal_has_merge_no_overlap_work_limit() const {
5001  bool value = (_has_bits_[4] & 0x00000004u) != 0;
5002  return value;
5003 }
5004 inline bool SatParameters::has_merge_no_overlap_work_limit() const {
5005  return _internal_has_merge_no_overlap_work_limit();
5006 }
5007 inline void SatParameters::clear_merge_no_overlap_work_limit() {
5008  merge_no_overlap_work_limit_ = 1000000000000;
5009  _has_bits_[4] &= ~0x00000004u;
5010 }
5011 inline double SatParameters::_internal_merge_no_overlap_work_limit() const {
5012  return merge_no_overlap_work_limit_;
5013 }
5014 inline double SatParameters::merge_no_overlap_work_limit() const {
5015  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.merge_no_overlap_work_limit)
5016  return _internal_merge_no_overlap_work_limit();
5017 }
5018 inline void SatParameters::_internal_set_merge_no_overlap_work_limit(double value) {
5019  _has_bits_[4] |= 0x00000004u;
5020  merge_no_overlap_work_limit_ = value;
5021 }
5022 inline void SatParameters::set_merge_no_overlap_work_limit(double value) {
5023  _internal_set_merge_no_overlap_work_limit(value);
5024  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.merge_no_overlap_work_limit)
5025 }
5026 
5027 // optional double merge_at_most_one_work_limit = 146 [default = 100000000];
5028 inline bool SatParameters::_internal_has_merge_at_most_one_work_limit() const {
5029  bool value = (_has_bits_[4] & 0x00000008u) != 0;
5030  return value;
5031 }
5032 inline bool SatParameters::has_merge_at_most_one_work_limit() const {
5033  return _internal_has_merge_at_most_one_work_limit();
5034 }
5035 inline void SatParameters::clear_merge_at_most_one_work_limit() {
5036  merge_at_most_one_work_limit_ = 100000000;
5037  _has_bits_[4] &= ~0x00000008u;
5038 }
5039 inline double SatParameters::_internal_merge_at_most_one_work_limit() const {
5040  return merge_at_most_one_work_limit_;
5041 }
5042 inline double SatParameters::merge_at_most_one_work_limit() const {
5043  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.merge_at_most_one_work_limit)
5044  return _internal_merge_at_most_one_work_limit();
5045 }
5046 inline void SatParameters::_internal_set_merge_at_most_one_work_limit(double value) {
5047  _has_bits_[4] |= 0x00000008u;
5048  merge_at_most_one_work_limit_ = value;
5049 }
5050 inline void SatParameters::set_merge_at_most_one_work_limit(double value) {
5051  _internal_set_merge_at_most_one_work_limit(value);
5052  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.merge_at_most_one_work_limit)
5053 }
5054 
5055 // optional int32 presolve_substitution_level = 147 [default = 1];
5056 inline bool SatParameters::_internal_has_presolve_substitution_level() const {
5057  bool value = (_has_bits_[4] & 0x00000010u) != 0;
5058  return value;
5059 }
5060 inline bool SatParameters::has_presolve_substitution_level() const {
5061  return _internal_has_presolve_substitution_level();
5062 }
5063 inline void SatParameters::clear_presolve_substitution_level() {
5064  presolve_substitution_level_ = 1;
5065  _has_bits_[4] &= ~0x00000010u;
5066 }
5067 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_presolve_substitution_level() const {
5068  return presolve_substitution_level_;
5069 }
5070 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::presolve_substitution_level() const {
5071  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_substitution_level)
5072  return _internal_presolve_substitution_level();
5073 }
5074 inline void SatParameters::_internal_set_presolve_substitution_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
5075  _has_bits_[4] |= 0x00000010u;
5076  presolve_substitution_level_ = value;
5077 }
5078 inline void SatParameters::set_presolve_substitution_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
5079  _internal_set_presolve_substitution_level(value);
5080  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_substitution_level)
5081 }
5082 
5083 // optional bool use_optimization_hints = 35 [default = true];
5084 inline bool SatParameters::_internal_has_use_optimization_hints() const {
5085  bool value = (_has_bits_[3] & 0x00080000u) != 0;
5086  return value;
5087 }
5088 inline bool SatParameters::has_use_optimization_hints() const {
5089  return _internal_has_use_optimization_hints();
5090 }
5091 inline void SatParameters::clear_use_optimization_hints() {
5092  use_optimization_hints_ = true;
5093  _has_bits_[3] &= ~0x00080000u;
5094 }
5095 inline bool SatParameters::_internal_use_optimization_hints() const {
5096  return use_optimization_hints_;
5097 }
5098 inline bool SatParameters::use_optimization_hints() const {
5099  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_optimization_hints)
5100  return _internal_use_optimization_hints();
5101 }
5102 inline void SatParameters::_internal_set_use_optimization_hints(bool value) {
5103  _has_bits_[3] |= 0x00080000u;
5104  use_optimization_hints_ = value;
5105 }
5106 inline void SatParameters::set_use_optimization_hints(bool value) {
5107  _internal_set_use_optimization_hints(value);
5108  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_optimization_hints)
5109 }
5110 
5111 // optional bool minimize_core = 50 [default = true];
5112 inline bool SatParameters::_internal_has_minimize_core() const {
5113  bool value = (_has_bits_[2] & 0x00040000u) != 0;
5114  return value;
5115 }
5116 inline bool SatParameters::has_minimize_core() const {
5117  return _internal_has_minimize_core();
5118 }
5119 inline void SatParameters::clear_minimize_core() {
5120  minimize_core_ = true;
5121  _has_bits_[2] &= ~0x00040000u;
5122 }
5123 inline bool SatParameters::_internal_minimize_core() const {
5124  return minimize_core_;
5125 }
5126 inline bool SatParameters::minimize_core() const {
5127  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimize_core)
5128  return _internal_minimize_core();
5129 }
5130 inline void SatParameters::_internal_set_minimize_core(bool value) {
5131  _has_bits_[2] |= 0x00040000u;
5132  minimize_core_ = value;
5133 }
5134 inline void SatParameters::set_minimize_core(bool value) {
5135  _internal_set_minimize_core(value);
5136  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimize_core)
5137 }
5138 
5139 // optional bool find_multiple_cores = 84 [default = true];
5140 inline bool SatParameters::_internal_has_find_multiple_cores() const {
5141  bool value = (_has_bits_[2] & 0x00080000u) != 0;
5142  return value;
5143 }
5144 inline bool SatParameters::has_find_multiple_cores() const {
5145  return _internal_has_find_multiple_cores();
5146 }
5147 inline void SatParameters::clear_find_multiple_cores() {
5148  find_multiple_cores_ = true;
5149  _has_bits_[2] &= ~0x00080000u;
5150 }
5151 inline bool SatParameters::_internal_find_multiple_cores() const {
5152  return find_multiple_cores_;
5153 }
5154 inline bool SatParameters::find_multiple_cores() const {
5155  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.find_multiple_cores)
5156  return _internal_find_multiple_cores();
5157 }
5158 inline void SatParameters::_internal_set_find_multiple_cores(bool value) {
5159  _has_bits_[2] |= 0x00080000u;
5160  find_multiple_cores_ = value;
5161 }
5162 inline void SatParameters::set_find_multiple_cores(bool value) {
5163  _internal_set_find_multiple_cores(value);
5164  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.find_multiple_cores)
5165 }
5166 
5167 // optional bool cover_optimization = 89 [default = true];
5168 inline bool SatParameters::_internal_has_cover_optimization() const {
5169  bool value = (_has_bits_[2] & 0x00100000u) != 0;
5170  return value;
5171 }
5172 inline bool SatParameters::has_cover_optimization() const {
5173  return _internal_has_cover_optimization();
5174 }
5175 inline void SatParameters::clear_cover_optimization() {
5176  cover_optimization_ = true;
5177  _has_bits_[2] &= ~0x00100000u;
5178 }
5179 inline bool SatParameters::_internal_cover_optimization() const {
5180  return cover_optimization_;
5181 }
5182 inline bool SatParameters::cover_optimization() const {
5183  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cover_optimization)
5184  return _internal_cover_optimization();
5185 }
5186 inline void SatParameters::_internal_set_cover_optimization(bool value) {
5187  _has_bits_[2] |= 0x00100000u;
5188  cover_optimization_ = value;
5189 }
5190 inline void SatParameters::set_cover_optimization(bool value) {
5191  _internal_set_cover_optimization(value);
5192  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cover_optimization)
5193 }
5194 
5195 // optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
5196 inline bool SatParameters::_internal_has_max_sat_assumption_order() const {
5197  bool value = (_has_bits_[0] & 0x00000004u) != 0;
5198  return value;
5199 }
5200 inline bool SatParameters::has_max_sat_assumption_order() const {
5201  return _internal_has_max_sat_assumption_order();
5202 }
5203 inline void SatParameters::clear_max_sat_assumption_order() {
5204  max_sat_assumption_order_ = 0;
5205  _has_bits_[0] &= ~0x00000004u;
5206 }
5207 inline ::operations_research::sat::SatParameters_MaxSatAssumptionOrder SatParameters::_internal_max_sat_assumption_order() const {
5208  return static_cast< ::operations_research::sat::SatParameters_MaxSatAssumptionOrder >(max_sat_assumption_order_);
5209 }
5210 inline ::operations_research::sat::SatParameters_MaxSatAssumptionOrder SatParameters::max_sat_assumption_order() const {
5211  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_sat_assumption_order)
5212  return _internal_max_sat_assumption_order();
5213 }
5214 inline void SatParameters::_internal_set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value) {
5215  assert(::operations_research::sat::SatParameters_MaxSatAssumptionOrder_IsValid(value));
5216  _has_bits_[0] |= 0x00000004u;
5217  max_sat_assumption_order_ = value;
5218 }
5219 inline void SatParameters::set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value) {
5220  _internal_set_max_sat_assumption_order(value);
5221  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_sat_assumption_order)
5222 }
5223 
5224 // optional bool max_sat_reverse_assumption_order = 52 [default = false];
5225 inline bool SatParameters::_internal_has_max_sat_reverse_assumption_order() const {
5226  bool value = (_has_bits_[0] & 0x00004000u) != 0;
5227  return value;
5228 }
5229 inline bool SatParameters::has_max_sat_reverse_assumption_order() const {
5230  return _internal_has_max_sat_reverse_assumption_order();
5231 }
5232 inline void SatParameters::clear_max_sat_reverse_assumption_order() {
5233  max_sat_reverse_assumption_order_ = false;
5234  _has_bits_[0] &= ~0x00004000u;
5235 }
5236 inline bool SatParameters::_internal_max_sat_reverse_assumption_order() const {
5237  return max_sat_reverse_assumption_order_;
5238 }
5239 inline bool SatParameters::max_sat_reverse_assumption_order() const {
5240  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_sat_reverse_assumption_order)
5241  return _internal_max_sat_reverse_assumption_order();
5242 }
5243 inline void SatParameters::_internal_set_max_sat_reverse_assumption_order(bool value) {
5244  _has_bits_[0] |= 0x00004000u;
5245  max_sat_reverse_assumption_order_ = value;
5246 }
5247 inline void SatParameters::set_max_sat_reverse_assumption_order(bool value) {
5248  _internal_set_max_sat_reverse_assumption_order(value);
5249  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_sat_reverse_assumption_order)
5250 }
5251 
5252 // optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
5253 inline bool SatParameters::_internal_has_max_sat_stratification() const {
5254  bool value = (_has_bits_[2] & 0x00000040u) != 0;
5255  return value;
5256 }
5257 inline bool SatParameters::has_max_sat_stratification() const {
5258  return _internal_has_max_sat_stratification();
5259 }
5260 inline void SatParameters::clear_max_sat_stratification() {
5261  max_sat_stratification_ = 1;
5262  _has_bits_[2] &= ~0x00000040u;
5263 }
5264 inline ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm SatParameters::_internal_max_sat_stratification() const {
5265  return static_cast< ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm >(max_sat_stratification_);
5266 }
5267 inline ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm SatParameters::max_sat_stratification() const {
5268  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_sat_stratification)
5269  return _internal_max_sat_stratification();
5270 }
5271 inline void SatParameters::_internal_set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value) {
5272  assert(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_IsValid(value));
5273  _has_bits_[2] |= 0x00000040u;
5274  max_sat_stratification_ = value;
5275 }
5276 inline void SatParameters::set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value) {
5277  _internal_set_max_sat_stratification(value);
5278  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_sat_stratification)
5279 }
5280 
5281 // optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
5282 inline bool SatParameters::_internal_has_use_precedences_in_disjunctive_constraint() const {
5283  bool value = (_has_bits_[2] & 0x00200000u) != 0;
5284  return value;
5285 }
5286 inline bool SatParameters::has_use_precedences_in_disjunctive_constraint() const {
5287  return _internal_has_use_precedences_in_disjunctive_constraint();
5288 }
5289 inline void SatParameters::clear_use_precedences_in_disjunctive_constraint() {
5290  use_precedences_in_disjunctive_constraint_ = true;
5291  _has_bits_[2] &= ~0x00200000u;
5292 }
5293 inline bool SatParameters::_internal_use_precedences_in_disjunctive_constraint() const {
5294  return use_precedences_in_disjunctive_constraint_;
5295 }
5296 inline bool SatParameters::use_precedences_in_disjunctive_constraint() const {
5297  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_precedences_in_disjunctive_constraint)
5298  return _internal_use_precedences_in_disjunctive_constraint();
5299 }
5300 inline void SatParameters::_internal_set_use_precedences_in_disjunctive_constraint(bool value) {
5301  _has_bits_[2] |= 0x00200000u;
5302  use_precedences_in_disjunctive_constraint_ = value;
5303 }
5304 inline void SatParameters::set_use_precedences_in_disjunctive_constraint(bool value) {
5305  _internal_set_use_precedences_in_disjunctive_constraint(value);
5306  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_precedences_in_disjunctive_constraint)
5307 }
5308 
5309 // optional bool use_overload_checker_in_cumulative_constraint = 78 [default = false];
5310 inline bool SatParameters::_internal_has_use_overload_checker_in_cumulative_constraint() const {
5311  bool value = (_has_bits_[0] & 0x00008000u) != 0;
5312  return value;
5313 }
5314 inline bool SatParameters::has_use_overload_checker_in_cumulative_constraint() const {
5315  return _internal_has_use_overload_checker_in_cumulative_constraint();
5316 }
5317 inline void SatParameters::clear_use_overload_checker_in_cumulative_constraint() {
5318  use_overload_checker_in_cumulative_constraint_ = false;
5319  _has_bits_[0] &= ~0x00008000u;
5320 }
5321 inline bool SatParameters::_internal_use_overload_checker_in_cumulative_constraint() const {
5322  return use_overload_checker_in_cumulative_constraint_;
5323 }
5324 inline bool SatParameters::use_overload_checker_in_cumulative_constraint() const {
5325  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_overload_checker_in_cumulative_constraint)
5326  return _internal_use_overload_checker_in_cumulative_constraint();
5327 }
5328 inline void SatParameters::_internal_set_use_overload_checker_in_cumulative_constraint(bool value) {
5329  _has_bits_[0] |= 0x00008000u;
5330  use_overload_checker_in_cumulative_constraint_ = value;
5331 }
5332 inline void SatParameters::set_use_overload_checker_in_cumulative_constraint(bool value) {
5333  _internal_set_use_overload_checker_in_cumulative_constraint(value);
5334  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_overload_checker_in_cumulative_constraint)
5335 }
5336 
5337 // optional bool use_timetable_edge_finding_in_cumulative_constraint = 79 [default = false];
5338 inline bool SatParameters::_internal_has_use_timetable_edge_finding_in_cumulative_constraint() const {
5339  bool value = (_has_bits_[0] & 0x00010000u) != 0;
5340  return value;
5341 }
5342 inline bool SatParameters::has_use_timetable_edge_finding_in_cumulative_constraint() const {
5343  return _internal_has_use_timetable_edge_finding_in_cumulative_constraint();
5344 }
5345 inline void SatParameters::clear_use_timetable_edge_finding_in_cumulative_constraint() {
5346  use_timetable_edge_finding_in_cumulative_constraint_ = false;
5347  _has_bits_[0] &= ~0x00010000u;
5348 }
5349 inline bool SatParameters::_internal_use_timetable_edge_finding_in_cumulative_constraint() const {
5350  return use_timetable_edge_finding_in_cumulative_constraint_;
5351 }
5352 inline bool SatParameters::use_timetable_edge_finding_in_cumulative_constraint() const {
5353  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_timetable_edge_finding_in_cumulative_constraint)
5354  return _internal_use_timetable_edge_finding_in_cumulative_constraint();
5355 }
5356 inline void SatParameters::_internal_set_use_timetable_edge_finding_in_cumulative_constraint(bool value) {
5357  _has_bits_[0] |= 0x00010000u;
5358  use_timetable_edge_finding_in_cumulative_constraint_ = value;
5359 }
5360 inline void SatParameters::set_use_timetable_edge_finding_in_cumulative_constraint(bool value) {
5361  _internal_set_use_timetable_edge_finding_in_cumulative_constraint(value);
5362  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_timetable_edge_finding_in_cumulative_constraint)
5363 }
5364 
5365 // optional bool use_disjunctive_constraint_in_cumulative_constraint = 80 [default = true];
5366 inline bool SatParameters::_internal_has_use_disjunctive_constraint_in_cumulative_constraint() const {
5367  bool value = (_has_bits_[3] & 0x00000800u) != 0;
5368  return value;
5369 }
5370 inline bool SatParameters::has_use_disjunctive_constraint_in_cumulative_constraint() const {
5371  return _internal_has_use_disjunctive_constraint_in_cumulative_constraint();
5372 }
5373 inline void SatParameters::clear_use_disjunctive_constraint_in_cumulative_constraint() {
5374  use_disjunctive_constraint_in_cumulative_constraint_ = true;
5375  _has_bits_[3] &= ~0x00000800u;
5376 }
5377 inline bool SatParameters::_internal_use_disjunctive_constraint_in_cumulative_constraint() const {
5378  return use_disjunctive_constraint_in_cumulative_constraint_;
5379 }
5380 inline bool SatParameters::use_disjunctive_constraint_in_cumulative_constraint() const {
5381  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_disjunctive_constraint_in_cumulative_constraint)
5382  return _internal_use_disjunctive_constraint_in_cumulative_constraint();
5383 }
5384 inline void SatParameters::_internal_set_use_disjunctive_constraint_in_cumulative_constraint(bool value) {
5385  _has_bits_[3] |= 0x00000800u;
5386  use_disjunctive_constraint_in_cumulative_constraint_ = value;
5387 }
5388 inline void SatParameters::set_use_disjunctive_constraint_in_cumulative_constraint(bool value) {
5389  _internal_set_use_disjunctive_constraint_in_cumulative_constraint(value);
5390  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_disjunctive_constraint_in_cumulative_constraint)
5391 }
5392 
5393 // optional int32 linearization_level = 90 [default = 1];
5394 inline bool SatParameters::_internal_has_linearization_level() const {
5395  bool value = (_has_bits_[2] & 0x04000000u) != 0;
5396  return value;
5397 }
5398 inline bool SatParameters::has_linearization_level() const {
5399  return _internal_has_linearization_level();
5400 }
5401 inline void SatParameters::clear_linearization_level() {
5402  linearization_level_ = 1;
5403  _has_bits_[2] &= ~0x04000000u;
5404 }
5405 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_linearization_level() const {
5406  return linearization_level_;
5407 }
5408 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::linearization_level() const {
5409  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.linearization_level)
5410  return _internal_linearization_level();
5411 }
5412 inline void SatParameters::_internal_set_linearization_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
5413  _has_bits_[2] |= 0x04000000u;
5414  linearization_level_ = value;
5415 }
5416 inline void SatParameters::set_linearization_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
5417  _internal_set_linearization_level(value);
5418  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.linearization_level)
5419 }
5420 
5421 // optional int32 boolean_encoding_level = 107 [default = 1];
5422 inline bool SatParameters::_internal_has_boolean_encoding_level() const {
5423  bool value = (_has_bits_[3] & 0x00000001u) != 0;
5424  return value;
5425 }
5426 inline bool SatParameters::has_boolean_encoding_level() const {
5427  return _internal_has_boolean_encoding_level();
5428 }
5429 inline void SatParameters::clear_boolean_encoding_level() {
5430  boolean_encoding_level_ = 1;
5431  _has_bits_[3] &= ~0x00000001u;
5432 }
5433 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_boolean_encoding_level() const {
5434  return boolean_encoding_level_;
5435 }
5436 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::boolean_encoding_level() const {
5437  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.boolean_encoding_level)
5438  return _internal_boolean_encoding_level();
5439 }
5440 inline void SatParameters::_internal_set_boolean_encoding_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
5441  _has_bits_[3] |= 0x00000001u;
5442  boolean_encoding_level_ = value;
5443 }
5444 inline void SatParameters::set_boolean_encoding_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
5445  _internal_set_boolean_encoding_level(value);
5446  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.boolean_encoding_level)
5447 }
5448 
5449 // optional int32 max_num_cuts = 91 [default = 10000];
5450 inline bool SatParameters::_internal_has_max_num_cuts() const {
5451  bool value = (_has_bits_[2] & 0x08000000u) != 0;
5452  return value;
5453 }
5454 inline bool SatParameters::has_max_num_cuts() const {
5455  return _internal_has_max_num_cuts();
5456 }
5457 inline void SatParameters::clear_max_num_cuts() {
5458  max_num_cuts_ = 10000;
5459  _has_bits_[2] &= ~0x08000000u;
5460 }
5461 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_num_cuts() const {
5462  return max_num_cuts_;
5463 }
5464 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_num_cuts() const {
5465  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_num_cuts)
5466  return _internal_max_num_cuts();
5467 }
5468 inline void SatParameters::_internal_set_max_num_cuts(::PROTOBUF_NAMESPACE_ID::int32 value) {
5469  _has_bits_[2] |= 0x08000000u;
5470  max_num_cuts_ = value;
5471 }
5472 inline void SatParameters::set_max_num_cuts(::PROTOBUF_NAMESPACE_ID::int32 value) {
5473  _internal_set_max_num_cuts(value);
5474  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_num_cuts)
5475 }
5476 
5477 // optional bool only_add_cuts_at_level_zero = 92 [default = false];
5478 inline bool SatParameters::_internal_has_only_add_cuts_at_level_zero() const {
5479  bool value = (_has_bits_[0] & 0x00020000u) != 0;
5480  return value;
5481 }
5482 inline bool SatParameters::has_only_add_cuts_at_level_zero() const {
5483  return _internal_has_only_add_cuts_at_level_zero();
5484 }
5485 inline void SatParameters::clear_only_add_cuts_at_level_zero() {
5486  only_add_cuts_at_level_zero_ = false;
5487  _has_bits_[0] &= ~0x00020000u;
5488 }
5489 inline bool SatParameters::_internal_only_add_cuts_at_level_zero() const {
5490  return only_add_cuts_at_level_zero_;
5491 }
5492 inline bool SatParameters::only_add_cuts_at_level_zero() const {
5493  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.only_add_cuts_at_level_zero)
5494  return _internal_only_add_cuts_at_level_zero();
5495 }
5496 inline void SatParameters::_internal_set_only_add_cuts_at_level_zero(bool value) {
5497  _has_bits_[0] |= 0x00020000u;
5498  only_add_cuts_at_level_zero_ = value;
5499 }
5500 inline void SatParameters::set_only_add_cuts_at_level_zero(bool value) {
5501  _internal_set_only_add_cuts_at_level_zero(value);
5502  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.only_add_cuts_at_level_zero)
5503 }
5504 
5505 // optional bool add_knapsack_cuts = 111 [default = false];
5506 inline bool SatParameters::_internal_has_add_knapsack_cuts() const {
5507  bool value = (_has_bits_[1] & 0x00000080u) != 0;
5508  return value;
5509 }
5510 inline bool SatParameters::has_add_knapsack_cuts() const {
5511  return _internal_has_add_knapsack_cuts();
5512 }
5513 inline void SatParameters::clear_add_knapsack_cuts() {
5514  add_knapsack_cuts_ = false;
5515  _has_bits_[1] &= ~0x00000080u;
5516 }
5517 inline bool SatParameters::_internal_add_knapsack_cuts() const {
5518  return add_knapsack_cuts_;
5519 }
5520 inline bool SatParameters::add_knapsack_cuts() const {
5521  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_knapsack_cuts)
5522  return _internal_add_knapsack_cuts();
5523 }
5524 inline void SatParameters::_internal_set_add_knapsack_cuts(bool value) {
5525  _has_bits_[1] |= 0x00000080u;
5526  add_knapsack_cuts_ = value;
5527 }
5528 inline void SatParameters::set_add_knapsack_cuts(bool value) {
5529  _internal_set_add_knapsack_cuts(value);
5530  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_knapsack_cuts)
5531 }
5532 
5533 // optional bool add_cg_cuts = 117 [default = true];
5534 inline bool SatParameters::_internal_has_add_cg_cuts() const {
5535  bool value = (_has_bits_[3] & 0x00001000u) != 0;
5536  return value;
5537 }
5538 inline bool SatParameters::has_add_cg_cuts() const {
5539  return _internal_has_add_cg_cuts();
5540 }
5541 inline void SatParameters::clear_add_cg_cuts() {
5542  add_cg_cuts_ = true;
5543  _has_bits_[3] &= ~0x00001000u;
5544 }
5545 inline bool SatParameters::_internal_add_cg_cuts() const {
5546  return add_cg_cuts_;
5547 }
5548 inline bool SatParameters::add_cg_cuts() const {
5549  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_cg_cuts)
5550  return _internal_add_cg_cuts();
5551 }
5552 inline void SatParameters::_internal_set_add_cg_cuts(bool value) {
5553  _has_bits_[3] |= 0x00001000u;
5554  add_cg_cuts_ = value;
5555 }
5556 inline void SatParameters::set_add_cg_cuts(bool value) {
5557  _internal_set_add_cg_cuts(value);
5558  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_cg_cuts)
5559 }
5560 
5561 // optional bool add_mir_cuts = 120 [default = true];
5562 inline bool SatParameters::_internal_has_add_mir_cuts() const {
5563  bool value = (_has_bits_[3] & 0x00002000u) != 0;
5564  return value;
5565 }
5566 inline bool SatParameters::has_add_mir_cuts() const {
5567  return _internal_has_add_mir_cuts();
5568 }
5569 inline void SatParameters::clear_add_mir_cuts() {
5570  add_mir_cuts_ = true;
5571  _has_bits_[3] &= ~0x00002000u;
5572 }
5573 inline bool SatParameters::_internal_add_mir_cuts() const {
5574  return add_mir_cuts_;
5575 }
5576 inline bool SatParameters::add_mir_cuts() const {
5577  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_mir_cuts)
5578  return _internal_add_mir_cuts();
5579 }
5580 inline void SatParameters::_internal_set_add_mir_cuts(bool value) {
5581  _has_bits_[3] |= 0x00002000u;
5582  add_mir_cuts_ = value;
5583 }
5584 inline void SatParameters::set_add_mir_cuts(bool value) {
5585  _internal_set_add_mir_cuts(value);
5586  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_mir_cuts)
5587 }
5588 
5589 // optional int32 max_all_diff_cut_size = 148 [default = 7];
5590 inline bool SatParameters::_internal_has_max_all_diff_cut_size() const {
5591  bool value = (_has_bits_[4] & 0x00000020u) != 0;
5592  return value;
5593 }
5594 inline bool SatParameters::has_max_all_diff_cut_size() const {
5595  return _internal_has_max_all_diff_cut_size();
5596 }
5597 inline void SatParameters::clear_max_all_diff_cut_size() {
5598  max_all_diff_cut_size_ = 7;
5599  _has_bits_[4] &= ~0x00000020u;
5600 }
5601 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_all_diff_cut_size() const {
5602  return max_all_diff_cut_size_;
5603 }
5604 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_all_diff_cut_size() const {
5605  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_all_diff_cut_size)
5606  return _internal_max_all_diff_cut_size();
5607 }
5608 inline void SatParameters::_internal_set_max_all_diff_cut_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
5609  _has_bits_[4] |= 0x00000020u;
5610  max_all_diff_cut_size_ = value;
5611 }
5612 inline void SatParameters::set_max_all_diff_cut_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
5613  _internal_set_max_all_diff_cut_size(value);
5614  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_all_diff_cut_size)
5615 }
5616 
5617 // optional bool add_lin_max_cuts = 152 [default = true];
5618 inline bool SatParameters::_internal_has_add_lin_max_cuts() const {
5619  bool value = (_has_bits_[3] & 0x00004000u) != 0;
5620  return value;
5621 }
5622 inline bool SatParameters::has_add_lin_max_cuts() const {
5623  return _internal_has_add_lin_max_cuts();
5624 }
5625 inline void SatParameters::clear_add_lin_max_cuts() {
5626  add_lin_max_cuts_ = true;
5627  _has_bits_[3] &= ~0x00004000u;
5628 }
5629 inline bool SatParameters::_internal_add_lin_max_cuts() const {
5630  return add_lin_max_cuts_;
5631 }
5632 inline bool SatParameters::add_lin_max_cuts() const {
5633  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_lin_max_cuts)
5634  return _internal_add_lin_max_cuts();
5635 }
5636 inline void SatParameters::_internal_set_add_lin_max_cuts(bool value) {
5637  _has_bits_[3] |= 0x00004000u;
5638  add_lin_max_cuts_ = value;
5639 }
5640 inline void SatParameters::set_add_lin_max_cuts(bool value) {
5641  _internal_set_add_lin_max_cuts(value);
5642  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_lin_max_cuts)
5643 }
5644 
5645 // optional int32 max_integer_rounding_scaling = 119 [default = 600];
5646 inline bool SatParameters::_internal_has_max_integer_rounding_scaling() const {
5647  bool value = (_has_bits_[3] & 0x00008000u) != 0;
5648  return value;
5649 }
5650 inline bool SatParameters::has_max_integer_rounding_scaling() const {
5651  return _internal_has_max_integer_rounding_scaling();
5652 }
5653 inline void SatParameters::clear_max_integer_rounding_scaling() {
5654  max_integer_rounding_scaling_ = 600;
5655  _has_bits_[3] &= ~0x00008000u;
5656 }
5657 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_integer_rounding_scaling() const {
5658  return max_integer_rounding_scaling_;
5659 }
5660 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_integer_rounding_scaling() const {
5661  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_integer_rounding_scaling)
5662  return _internal_max_integer_rounding_scaling();
5663 }
5664 inline void SatParameters::_internal_set_max_integer_rounding_scaling(::PROTOBUF_NAMESPACE_ID::int32 value) {
5665  _has_bits_[3] |= 0x00008000u;
5666  max_integer_rounding_scaling_ = value;
5667 }
5668 inline void SatParameters::set_max_integer_rounding_scaling(::PROTOBUF_NAMESPACE_ID::int32 value) {
5669  _internal_set_max_integer_rounding_scaling(value);
5670  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_integer_rounding_scaling)
5671 }
5672 
5673 // optional bool add_lp_constraints_lazily = 112 [default = true];
5674 inline bool SatParameters::_internal_has_add_lp_constraints_lazily() const {
5675  bool value = (_has_bits_[3] & 0x00000080u) != 0;
5676  return value;
5677 }
5678 inline bool SatParameters::has_add_lp_constraints_lazily() const {
5679  return _internal_has_add_lp_constraints_lazily();
5680 }
5681 inline void SatParameters::clear_add_lp_constraints_lazily() {
5682  add_lp_constraints_lazily_ = true;
5683  _has_bits_[3] &= ~0x00000080u;
5684 }
5685 inline bool SatParameters::_internal_add_lp_constraints_lazily() const {
5686  return add_lp_constraints_lazily_;
5687 }
5688 inline bool SatParameters::add_lp_constraints_lazily() const {
5689  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_lp_constraints_lazily)
5690  return _internal_add_lp_constraints_lazily();
5691 }
5692 inline void SatParameters::_internal_set_add_lp_constraints_lazily(bool value) {
5693  _has_bits_[3] |= 0x00000080u;
5694  add_lp_constraints_lazily_ = value;
5695 }
5696 inline void SatParameters::set_add_lp_constraints_lazily(bool value) {
5697  _internal_set_add_lp_constraints_lazily(value);
5698  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_lp_constraints_lazily)
5699 }
5700 
5701 // optional double min_orthogonality_for_lp_constraints = 115 [default = 0.05];
5702 inline bool SatParameters::_internal_has_min_orthogonality_for_lp_constraints() const {
5703  bool value = (_has_bits_[3] & 0x00000040u) != 0;
5704  return value;
5705 }
5706 inline bool SatParameters::has_min_orthogonality_for_lp_constraints() const {
5707  return _internal_has_min_orthogonality_for_lp_constraints();
5708 }
5709 inline void SatParameters::clear_min_orthogonality_for_lp_constraints() {
5710  min_orthogonality_for_lp_constraints_ = 0.05;
5711  _has_bits_[3] &= ~0x00000040u;
5712 }
5713 inline double SatParameters::_internal_min_orthogonality_for_lp_constraints() const {
5714  return min_orthogonality_for_lp_constraints_;
5715 }
5716 inline double SatParameters::min_orthogonality_for_lp_constraints() const {
5717  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.min_orthogonality_for_lp_constraints)
5718  return _internal_min_orthogonality_for_lp_constraints();
5719 }
5720 inline void SatParameters::_internal_set_min_orthogonality_for_lp_constraints(double value) {
5721  _has_bits_[3] |= 0x00000040u;
5722  min_orthogonality_for_lp_constraints_ = value;
5723 }
5724 inline void SatParameters::set_min_orthogonality_for_lp_constraints(double value) {
5725  _internal_set_min_orthogonality_for_lp_constraints(value);
5726  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.min_orthogonality_for_lp_constraints)
5727 }
5728 
5729 // optional int32 max_cut_rounds_at_level_zero = 154 [default = 1];
5730 inline bool SatParameters::_internal_has_max_cut_rounds_at_level_zero() const {
5731  bool value = (_has_bits_[4] & 0x00000800u) != 0;
5732  return value;
5733 }
5734 inline bool SatParameters::has_max_cut_rounds_at_level_zero() const {
5735  return _internal_has_max_cut_rounds_at_level_zero();
5736 }
5737 inline void SatParameters::clear_max_cut_rounds_at_level_zero() {
5738  max_cut_rounds_at_level_zero_ = 1;
5739  _has_bits_[4] &= ~0x00000800u;
5740 }
5741 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_cut_rounds_at_level_zero() const {
5742  return max_cut_rounds_at_level_zero_;
5743 }
5744 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_cut_rounds_at_level_zero() const {
5745  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_cut_rounds_at_level_zero)
5746  return _internal_max_cut_rounds_at_level_zero();
5747 }
5748 inline void SatParameters::_internal_set_max_cut_rounds_at_level_zero(::PROTOBUF_NAMESPACE_ID::int32 value) {
5749  _has_bits_[4] |= 0x00000800u;
5750  max_cut_rounds_at_level_zero_ = value;
5751 }
5752 inline void SatParameters::set_max_cut_rounds_at_level_zero(::PROTOBUF_NAMESPACE_ID::int32 value) {
5753  _internal_set_max_cut_rounds_at_level_zero(value);
5754  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_cut_rounds_at_level_zero)
5755 }
5756 
5757 // optional int32 max_consecutive_inactive_count = 121 [default = 100];
5758 inline bool SatParameters::_internal_has_max_consecutive_inactive_count() const {
5759  bool value = (_has_bits_[3] & 0x00100000u) != 0;
5760  return value;
5761 }
5762 inline bool SatParameters::has_max_consecutive_inactive_count() const {
5763  return _internal_has_max_consecutive_inactive_count();
5764 }
5765 inline void SatParameters::clear_max_consecutive_inactive_count() {
5766  max_consecutive_inactive_count_ = 100;
5767  _has_bits_[3] &= ~0x00100000u;
5768 }
5769 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_consecutive_inactive_count() const {
5770  return max_consecutive_inactive_count_;
5771 }
5772 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_consecutive_inactive_count() const {
5773  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_consecutive_inactive_count)
5774  return _internal_max_consecutive_inactive_count();
5775 }
5776 inline void SatParameters::_internal_set_max_consecutive_inactive_count(::PROTOBUF_NAMESPACE_ID::int32 value) {
5777  _has_bits_[3] |= 0x00100000u;
5778  max_consecutive_inactive_count_ = value;
5779 }
5780 inline void SatParameters::set_max_consecutive_inactive_count(::PROTOBUF_NAMESPACE_ID::int32 value) {
5781  _internal_set_max_consecutive_inactive_count(value);
5782  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_consecutive_inactive_count)
5783 }
5784 
5785 // optional double cut_max_active_count_value = 155 [default = 10000000000];
5786 inline bool SatParameters::_internal_has_cut_max_active_count_value() const {
5787  bool value = (_has_bits_[4] & 0x00000400u) != 0;
5788  return value;
5789 }
5790 inline bool SatParameters::has_cut_max_active_count_value() const {
5791  return _internal_has_cut_max_active_count_value();
5792 }
5793 inline void SatParameters::clear_cut_max_active_count_value() {
5794  cut_max_active_count_value_ = 10000000000;
5795  _has_bits_[4] &= ~0x00000400u;
5796 }
5797 inline double SatParameters::_internal_cut_max_active_count_value() const {
5798  return cut_max_active_count_value_;
5799 }
5800 inline double SatParameters::cut_max_active_count_value() const {
5801  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cut_max_active_count_value)
5802  return _internal_cut_max_active_count_value();
5803 }
5804 inline void SatParameters::_internal_set_cut_max_active_count_value(double value) {
5805  _has_bits_[4] |= 0x00000400u;
5806  cut_max_active_count_value_ = value;
5807 }
5808 inline void SatParameters::set_cut_max_active_count_value(double value) {
5809  _internal_set_cut_max_active_count_value(value);
5810  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cut_max_active_count_value)
5811 }
5812 
5813 // optional double cut_active_count_decay = 156 [default = 0.8];
5814 inline bool SatParameters::_internal_has_cut_active_count_decay() const {
5815  bool value = (_has_bits_[4] & 0x00002000u) != 0;
5816  return value;
5817 }
5818 inline bool SatParameters::has_cut_active_count_decay() const {
5819  return _internal_has_cut_active_count_decay();
5820 }
5821 inline void SatParameters::clear_cut_active_count_decay() {
5822  cut_active_count_decay_ = 0.8;
5823  _has_bits_[4] &= ~0x00002000u;
5824 }
5825 inline double SatParameters::_internal_cut_active_count_decay() const {
5826  return cut_active_count_decay_;
5827 }
5828 inline double SatParameters::cut_active_count_decay() const {
5829  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cut_active_count_decay)
5830  return _internal_cut_active_count_decay();
5831 }
5832 inline void SatParameters::_internal_set_cut_active_count_decay(double value) {
5833  _has_bits_[4] |= 0x00002000u;
5834  cut_active_count_decay_ = value;
5835 }
5836 inline void SatParameters::set_cut_active_count_decay(double value) {
5837  _internal_set_cut_active_count_decay(value);
5838  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cut_active_count_decay)
5839 }
5840 
5841 // optional int32 cut_cleanup_target = 157 [default = 1000];
5842 inline bool SatParameters::_internal_has_cut_cleanup_target() const {
5843  bool value = (_has_bits_[4] & 0x00001000u) != 0;
5844  return value;
5845 }
5846 inline bool SatParameters::has_cut_cleanup_target() const {
5847  return _internal_has_cut_cleanup_target();
5848 }
5849 inline void SatParameters::clear_cut_cleanup_target() {
5850  cut_cleanup_target_ = 1000;
5851  _has_bits_[4] &= ~0x00001000u;
5852 }
5853 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_cut_cleanup_target() const {
5854  return cut_cleanup_target_;
5855 }
5856 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::cut_cleanup_target() const {
5857  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cut_cleanup_target)
5858  return _internal_cut_cleanup_target();
5859 }
5860 inline void SatParameters::_internal_set_cut_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value) {
5861  _has_bits_[4] |= 0x00001000u;
5862  cut_cleanup_target_ = value;
5863 }
5864 inline void SatParameters::set_cut_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value) {
5865  _internal_set_cut_cleanup_target(value);
5866  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cut_cleanup_target)
5867 }
5868 
5869 // optional int32 new_constraints_batch_size = 122 [default = 50];
5870 inline bool SatParameters::_internal_has_new_constraints_batch_size() const {
5871  bool value = (_has_bits_[3] & 0x00200000u) != 0;
5872  return value;
5873 }
5874 inline bool SatParameters::has_new_constraints_batch_size() const {
5875  return _internal_has_new_constraints_batch_size();
5876 }
5877 inline void SatParameters::clear_new_constraints_batch_size() {
5878  new_constraints_batch_size_ = 50;
5879  _has_bits_[3] &= ~0x00200000u;
5880 }
5881 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_new_constraints_batch_size() const {
5882  return new_constraints_batch_size_;
5883 }
5884 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::new_constraints_batch_size() const {
5885  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.new_constraints_batch_size)
5886  return _internal_new_constraints_batch_size();
5887 }
5888 inline void SatParameters::_internal_set_new_constraints_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
5889  _has_bits_[3] |= 0x00200000u;
5890  new_constraints_batch_size_ = value;
5891 }
5892 inline void SatParameters::set_new_constraints_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
5893  _internal_set_new_constraints_batch_size(value);
5894  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.new_constraints_batch_size)
5895 }
5896 
5897 // optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
5898 inline bool SatParameters::_internal_has_search_branching() const {
5899  bool value = (_has_bits_[0] & 0x00040000u) != 0;
5900  return value;
5901 }
5902 inline bool SatParameters::has_search_branching() const {
5903  return _internal_has_search_branching();
5904 }
5905 inline void SatParameters::clear_search_branching() {
5906  search_branching_ = 0;
5907  _has_bits_[0] &= ~0x00040000u;
5908 }
5909 inline ::operations_research::sat::SatParameters_SearchBranching SatParameters::_internal_search_branching() const {
5910  return static_cast< ::operations_research::sat::SatParameters_SearchBranching >(search_branching_);
5911 }
5912 inline ::operations_research::sat::SatParameters_SearchBranching SatParameters::search_branching() const {
5913  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.search_branching)
5914  return _internal_search_branching();
5915 }
5916 inline void SatParameters::_internal_set_search_branching(::operations_research::sat::SatParameters_SearchBranching value) {
5917  assert(::operations_research::sat::SatParameters_SearchBranching_IsValid(value));
5918  _has_bits_[0] |= 0x00040000u;
5919  search_branching_ = value;
5920 }
5921 inline void SatParameters::set_search_branching(::operations_research::sat::SatParameters_SearchBranching value) {
5922  _internal_set_search_branching(value);
5923  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.search_branching)
5924 }
5925 
5926 // optional int32 hint_conflict_limit = 153 [default = 10];
5927 inline bool SatParameters::_internal_has_hint_conflict_limit() const {
5928  bool value = (_has_bits_[4] & 0x00000200u) != 0;
5929  return value;
5930 }
5931 inline bool SatParameters::has_hint_conflict_limit() const {
5932  return _internal_has_hint_conflict_limit();
5933 }
5934 inline void SatParameters::clear_hint_conflict_limit() {
5935  hint_conflict_limit_ = 10;
5936  _has_bits_[4] &= ~0x00000200u;
5937 }
5938 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_hint_conflict_limit() const {
5939  return hint_conflict_limit_;
5940 }
5941 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::hint_conflict_limit() const {
5942  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.hint_conflict_limit)
5943  return _internal_hint_conflict_limit();
5944 }
5945 inline void SatParameters::_internal_set_hint_conflict_limit(::PROTOBUF_NAMESPACE_ID::int32 value) {
5946  _has_bits_[4] |= 0x00000200u;
5947  hint_conflict_limit_ = value;
5948 }
5949 inline void SatParameters::set_hint_conflict_limit(::PROTOBUF_NAMESPACE_ID::int32 value) {
5950  _internal_set_hint_conflict_limit(value);
5951  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.hint_conflict_limit)
5952 }
5953 
5954 // optional bool repair_hint = 167 [default = false];
5955 inline bool SatParameters::_internal_has_repair_hint() const {
5956  bool value = (_has_bits_[1] & 0x00000100u) != 0;
5957  return value;
5958 }
5959 inline bool SatParameters::has_repair_hint() const {
5960  return _internal_has_repair_hint();
5961 }
5962 inline void SatParameters::clear_repair_hint() {
5963  repair_hint_ = false;
5964  _has_bits_[1] &= ~0x00000100u;
5965 }
5966 inline bool SatParameters::_internal_repair_hint() const {
5967  return repair_hint_;
5968 }
5969 inline bool SatParameters::repair_hint() const {
5970  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.repair_hint)
5971  return _internal_repair_hint();
5972 }
5973 inline void SatParameters::_internal_set_repair_hint(bool value) {
5974  _has_bits_[1] |= 0x00000100u;
5975  repair_hint_ = value;
5976 }
5977 inline void SatParameters::set_repair_hint(bool value) {
5978  _internal_set_repair_hint(value);
5979  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.repair_hint)
5980 }
5981 
5982 // optional bool exploit_integer_lp_solution = 94 [default = true];
5983 inline bool SatParameters::_internal_has_exploit_integer_lp_solution() const {
5984  bool value = (_has_bits_[3] & 0x00000100u) != 0;
5985  return value;
5986 }
5987 inline bool SatParameters::has_exploit_integer_lp_solution() const {
5988  return _internal_has_exploit_integer_lp_solution();
5989 }
5990 inline void SatParameters::clear_exploit_integer_lp_solution() {
5991  exploit_integer_lp_solution_ = true;
5992  _has_bits_[3] &= ~0x00000100u;
5993 }
5994 inline bool SatParameters::_internal_exploit_integer_lp_solution() const {
5995  return exploit_integer_lp_solution_;
5996 }
5997 inline bool SatParameters::exploit_integer_lp_solution() const {
5998  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_integer_lp_solution)
5999  return _internal_exploit_integer_lp_solution();
6000 }
6001 inline void SatParameters::_internal_set_exploit_integer_lp_solution(bool value) {
6002  _has_bits_[3] |= 0x00000100u;
6003  exploit_integer_lp_solution_ = value;
6004 }
6005 inline void SatParameters::set_exploit_integer_lp_solution(bool value) {
6006  _internal_set_exploit_integer_lp_solution(value);
6007  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_integer_lp_solution)
6008 }
6009 
6010 // optional bool exploit_all_lp_solution = 116 [default = true];
6011 inline bool SatParameters::_internal_has_exploit_all_lp_solution() const {
6012  bool value = (_has_bits_[3] & 0x00000200u) != 0;
6013  return value;
6014 }
6015 inline bool SatParameters::has_exploit_all_lp_solution() const {
6016  return _internal_has_exploit_all_lp_solution();
6017 }
6018 inline void SatParameters::clear_exploit_all_lp_solution() {
6019  exploit_all_lp_solution_ = true;
6020  _has_bits_[3] &= ~0x00000200u;
6021 }
6022 inline bool SatParameters::_internal_exploit_all_lp_solution() const {
6023  return exploit_all_lp_solution_;
6024 }
6025 inline bool SatParameters::exploit_all_lp_solution() const {
6026  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_all_lp_solution)
6027  return _internal_exploit_all_lp_solution();
6028 }
6029 inline void SatParameters::_internal_set_exploit_all_lp_solution(bool value) {
6030  _has_bits_[3] |= 0x00000200u;
6031  exploit_all_lp_solution_ = value;
6032 }
6033 inline void SatParameters::set_exploit_all_lp_solution(bool value) {
6034  _internal_set_exploit_all_lp_solution(value);
6035  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_all_lp_solution)
6036 }
6037 
6038 // optional bool exploit_best_solution = 130 [default = false];
6039 inline bool SatParameters::_internal_has_exploit_best_solution() const {
6040  bool value = (_has_bits_[1] & 0x00000200u) != 0;
6041  return value;
6042 }
6043 inline bool SatParameters::has_exploit_best_solution() const {
6044  return _internal_has_exploit_best_solution();
6045 }
6046 inline void SatParameters::clear_exploit_best_solution() {
6047  exploit_best_solution_ = false;
6048  _has_bits_[1] &= ~0x00000200u;
6049 }
6050 inline bool SatParameters::_internal_exploit_best_solution() const {
6051  return exploit_best_solution_;
6052 }
6053 inline bool SatParameters::exploit_best_solution() const {
6054  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_best_solution)
6055  return _internal_exploit_best_solution();
6056 }
6057 inline void SatParameters::_internal_set_exploit_best_solution(bool value) {
6058  _has_bits_[1] |= 0x00000200u;
6059  exploit_best_solution_ = value;
6060 }
6061 inline void SatParameters::set_exploit_best_solution(bool value) {
6062  _internal_set_exploit_best_solution(value);
6063  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_best_solution)
6064 }
6065 
6066 // optional bool exploit_relaxation_solution = 161 [default = false];
6067 inline bool SatParameters::_internal_has_exploit_relaxation_solution() const {
6068  bool value = (_has_bits_[1] & 0x00000400u) != 0;
6069  return value;
6070 }
6071 inline bool SatParameters::has_exploit_relaxation_solution() const {
6072  return _internal_has_exploit_relaxation_solution();
6073 }
6074 inline void SatParameters::clear_exploit_relaxation_solution() {
6075  exploit_relaxation_solution_ = false;
6076  _has_bits_[1] &= ~0x00000400u;
6077 }
6078 inline bool SatParameters::_internal_exploit_relaxation_solution() const {
6079  return exploit_relaxation_solution_;
6080 }
6081 inline bool SatParameters::exploit_relaxation_solution() const {
6082  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_relaxation_solution)
6083  return _internal_exploit_relaxation_solution();
6084 }
6085 inline void SatParameters::_internal_set_exploit_relaxation_solution(bool value) {
6086  _has_bits_[1] |= 0x00000400u;
6087  exploit_relaxation_solution_ = value;
6088 }
6089 inline void SatParameters::set_exploit_relaxation_solution(bool value) {
6090  _internal_set_exploit_relaxation_solution(value);
6091  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_relaxation_solution)
6092 }
6093 
6094 // optional bool exploit_objective = 131 [default = true];
6095 inline bool SatParameters::_internal_has_exploit_objective() const {
6096  bool value = (_has_bits_[3] & 0x00000400u) != 0;
6097  return value;
6098 }
6099 inline bool SatParameters::has_exploit_objective() const {
6100  return _internal_has_exploit_objective();
6101 }
6102 inline void SatParameters::clear_exploit_objective() {
6103  exploit_objective_ = true;
6104  _has_bits_[3] &= ~0x00000400u;
6105 }
6106 inline bool SatParameters::_internal_exploit_objective() const {
6107  return exploit_objective_;
6108 }
6109 inline bool SatParameters::exploit_objective() const {
6110  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_objective)
6111  return _internal_exploit_objective();
6112 }
6113 inline void SatParameters::_internal_set_exploit_objective(bool value) {
6114  _has_bits_[3] |= 0x00000400u;
6115  exploit_objective_ = value;
6116 }
6117 inline void SatParameters::set_exploit_objective(bool value) {
6118  _internal_set_exploit_objective(value);
6119  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_objective)
6120 }
6121 
6122 // optional int64 probing_period_at_root = 142 [default = 0];
6123 inline bool SatParameters::_internal_has_probing_period_at_root() const {
6124  bool value = (_has_bits_[1] & 0x00000800u) != 0;
6125  return value;
6126 }
6127 inline bool SatParameters::has_probing_period_at_root() const {
6128  return _internal_has_probing_period_at_root();
6129 }
6130 inline void SatParameters::clear_probing_period_at_root() {
6131  probing_period_at_root_ = PROTOBUF_LONGLONG(0);
6132  _has_bits_[1] &= ~0x00000800u;
6133 }
6134 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::_internal_probing_period_at_root() const {
6135  return probing_period_at_root_;
6136 }
6137 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::probing_period_at_root() const {
6138  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.probing_period_at_root)
6139  return _internal_probing_period_at_root();
6140 }
6141 inline void SatParameters::_internal_set_probing_period_at_root(::PROTOBUF_NAMESPACE_ID::int64 value) {
6142  _has_bits_[1] |= 0x00000800u;
6143  probing_period_at_root_ = value;
6144 }
6145 inline void SatParameters::set_probing_period_at_root(::PROTOBUF_NAMESPACE_ID::int64 value) {
6146  _internal_set_probing_period_at_root(value);
6147  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.probing_period_at_root)
6148 }
6149 
6150 // optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
6151 inline bool SatParameters::_internal_has_pseudo_cost_reliability_threshold() const {
6152  bool value = (_has_bits_[3] & 0x00400000u) != 0;
6153  return value;
6154 }
6155 inline bool SatParameters::has_pseudo_cost_reliability_threshold() const {
6156  return _internal_has_pseudo_cost_reliability_threshold();
6157 }
6158 inline void SatParameters::clear_pseudo_cost_reliability_threshold() {
6159  pseudo_cost_reliability_threshold_ = PROTOBUF_LONGLONG(100);
6160  _has_bits_[3] &= ~0x00400000u;
6161 }
6162 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::_internal_pseudo_cost_reliability_threshold() const {
6163  return pseudo_cost_reliability_threshold_;
6164 }
6165 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::pseudo_cost_reliability_threshold() const {
6166  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.pseudo_cost_reliability_threshold)
6167  return _internal_pseudo_cost_reliability_threshold();
6168 }
6169 inline void SatParameters::_internal_set_pseudo_cost_reliability_threshold(::PROTOBUF_NAMESPACE_ID::int64 value) {
6170  _has_bits_[3] |= 0x00400000u;
6171  pseudo_cost_reliability_threshold_ = value;
6172 }
6173 inline void SatParameters::set_pseudo_cost_reliability_threshold(::PROTOBUF_NAMESPACE_ID::int64 value) {
6174  _internal_set_pseudo_cost_reliability_threshold(value);
6175  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.pseudo_cost_reliability_threshold)
6176 }
6177 
6178 // optional bool optimize_with_core = 83 [default = false];
6179 inline bool SatParameters::_internal_has_optimize_with_core() const {
6180  bool value = (_has_bits_[0] & 0x00080000u) != 0;
6181  return value;
6182 }
6183 inline bool SatParameters::has_optimize_with_core() const {
6184  return _internal_has_optimize_with_core();
6185 }
6186 inline void SatParameters::clear_optimize_with_core() {
6187  optimize_with_core_ = false;
6188  _has_bits_[0] &= ~0x00080000u;
6189 }
6190 inline bool SatParameters::_internal_optimize_with_core() const {
6191  return optimize_with_core_;
6192 }
6193 inline bool SatParameters::optimize_with_core() const {
6194  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.optimize_with_core)
6195  return _internal_optimize_with_core();
6196 }
6197 inline void SatParameters::_internal_set_optimize_with_core(bool value) {
6198  _has_bits_[0] |= 0x00080000u;
6199  optimize_with_core_ = value;
6200 }
6201 inline void SatParameters::set_optimize_with_core(bool value) {
6202  _internal_set_optimize_with_core(value);
6203  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.optimize_with_core)
6204 }
6205 
6206 // optional int32 binary_search_num_conflicts = 99 [default = -1];
6207 inline bool SatParameters::_internal_has_binary_search_num_conflicts() const {
6208  bool value = (_has_bits_[2] & 0x40000000u) != 0;
6209  return value;
6210 }
6211 inline bool SatParameters::has_binary_search_num_conflicts() const {
6212  return _internal_has_binary_search_num_conflicts();
6213 }
6214 inline void SatParameters::clear_binary_search_num_conflicts() {
6215  binary_search_num_conflicts_ = -1;
6216  _has_bits_[2] &= ~0x40000000u;
6217 }
6218 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_binary_search_num_conflicts() const {
6219  return binary_search_num_conflicts_;
6220 }
6221 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::binary_search_num_conflicts() const {
6222  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.binary_search_num_conflicts)
6223  return _internal_binary_search_num_conflicts();
6224 }
6225 inline void SatParameters::_internal_set_binary_search_num_conflicts(::PROTOBUF_NAMESPACE_ID::int32 value) {
6226  _has_bits_[2] |= 0x40000000u;
6227  binary_search_num_conflicts_ = value;
6228 }
6229 inline void SatParameters::set_binary_search_num_conflicts(::PROTOBUF_NAMESPACE_ID::int32 value) {
6230  _internal_set_binary_search_num_conflicts(value);
6231  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.binary_search_num_conflicts)
6232 }
6233 
6234 // optional bool optimize_with_max_hs = 85 [default = false];
6235 inline bool SatParameters::_internal_has_optimize_with_max_hs() const {
6236  bool value = (_has_bits_[0] & 0x00100000u) != 0;
6237  return value;
6238 }
6239 inline bool SatParameters::has_optimize_with_max_hs() const {
6240  return _internal_has_optimize_with_max_hs();
6241 }
6242 inline void SatParameters::clear_optimize_with_max_hs() {
6243  optimize_with_max_hs_ = false;
6244  _has_bits_[0] &= ~0x00100000u;
6245 }
6246 inline bool SatParameters::_internal_optimize_with_max_hs() const {
6247  return optimize_with_max_hs_;
6248 }
6249 inline bool SatParameters::optimize_with_max_hs() const {
6250  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.optimize_with_max_hs)
6251  return _internal_optimize_with_max_hs();
6252 }
6253 inline void SatParameters::_internal_set_optimize_with_max_hs(bool value) {
6254  _has_bits_[0] |= 0x00100000u;
6255  optimize_with_max_hs_ = value;
6256 }
6257 inline void SatParameters::set_optimize_with_max_hs(bool value) {
6258  _internal_set_optimize_with_max_hs(value);
6259  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.optimize_with_max_hs)
6260 }
6261 
6262 // optional bool enumerate_all_solutions = 87 [default = false];
6263 inline bool SatParameters::_internal_has_enumerate_all_solutions() const {
6264  bool value = (_has_bits_[0] & 0x00200000u) != 0;
6265  return value;
6266 }
6267 inline bool SatParameters::has_enumerate_all_solutions() const {
6268  return _internal_has_enumerate_all_solutions();
6269 }
6270 inline void SatParameters::clear_enumerate_all_solutions() {
6271  enumerate_all_solutions_ = false;
6272  _has_bits_[0] &= ~0x00200000u;
6273 }
6274 inline bool SatParameters::_internal_enumerate_all_solutions() const {
6275  return enumerate_all_solutions_;
6276 }
6277 inline bool SatParameters::enumerate_all_solutions() const {
6278  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.enumerate_all_solutions)
6279  return _internal_enumerate_all_solutions();
6280 }
6281 inline void SatParameters::_internal_set_enumerate_all_solutions(bool value) {
6282  _has_bits_[0] |= 0x00200000u;
6283  enumerate_all_solutions_ = value;
6284 }
6285 inline void SatParameters::set_enumerate_all_solutions(bool value) {
6286  _internal_set_enumerate_all_solutions(value);
6287  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.enumerate_all_solutions)
6288 }
6289 
6290 // optional bool fill_tightened_domains_in_response = 132 [default = false];
6291 inline bool SatParameters::_internal_has_fill_tightened_domains_in_response() const {
6292  bool value = (_has_bits_[0] & 0x00400000u) != 0;
6293  return value;
6294 }
6295 inline bool SatParameters::has_fill_tightened_domains_in_response() const {
6296  return _internal_has_fill_tightened_domains_in_response();
6297 }
6298 inline void SatParameters::clear_fill_tightened_domains_in_response() {
6299  fill_tightened_domains_in_response_ = false;
6300  _has_bits_[0] &= ~0x00400000u;
6301 }
6302 inline bool SatParameters::_internal_fill_tightened_domains_in_response() const {
6303  return fill_tightened_domains_in_response_;
6304 }
6305 inline bool SatParameters::fill_tightened_domains_in_response() const {
6306  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.fill_tightened_domains_in_response)
6307  return _internal_fill_tightened_domains_in_response();
6308 }
6309 inline void SatParameters::_internal_set_fill_tightened_domains_in_response(bool value) {
6310  _has_bits_[0] |= 0x00400000u;
6311  fill_tightened_domains_in_response_ = value;
6312 }
6313 inline void SatParameters::set_fill_tightened_domains_in_response(bool value) {
6314  _internal_set_fill_tightened_domains_in_response(value);
6315  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.fill_tightened_domains_in_response)
6316 }
6317 
6318 // optional bool instantiate_all_variables = 106 [default = true];
6319 inline bool SatParameters::_internal_has_instantiate_all_variables() const {
6320  bool value = (_has_bits_[3] & 0x00000002u) != 0;
6321  return value;
6322 }
6323 inline bool SatParameters::has_instantiate_all_variables() const {
6324  return _internal_has_instantiate_all_variables();
6325 }
6326 inline void SatParameters::clear_instantiate_all_variables() {
6327  instantiate_all_variables_ = true;
6328  _has_bits_[3] &= ~0x00000002u;
6329 }
6330 inline bool SatParameters::_internal_instantiate_all_variables() const {
6331  return instantiate_all_variables_;
6332 }
6333 inline bool SatParameters::instantiate_all_variables() const {
6334  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.instantiate_all_variables)
6335  return _internal_instantiate_all_variables();
6336 }
6337 inline void SatParameters::_internal_set_instantiate_all_variables(bool value) {
6338  _has_bits_[3] |= 0x00000002u;
6339  instantiate_all_variables_ = value;
6340 }
6341 inline void SatParameters::set_instantiate_all_variables(bool value) {
6342  _internal_set_instantiate_all_variables(value);
6343  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.instantiate_all_variables)
6344 }
6345 
6346 // optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
6347 inline bool SatParameters::_internal_has_auto_detect_greater_than_at_least_one_of() const {
6348  bool value = (_has_bits_[3] & 0x00000004u) != 0;
6349  return value;
6350 }
6351 inline bool SatParameters::has_auto_detect_greater_than_at_least_one_of() const {
6352  return _internal_has_auto_detect_greater_than_at_least_one_of();
6353 }
6354 inline void SatParameters::clear_auto_detect_greater_than_at_least_one_of() {
6355  auto_detect_greater_than_at_least_one_of_ = true;
6356  _has_bits_[3] &= ~0x00000004u;
6357 }
6358 inline bool SatParameters::_internal_auto_detect_greater_than_at_least_one_of() const {
6359  return auto_detect_greater_than_at_least_one_of_;
6360 }
6361 inline bool SatParameters::auto_detect_greater_than_at_least_one_of() const {
6362  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.auto_detect_greater_than_at_least_one_of)
6363  return _internal_auto_detect_greater_than_at_least_one_of();
6364 }
6365 inline void SatParameters::_internal_set_auto_detect_greater_than_at_least_one_of(bool value) {
6366  _has_bits_[3] |= 0x00000004u;
6367  auto_detect_greater_than_at_least_one_of_ = value;
6368 }
6369 inline void SatParameters::set_auto_detect_greater_than_at_least_one_of(bool value) {
6370  _internal_set_auto_detect_greater_than_at_least_one_of(value);
6371  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.auto_detect_greater_than_at_least_one_of)
6372 }
6373 
6374 // optional bool stop_after_first_solution = 98 [default = false];
6375 inline bool SatParameters::_internal_has_stop_after_first_solution() const {
6376  bool value = (_has_bits_[1] & 0x00000008u) != 0;
6377  return value;
6378 }
6379 inline bool SatParameters::has_stop_after_first_solution() const {
6380  return _internal_has_stop_after_first_solution();
6381 }
6382 inline void SatParameters::clear_stop_after_first_solution() {
6383  stop_after_first_solution_ = false;
6384  _has_bits_[1] &= ~0x00000008u;
6385 }
6386 inline bool SatParameters::_internal_stop_after_first_solution() const {
6387  return stop_after_first_solution_;
6388 }
6389 inline bool SatParameters::stop_after_first_solution() const {
6390  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.stop_after_first_solution)
6391  return _internal_stop_after_first_solution();
6392 }
6393 inline void SatParameters::_internal_set_stop_after_first_solution(bool value) {
6394  _has_bits_[1] |= 0x00000008u;
6395  stop_after_first_solution_ = value;
6396 }
6397 inline void SatParameters::set_stop_after_first_solution(bool value) {
6398  _internal_set_stop_after_first_solution(value);
6399  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.stop_after_first_solution)
6400 }
6401 
6402 // optional bool stop_after_presolve = 149 [default = false];
6403 inline bool SatParameters::_internal_has_stop_after_presolve() const {
6404  bool value = (_has_bits_[1] & 0x00000010u) != 0;
6405  return value;
6406 }
6407 inline bool SatParameters::has_stop_after_presolve() const {
6408  return _internal_has_stop_after_presolve();
6409 }
6410 inline void SatParameters::clear_stop_after_presolve() {
6411  stop_after_presolve_ = false;
6412  _has_bits_[1] &= ~0x00000010u;
6413 }
6414 inline bool SatParameters::_internal_stop_after_presolve() const {
6415  return stop_after_presolve_;
6416 }
6417 inline bool SatParameters::stop_after_presolve() const {
6418  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.stop_after_presolve)
6419  return _internal_stop_after_presolve();
6420 }
6421 inline void SatParameters::_internal_set_stop_after_presolve(bool value) {
6422  _has_bits_[1] |= 0x00000010u;
6423  stop_after_presolve_ = value;
6424 }
6425 inline void SatParameters::set_stop_after_presolve(bool value) {
6426  _internal_set_stop_after_presolve(value);
6427  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.stop_after_presolve)
6428 }
6429 
6430 // optional int32 num_search_workers = 100 [default = 1];
6431 inline bool SatParameters::_internal_has_num_search_workers() const {
6432  bool value = (_has_bits_[2] & 0x80000000u) != 0;
6433  return value;
6434 }
6435 inline bool SatParameters::has_num_search_workers() const {
6436  return _internal_has_num_search_workers();
6437 }
6438 inline void SatParameters::clear_num_search_workers() {
6439  num_search_workers_ = 1;
6440  _has_bits_[2] &= ~0x80000000u;
6441 }
6442 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_num_search_workers() const {
6443  return num_search_workers_;
6444 }
6445 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::num_search_workers() const {
6446  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.num_search_workers)
6447  return _internal_num_search_workers();
6448 }
6449 inline void SatParameters::_internal_set_num_search_workers(::PROTOBUF_NAMESPACE_ID::int32 value) {
6450  _has_bits_[2] |= 0x80000000u;
6451  num_search_workers_ = value;
6452 }
6453 inline void SatParameters::set_num_search_workers(::PROTOBUF_NAMESPACE_ID::int32 value) {
6454  _internal_set_num_search_workers(value);
6455  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.num_search_workers)
6456 }
6457 
6458 // optional bool interleave_search = 136 [default = false];
6459 inline bool SatParameters::_internal_has_interleave_search() const {
6460  bool value = (_has_bits_[1] & 0x00000020u) != 0;
6461  return value;
6462 }
6463 inline bool SatParameters::has_interleave_search() const {
6464  return _internal_has_interleave_search();
6465 }
6466 inline void SatParameters::clear_interleave_search() {
6467  interleave_search_ = false;
6468  _has_bits_[1] &= ~0x00000020u;
6469 }
6470 inline bool SatParameters::_internal_interleave_search() const {
6471  return interleave_search_;
6472 }
6473 inline bool SatParameters::interleave_search() const {
6474  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.interleave_search)
6475  return _internal_interleave_search();
6476 }
6477 inline void SatParameters::_internal_set_interleave_search(bool value) {
6478  _has_bits_[1] |= 0x00000020u;
6479  interleave_search_ = value;
6480 }
6481 inline void SatParameters::set_interleave_search(bool value) {
6482  _internal_set_interleave_search(value);
6483  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.interleave_search)
6484 }
6485 
6486 // optional int32 interleave_batch_size = 134 [default = 1];
6487 inline bool SatParameters::_internal_has_interleave_batch_size() const {
6488  bool value = (_has_bits_[4] & 0x00000001u) != 0;
6489  return value;
6490 }
6491 inline bool SatParameters::has_interleave_batch_size() const {
6492  return _internal_has_interleave_batch_size();
6493 }
6494 inline void SatParameters::clear_interleave_batch_size() {
6495  interleave_batch_size_ = 1;
6496  _has_bits_[4] &= ~0x00000001u;
6497 }
6498 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_interleave_batch_size() const {
6499  return interleave_batch_size_;
6500 }
6501 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::interleave_batch_size() const {
6502  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.interleave_batch_size)
6503  return _internal_interleave_batch_size();
6504 }
6505 inline void SatParameters::_internal_set_interleave_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
6506  _has_bits_[4] |= 0x00000001u;
6507  interleave_batch_size_ = value;
6508 }
6509 inline void SatParameters::set_interleave_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
6510  _internal_set_interleave_batch_size(value);
6511  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.interleave_batch_size)
6512 }
6513 
6514 // optional bool reduce_memory_usage_in_interleave_mode = 141 [default = false];
6515 inline bool SatParameters::_internal_has_reduce_memory_usage_in_interleave_mode() const {
6516  bool value = (_has_bits_[1] & 0x00000040u) != 0;
6517  return value;
6518 }
6519 inline bool SatParameters::has_reduce_memory_usage_in_interleave_mode() const {
6520  return _internal_has_reduce_memory_usage_in_interleave_mode();
6521 }
6522 inline void SatParameters::clear_reduce_memory_usage_in_interleave_mode() {
6523  reduce_memory_usage_in_interleave_mode_ = false;
6524  _has_bits_[1] &= ~0x00000040u;
6525 }
6526 inline bool SatParameters::_internal_reduce_memory_usage_in_interleave_mode() const {
6527  return reduce_memory_usage_in_interleave_mode_;
6528 }
6529 inline bool SatParameters::reduce_memory_usage_in_interleave_mode() const {
6530  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.reduce_memory_usage_in_interleave_mode)
6531  return _internal_reduce_memory_usage_in_interleave_mode();
6532 }
6533 inline void SatParameters::_internal_set_reduce_memory_usage_in_interleave_mode(bool value) {
6534  _has_bits_[1] |= 0x00000040u;
6535  reduce_memory_usage_in_interleave_mode_ = value;
6536 }
6537 inline void SatParameters::set_reduce_memory_usage_in_interleave_mode(bool value) {
6538  _internal_set_reduce_memory_usage_in_interleave_mode(value);
6539  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.reduce_memory_usage_in_interleave_mode)
6540 }
6541 
6542 // optional bool share_objective_bounds = 113 [default = true];
6543 inline bool SatParameters::_internal_has_share_objective_bounds() const {
6544  bool value = (_has_bits_[3] & 0x00000008u) != 0;
6545  return value;
6546 }
6547 inline bool SatParameters::has_share_objective_bounds() const {
6548  return _internal_has_share_objective_bounds();
6549 }
6550 inline void SatParameters::clear_share_objective_bounds() {
6551  share_objective_bounds_ = true;
6552  _has_bits_[3] &= ~0x00000008u;
6553 }
6554 inline bool SatParameters::_internal_share_objective_bounds() const {
6555  return share_objective_bounds_;
6556 }
6557 inline bool SatParameters::share_objective_bounds() const {
6558  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.share_objective_bounds)
6559  return _internal_share_objective_bounds();
6560 }
6561 inline void SatParameters::_internal_set_share_objective_bounds(bool value) {
6562  _has_bits_[3] |= 0x00000008u;
6563  share_objective_bounds_ = value;
6564 }
6565 inline void SatParameters::set_share_objective_bounds(bool value) {
6566  _internal_set_share_objective_bounds(value);
6567  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.share_objective_bounds)
6568 }
6569 
6570 // optional bool share_level_zero_bounds = 114 [default = true];
6571 inline bool SatParameters::_internal_has_share_level_zero_bounds() const {
6572  bool value = (_has_bits_[3] & 0x00000010u) != 0;
6573  return value;
6574 }
6575 inline bool SatParameters::has_share_level_zero_bounds() const {
6576  return _internal_has_share_level_zero_bounds();
6577 }
6578 inline void SatParameters::clear_share_level_zero_bounds() {
6579  share_level_zero_bounds_ = true;
6580  _has_bits_[3] &= ~0x00000010u;
6581 }
6582 inline bool SatParameters::_internal_share_level_zero_bounds() const {
6583  return share_level_zero_bounds_;
6584 }
6585 inline bool SatParameters::share_level_zero_bounds() const {
6586  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.share_level_zero_bounds)
6587  return _internal_share_level_zero_bounds();
6588 }
6589 inline void SatParameters::_internal_set_share_level_zero_bounds(bool value) {
6590  _has_bits_[3] |= 0x00000010u;
6591  share_level_zero_bounds_ = value;
6592 }
6593 inline void SatParameters::set_share_level_zero_bounds(bool value) {
6594  _internal_set_share_level_zero_bounds(value);
6595  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.share_level_zero_bounds)
6596 }
6597 
6598 // optional bool use_lns_only = 101 [default = false];
6599 inline bool SatParameters::_internal_has_use_lns_only() const {
6600  bool value = (_has_bits_[0] & 0x10000000u) != 0;
6601  return value;
6602 }
6603 inline bool SatParameters::has_use_lns_only() const {
6604  return _internal_has_use_lns_only();
6605 }
6606 inline void SatParameters::clear_use_lns_only() {
6607  use_lns_only_ = false;
6608  _has_bits_[0] &= ~0x10000000u;
6609 }
6610 inline bool SatParameters::_internal_use_lns_only() const {
6611  return use_lns_only_;
6612 }
6613 inline bool SatParameters::use_lns_only() const {
6614  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_lns_only)
6615  return _internal_use_lns_only();
6616 }
6617 inline void SatParameters::_internal_set_use_lns_only(bool value) {
6618  _has_bits_[0] |= 0x10000000u;
6619  use_lns_only_ = value;
6620 }
6621 inline void SatParameters::set_use_lns_only(bool value) {
6622  _internal_set_use_lns_only(value);
6623  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_lns_only)
6624 }
6625 
6626 // optional bool lns_focus_on_decision_variables = 105 [default = false];
6627 inline bool SatParameters::_internal_has_lns_focus_on_decision_variables() const {
6628  bool value = (_has_bits_[0] & 0x20000000u) != 0;
6629  return value;
6630 }
6631 inline bool SatParameters::has_lns_focus_on_decision_variables() const {
6632  return _internal_has_lns_focus_on_decision_variables();
6633 }
6634 inline void SatParameters::clear_lns_focus_on_decision_variables() {
6635  lns_focus_on_decision_variables_ = false;
6636  _has_bits_[0] &= ~0x20000000u;
6637 }
6638 inline bool SatParameters::_internal_lns_focus_on_decision_variables() const {
6639  return lns_focus_on_decision_variables_;
6640 }
6641 inline bool SatParameters::lns_focus_on_decision_variables() const {
6642  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.lns_focus_on_decision_variables)
6643  return _internal_lns_focus_on_decision_variables();
6644 }
6645 inline void SatParameters::_internal_set_lns_focus_on_decision_variables(bool value) {
6646  _has_bits_[0] |= 0x20000000u;
6647  lns_focus_on_decision_variables_ = value;
6648 }
6649 inline void SatParameters::set_lns_focus_on_decision_variables(bool value) {
6650  _internal_set_lns_focus_on_decision_variables(value);
6651  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.lns_focus_on_decision_variables)
6652 }
6653 
6654 // optional bool use_rins_lns = 129 [default = true];
6655 inline bool SatParameters::_internal_has_use_rins_lns() const {
6656  bool value = (_has_bits_[3] & 0x08000000u) != 0;
6657  return value;
6658 }
6659 inline bool SatParameters::has_use_rins_lns() const {
6660  return _internal_has_use_rins_lns();
6661 }
6662 inline void SatParameters::clear_use_rins_lns() {
6663  use_rins_lns_ = true;
6664  _has_bits_[3] &= ~0x08000000u;
6665 }
6666 inline bool SatParameters::_internal_use_rins_lns() const {
6667  return use_rins_lns_;
6668 }
6669 inline bool SatParameters::use_rins_lns() const {
6670  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_rins_lns)
6671  return _internal_use_rins_lns();
6672 }
6673 inline void SatParameters::_internal_set_use_rins_lns(bool value) {
6674  _has_bits_[3] |= 0x08000000u;
6675  use_rins_lns_ = value;
6676 }
6677 inline void SatParameters::set_use_rins_lns(bool value) {
6678  _internal_set_use_rins_lns(value);
6679  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_rins_lns)
6680 }
6681 
6682 // optional bool use_feasibility_pump = 164 [default = true];
6683 inline bool SatParameters::_internal_has_use_feasibility_pump() const {
6684  bool value = (_has_bits_[3] & 0x10000000u) != 0;
6685  return value;
6686 }
6687 inline bool SatParameters::has_use_feasibility_pump() const {
6688  return _internal_has_use_feasibility_pump();
6689 }
6690 inline void SatParameters::clear_use_feasibility_pump() {
6691  use_feasibility_pump_ = true;
6692  _has_bits_[3] &= ~0x10000000u;
6693 }
6694 inline bool SatParameters::_internal_use_feasibility_pump() const {
6695  return use_feasibility_pump_;
6696 }
6697 inline bool SatParameters::use_feasibility_pump() const {
6698  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_feasibility_pump)
6699  return _internal_use_feasibility_pump();
6700 }
6701 inline void SatParameters::_internal_set_use_feasibility_pump(bool value) {
6702  _has_bits_[3] |= 0x10000000u;
6703  use_feasibility_pump_ = value;
6704 }
6705 inline void SatParameters::set_use_feasibility_pump(bool value) {
6706  _internal_set_use_feasibility_pump(value);
6707  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_feasibility_pump)
6708 }
6709 
6710 // optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
6711 inline bool SatParameters::_internal_has_fp_rounding() const {
6712  bool value = (_has_bits_[4] & 0x00004000u) != 0;
6713  return value;
6714 }
6715 inline bool SatParameters::has_fp_rounding() const {
6716  return _internal_has_fp_rounding();
6717 }
6718 inline void SatParameters::clear_fp_rounding() {
6719  fp_rounding_ = 2;
6720  _has_bits_[4] &= ~0x00004000u;
6721 }
6722 inline ::operations_research::sat::SatParameters_FPRoundingMethod SatParameters::_internal_fp_rounding() const {
6723  return static_cast< ::operations_research::sat::SatParameters_FPRoundingMethod >(fp_rounding_);
6724 }
6725 inline ::operations_research::sat::SatParameters_FPRoundingMethod SatParameters::fp_rounding() const {
6726  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.fp_rounding)
6727  return _internal_fp_rounding();
6728 }
6729 inline void SatParameters::_internal_set_fp_rounding(::operations_research::sat::SatParameters_FPRoundingMethod value) {
6730  assert(::operations_research::sat::SatParameters_FPRoundingMethod_IsValid(value));
6731  _has_bits_[4] |= 0x00004000u;
6732  fp_rounding_ = value;
6733 }
6734 inline void SatParameters::set_fp_rounding(::operations_research::sat::SatParameters_FPRoundingMethod value) {
6735  _internal_set_fp_rounding(value);
6736  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.fp_rounding)
6737 }
6738 
6739 // optional bool use_relaxation_lns = 150 [default = false];
6740 inline bool SatParameters::_internal_has_use_relaxation_lns() const {
6741  bool value = (_has_bits_[0] & 0x40000000u) != 0;
6742  return value;
6743 }
6744 inline bool SatParameters::has_use_relaxation_lns() const {
6745  return _internal_has_use_relaxation_lns();
6746 }
6747 inline void SatParameters::clear_use_relaxation_lns() {
6748  use_relaxation_lns_ = false;
6749  _has_bits_[0] &= ~0x40000000u;
6750 }
6751 inline bool SatParameters::_internal_use_relaxation_lns() const {
6752  return use_relaxation_lns_;
6753 }
6754 inline bool SatParameters::use_relaxation_lns() const {
6755  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_relaxation_lns)
6756  return _internal_use_relaxation_lns();
6757 }
6758 inline void SatParameters::_internal_set_use_relaxation_lns(bool value) {
6759  _has_bits_[0] |= 0x40000000u;
6760  use_relaxation_lns_ = value;
6761 }
6762 inline void SatParameters::set_use_relaxation_lns(bool value) {
6763  _internal_set_use_relaxation_lns(value);
6764  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_relaxation_lns)
6765 }
6766 
6767 // optional bool diversify_lns_params = 137 [default = false];
6768 inline bool SatParameters::_internal_has_diversify_lns_params() const {
6769  bool value = (_has_bits_[0] & 0x80000000u) != 0;
6770  return value;
6771 }
6772 inline bool SatParameters::has_diversify_lns_params() const {
6773  return _internal_has_diversify_lns_params();
6774 }
6775 inline void SatParameters::clear_diversify_lns_params() {
6776  diversify_lns_params_ = false;
6777  _has_bits_[0] &= ~0x80000000u;
6778 }
6779 inline bool SatParameters::_internal_diversify_lns_params() const {
6780  return diversify_lns_params_;
6781 }
6782 inline bool SatParameters::diversify_lns_params() const {
6783  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.diversify_lns_params)
6784  return _internal_diversify_lns_params();
6785 }
6786 inline void SatParameters::_internal_set_diversify_lns_params(bool value) {
6787  _has_bits_[0] |= 0x80000000u;
6788  diversify_lns_params_ = value;
6789 }
6790 inline void SatParameters::set_diversify_lns_params(bool value) {
6791  _internal_set_diversify_lns_params(value);
6792  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.diversify_lns_params)
6793 }
6794 
6795 // optional bool randomize_search = 103 [default = false];
6796 inline bool SatParameters::_internal_has_randomize_search() const {
6797  bool value = (_has_bits_[1] & 0x00000001u) != 0;
6798  return value;
6799 }
6800 inline bool SatParameters::has_randomize_search() const {
6801  return _internal_has_randomize_search();
6802 }
6803 inline void SatParameters::clear_randomize_search() {
6804  randomize_search_ = false;
6805  _has_bits_[1] &= ~0x00000001u;
6806 }
6807 inline bool SatParameters::_internal_randomize_search() const {
6808  return randomize_search_;
6809 }
6810 inline bool SatParameters::randomize_search() const {
6811  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.randomize_search)
6812  return _internal_randomize_search();
6813 }
6814 inline void SatParameters::_internal_set_randomize_search(bool value) {
6815  _has_bits_[1] |= 0x00000001u;
6816  randomize_search_ = value;
6817 }
6818 inline void SatParameters::set_randomize_search(bool value) {
6819  _internal_set_randomize_search(value);
6820  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.randomize_search)
6821 }
6822 
6823 // optional int64 search_randomization_tolerance = 104 [default = 0];
6824 inline bool SatParameters::_internal_has_search_randomization_tolerance() const {
6825  bool value = (_has_bits_[0] & 0x08000000u) != 0;
6826  return value;
6827 }
6828 inline bool SatParameters::has_search_randomization_tolerance() const {
6829  return _internal_has_search_randomization_tolerance();
6830 }
6831 inline void SatParameters::clear_search_randomization_tolerance() {
6832  search_randomization_tolerance_ = PROTOBUF_LONGLONG(0);
6833  _has_bits_[0] &= ~0x08000000u;
6834 }
6835 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::_internal_search_randomization_tolerance() const {
6836  return search_randomization_tolerance_;
6837 }
6838 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::search_randomization_tolerance() const {
6839  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.search_randomization_tolerance)
6840  return _internal_search_randomization_tolerance();
6841 }
6842 inline void SatParameters::_internal_set_search_randomization_tolerance(::PROTOBUF_NAMESPACE_ID::int64 value) {
6843  _has_bits_[0] |= 0x08000000u;
6844  search_randomization_tolerance_ = value;
6845 }
6846 inline void SatParameters::set_search_randomization_tolerance(::PROTOBUF_NAMESPACE_ID::int64 value) {
6847  _internal_set_search_randomization_tolerance(value);
6848  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.search_randomization_tolerance)
6849 }
6850 
6851 // optional bool use_optional_variables = 108 [default = true];
6852 inline bool SatParameters::_internal_has_use_optional_variables() const {
6853  bool value = (_has_bits_[3] & 0x20000000u) != 0;
6854  return value;
6855 }
6856 inline bool SatParameters::has_use_optional_variables() const {
6857  return _internal_has_use_optional_variables();
6858 }
6859 inline void SatParameters::clear_use_optional_variables() {
6860  use_optional_variables_ = true;
6861  _has_bits_[3] &= ~0x20000000u;
6862 }
6863 inline bool SatParameters::_internal_use_optional_variables() const {
6864  return use_optional_variables_;
6865 }
6866 inline bool SatParameters::use_optional_variables() const {
6867  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_optional_variables)
6868  return _internal_use_optional_variables();
6869 }
6870 inline void SatParameters::_internal_set_use_optional_variables(bool value) {
6871  _has_bits_[3] |= 0x20000000u;
6872  use_optional_variables_ = value;
6873 }
6874 inline void SatParameters::set_use_optional_variables(bool value) {
6875  _internal_set_use_optional_variables(value);
6876  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_optional_variables)
6877 }
6878 
6879 // optional bool use_exact_lp_reason = 109 [default = true];
6880 inline bool SatParameters::_internal_has_use_exact_lp_reason() const {
6881  bool value = (_has_bits_[3] & 0x40000000u) != 0;
6882  return value;
6883 }
6884 inline bool SatParameters::has_use_exact_lp_reason() const {
6885  return _internal_has_use_exact_lp_reason();
6886 }
6887 inline void SatParameters::clear_use_exact_lp_reason() {
6888  use_exact_lp_reason_ = true;
6889  _has_bits_[3] &= ~0x40000000u;
6890 }
6891 inline bool SatParameters::_internal_use_exact_lp_reason() const {
6892  return use_exact_lp_reason_;
6893 }
6894 inline bool SatParameters::use_exact_lp_reason() const {
6895  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_exact_lp_reason)
6896  return _internal_use_exact_lp_reason();
6897 }
6898 inline void SatParameters::_internal_set_use_exact_lp_reason(bool value) {
6899  _has_bits_[3] |= 0x40000000u;
6900  use_exact_lp_reason_ = value;
6901 }
6902 inline void SatParameters::set_use_exact_lp_reason(bool value) {
6903  _internal_set_use_exact_lp_reason(value);
6904  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_exact_lp_reason)
6905 }
6906 
6907 // optional bool use_branching_in_lp = 139 [default = false];
6908 inline bool SatParameters::_internal_has_use_branching_in_lp() const {
6909  bool value = (_has_bits_[1] & 0x00000002u) != 0;
6910  return value;
6911 }
6912 inline bool SatParameters::has_use_branching_in_lp() const {
6913  return _internal_has_use_branching_in_lp();
6914 }
6915 inline void SatParameters::clear_use_branching_in_lp() {
6916  use_branching_in_lp_ = false;
6917  _has_bits_[1] &= ~0x00000002u;
6918 }
6919 inline bool SatParameters::_internal_use_branching_in_lp() const {
6920  return use_branching_in_lp_;
6921 }
6922 inline bool SatParameters::use_branching_in_lp() const {
6923  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_branching_in_lp)
6924  return _internal_use_branching_in_lp();
6925 }
6926 inline void SatParameters::_internal_set_use_branching_in_lp(bool value) {
6927  _has_bits_[1] |= 0x00000002u;
6928  use_branching_in_lp_ = value;
6929 }
6930 inline void SatParameters::set_use_branching_in_lp(bool value) {
6931  _internal_set_use_branching_in_lp(value);
6932  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_branching_in_lp)
6933 }
6934 
6935 // optional bool use_combined_no_overlap = 133 [default = false];
6936 inline bool SatParameters::_internal_has_use_combined_no_overlap() const {
6937  bool value = (_has_bits_[1] & 0x00000004u) != 0;
6938  return value;
6939 }
6940 inline bool SatParameters::has_use_combined_no_overlap() const {
6941  return _internal_has_use_combined_no_overlap();
6942 }
6943 inline void SatParameters::clear_use_combined_no_overlap() {
6944  use_combined_no_overlap_ = false;
6945  _has_bits_[1] &= ~0x00000004u;
6946 }
6947 inline bool SatParameters::_internal_use_combined_no_overlap() const {
6948  return use_combined_no_overlap_;
6949 }
6950 inline bool SatParameters::use_combined_no_overlap() const {
6951  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_combined_no_overlap)
6952  return _internal_use_combined_no_overlap();
6953 }
6954 inline void SatParameters::_internal_set_use_combined_no_overlap(bool value) {
6955  _has_bits_[1] |= 0x00000004u;
6956  use_combined_no_overlap_ = value;
6957 }
6958 inline void SatParameters::set_use_combined_no_overlap(bool value) {
6959  _internal_set_use_combined_no_overlap(value);
6960  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_combined_no_overlap)
6961 }
6962 
6963 // optional bool catch_sigint_signal = 135 [default = true];
6964 inline bool SatParameters::_internal_has_catch_sigint_signal() const {
6965  bool value = (_has_bits_[4] & 0x00000040u) != 0;
6966  return value;
6967 }
6968 inline bool SatParameters::has_catch_sigint_signal() const {
6969  return _internal_has_catch_sigint_signal();
6970 }
6971 inline void SatParameters::clear_catch_sigint_signal() {
6972  catch_sigint_signal_ = true;
6973  _has_bits_[4] &= ~0x00000040u;
6974 }
6975 inline bool SatParameters::_internal_catch_sigint_signal() const {
6976  return catch_sigint_signal_;
6977 }
6978 inline bool SatParameters::catch_sigint_signal() const {
6979  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.catch_sigint_signal)
6980  return _internal_catch_sigint_signal();
6981 }
6982 inline void SatParameters::_internal_set_catch_sigint_signal(bool value) {
6983  _has_bits_[4] |= 0x00000040u;
6984  catch_sigint_signal_ = value;
6985 }
6986 inline void SatParameters::set_catch_sigint_signal(bool value) {
6987  _internal_set_catch_sigint_signal(value);
6988  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.catch_sigint_signal)
6989 }
6990 
6991 // optional bool use_implied_bounds = 144 [default = true];
6992 inline bool SatParameters::_internal_has_use_implied_bounds() const {
6993  bool value = (_has_bits_[4] & 0x00000080u) != 0;
6994  return value;
6995 }
6996 inline bool SatParameters::has_use_implied_bounds() const {
6997  return _internal_has_use_implied_bounds();
6998 }
6999 inline void SatParameters::clear_use_implied_bounds() {
7000  use_implied_bounds_ = true;
7001  _has_bits_[4] &= ~0x00000080u;
7002 }
7003 inline bool SatParameters::_internal_use_implied_bounds() const {
7004  return use_implied_bounds_;
7005 }
7006 inline bool SatParameters::use_implied_bounds() const {
7007  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_implied_bounds)
7008  return _internal_use_implied_bounds();
7009 }
7010 inline void SatParameters::_internal_set_use_implied_bounds(bool value) {
7011  _has_bits_[4] |= 0x00000080u;
7012  use_implied_bounds_ = value;
7013 }
7014 inline void SatParameters::set_use_implied_bounds(bool value) {
7015  _internal_set_use_implied_bounds(value);
7016  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_implied_bounds)
7017 }
7018 
7019 // optional double mip_max_bound = 124 [default = 10000000];
7020 inline bool SatParameters::_internal_has_mip_max_bound() const {
7021  bool value = (_has_bits_[3] & 0x00800000u) != 0;
7022  return value;
7023 }
7024 inline bool SatParameters::has_mip_max_bound() const {
7025  return _internal_has_mip_max_bound();
7026 }
7027 inline void SatParameters::clear_mip_max_bound() {
7028  mip_max_bound_ = 10000000;
7029  _has_bits_[3] &= ~0x00800000u;
7030 }
7031 inline double SatParameters::_internal_mip_max_bound() const {
7032  return mip_max_bound_;
7033 }
7034 inline double SatParameters::mip_max_bound() const {
7035  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_max_bound)
7036  return _internal_mip_max_bound();
7037 }
7038 inline void SatParameters::_internal_set_mip_max_bound(double value) {
7039  _has_bits_[3] |= 0x00800000u;
7040  mip_max_bound_ = value;
7041 }
7042 inline void SatParameters::set_mip_max_bound(double value) {
7043  _internal_set_mip_max_bound(value);
7044  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_max_bound)
7045 }
7046 
7047 // optional double mip_var_scaling = 125 [default = 1];
7048 inline bool SatParameters::_internal_has_mip_var_scaling() const {
7049  bool value = (_has_bits_[3] & 0x01000000u) != 0;
7050  return value;
7051 }
7052 inline bool SatParameters::has_mip_var_scaling() const {
7053  return _internal_has_mip_var_scaling();
7054 }
7055 inline void SatParameters::clear_mip_var_scaling() {
7056  mip_var_scaling_ = 1;
7057  _has_bits_[3] &= ~0x01000000u;
7058 }
7059 inline double SatParameters::_internal_mip_var_scaling() const {
7060  return mip_var_scaling_;
7061 }
7062 inline double SatParameters::mip_var_scaling() const {
7063  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_var_scaling)
7064  return _internal_mip_var_scaling();
7065 }
7066 inline void SatParameters::_internal_set_mip_var_scaling(double value) {
7067  _has_bits_[3] |= 0x01000000u;
7068  mip_var_scaling_ = value;
7069 }
7070 inline void SatParameters::set_mip_var_scaling(double value) {
7071  _internal_set_mip_var_scaling(value);
7072  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_var_scaling)
7073 }
7074 
7075 // optional bool mip_automatically_scale_variables = 166 [default = true];
7076 inline bool SatParameters::_internal_has_mip_automatically_scale_variables() const {
7077  bool value = (_has_bits_[4] & 0x00000100u) != 0;
7078  return value;
7079 }
7080 inline bool SatParameters::has_mip_automatically_scale_variables() const {
7081  return _internal_has_mip_automatically_scale_variables();
7082 }
7083 inline void SatParameters::clear_mip_automatically_scale_variables() {
7084  mip_automatically_scale_variables_ = true;
7085  _has_bits_[4] &= ~0x00000100u;
7086 }
7087 inline bool SatParameters::_internal_mip_automatically_scale_variables() const {
7088  return mip_automatically_scale_variables_;
7089 }
7090 inline bool SatParameters::mip_automatically_scale_variables() const {
7091  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_automatically_scale_variables)
7092  return _internal_mip_automatically_scale_variables();
7093 }
7094 inline void SatParameters::_internal_set_mip_automatically_scale_variables(bool value) {
7095  _has_bits_[4] |= 0x00000100u;
7096  mip_automatically_scale_variables_ = value;
7097 }
7098 inline void SatParameters::set_mip_automatically_scale_variables(bool value) {
7099  _internal_set_mip_automatically_scale_variables(value);
7100  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_automatically_scale_variables)
7101 }
7102 
7103 // optional double mip_wanted_precision = 126 [default = 1e-06];
7104 inline bool SatParameters::_internal_has_mip_wanted_precision() const {
7105  bool value = (_has_bits_[3] & 0x02000000u) != 0;
7106  return value;
7107 }
7108 inline bool SatParameters::has_mip_wanted_precision() const {
7109  return _internal_has_mip_wanted_precision();
7110 }
7111 inline void SatParameters::clear_mip_wanted_precision() {
7112  mip_wanted_precision_ = 1e-06;
7113  _has_bits_[3] &= ~0x02000000u;
7114 }
7115 inline double SatParameters::_internal_mip_wanted_precision() const {
7116  return mip_wanted_precision_;
7117 }
7118 inline double SatParameters::mip_wanted_precision() const {
7119  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_wanted_precision)
7120  return _internal_mip_wanted_precision();
7121 }
7122 inline void SatParameters::_internal_set_mip_wanted_precision(double value) {
7123  _has_bits_[3] |= 0x02000000u;
7124  mip_wanted_precision_ = value;
7125 }
7126 inline void SatParameters::set_mip_wanted_precision(double value) {
7127  _internal_set_mip_wanted_precision(value);
7128  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_wanted_precision)
7129 }
7130 
7131 // optional int32 mip_max_activity_exponent = 127 [default = 53];
7132 inline bool SatParameters::_internal_has_mip_max_activity_exponent() const {
7133  bool value = (_has_bits_[3] & 0x04000000u) != 0;
7134  return value;
7135 }
7136 inline bool SatParameters::has_mip_max_activity_exponent() const {
7137  return _internal_has_mip_max_activity_exponent();
7138 }
7139 inline void SatParameters::clear_mip_max_activity_exponent() {
7140  mip_max_activity_exponent_ = 53;
7141  _has_bits_[3] &= ~0x04000000u;
7142 }
7143 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_mip_max_activity_exponent() const {
7144  return mip_max_activity_exponent_;
7145 }
7146 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::mip_max_activity_exponent() const {
7147  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_max_activity_exponent)
7148  return _internal_mip_max_activity_exponent();
7149 }
7150 inline void SatParameters::_internal_set_mip_max_activity_exponent(::PROTOBUF_NAMESPACE_ID::int32 value) {
7151  _has_bits_[3] |= 0x04000000u;
7152  mip_max_activity_exponent_ = value;
7153 }
7154 inline void SatParameters::set_mip_max_activity_exponent(::PROTOBUF_NAMESPACE_ID::int32 value) {
7155  _internal_set_mip_max_activity_exponent(value);
7156  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_max_activity_exponent)
7157 }
7158 
7159 // optional double mip_check_precision = 128 [default = 0.0001];
7160 inline bool SatParameters::_internal_has_mip_check_precision() const {
7161  bool value = (_has_bits_[3] & 0x80000000u) != 0;
7162  return value;
7163 }
7164 inline bool SatParameters::has_mip_check_precision() const {
7165  return _internal_has_mip_check_precision();
7166 }
7167 inline void SatParameters::clear_mip_check_precision() {
7168  mip_check_precision_ = 0.0001;
7169  _has_bits_[3] &= ~0x80000000u;
7170 }
7171 inline double SatParameters::_internal_mip_check_precision() const {
7172  return mip_check_precision_;
7173 }
7174 inline double SatParameters::mip_check_precision() const {
7175  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_check_precision)
7176  return _internal_mip_check_precision();
7177 }
7178 inline void SatParameters::_internal_set_mip_check_precision(double value) {
7179  _has_bits_[3] |= 0x80000000u;
7180  mip_check_precision_ = value;
7181 }
7182 inline void SatParameters::set_mip_check_precision(double value) {
7183  _internal_set_mip_check_precision(value);
7184  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_check_precision)
7185 }
7186 
7187 #ifdef __GNUC__
7188  #pragma GCC diagnostic pop
7189 #endif // __GNUC__
7190 
7191 // @@protoc_insertion_point(namespace_scope)
7192 
7193 } // namespace sat
7194 } // namespace operations_research
7195 
7196 PROTOBUF_NAMESPACE_OPEN
7197 
7198 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_VariableOrder> : ::std::true_type {};
7199 template <>
7200 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_VariableOrder>() {
7201  return ::operations_research::sat::SatParameters_VariableOrder_descriptor();
7202 }
7203 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_Polarity> : ::std::true_type {};
7204 template <>
7205 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_Polarity>() {
7206  return ::operations_research::sat::SatParameters_Polarity_descriptor();
7207 }
7208 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm> : ::std::true_type {};
7209 template <>
7210 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm>() {
7211  return ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_descriptor();
7212 }
7213 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm> : ::std::true_type {};
7214 template <>
7215 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm>() {
7216  return ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm_descriptor();
7217 }
7218 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_ClauseProtection> : ::std::true_type {};
7219 template <>
7220 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_ClauseProtection>() {
7221  return ::operations_research::sat::SatParameters_ClauseProtection_descriptor();
7222 }
7223 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_ClauseOrdering> : ::std::true_type {};
7224 template <>
7225 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_ClauseOrdering>() {
7226  return ::operations_research::sat::SatParameters_ClauseOrdering_descriptor();
7227 }
7228 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_RestartAlgorithm> : ::std::true_type {};
7229 template <>
7230 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_RestartAlgorithm>() {
7231  return ::operations_research::sat::SatParameters_RestartAlgorithm_descriptor();
7232 }
7233 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_MaxSatAssumptionOrder> : ::std::true_type {};
7234 template <>
7235 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_MaxSatAssumptionOrder>() {
7236  return ::operations_research::sat::SatParameters_MaxSatAssumptionOrder_descriptor();
7237 }
7238 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm> : ::std::true_type {};
7239 template <>
7240 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm>() {
7241  return ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_descriptor();
7242 }
7243 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_SearchBranching> : ::std::true_type {};
7244 template <>
7245 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_SearchBranching>() {
7246  return ::operations_research::sat::SatParameters_SearchBranching_descriptor();
7247 }
7248 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_FPRoundingMethod> : ::std::true_type {};
7249 template <>
7250 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_FPRoundingMethod>() {
7251  return ::operations_research::sat::SatParameters_FPRoundingMethod_descriptor();
7252 }
7253 
7254 PROTOBUF_NAMESPACE_CLOSE
7255 
7256 // @@protoc_insertion_point(global_scope)
7257 
7258 #include <google/protobuf/port_undef.inc>
7259 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_ortools_2fsat_2fsat_5fparameters_2eproto
operations_research::sat::PROTOBUF_FINAL::has_add_cg_cuts
bool has_add_cg_cuts() const
operations_research::sat::PROTOBUF_FINAL::exploit_relaxation_solution
bool exploit_relaxation_solution() const
operations_research::sat::PROTOBUF_FINAL::clear_pb_cleanup_ratio
void clear_pb_cleanup_ratio()
operations_research::sat::PROTOBUF_FINAL::swap
friend void swap(SatParameters &a, SatParameters &b)
Definition: sat_parameters.pb.h:399
operations_research::sat::PROTOBUF_FINAL::has_subsumption_during_conflict_analysis
bool has_subsumption_during_conflict_analysis() const
operations_research::sat::PROTOBUF_FINAL::operator=
SatParameters & operator=(SatParameters &&from) noexcept
Definition: sat_parameters.pb.h:364
operations_research::sat::PROTOBUF_FINAL::SatParameters
SatParameters(::PROTOBUF_NAMESPACE_ID::Arena *arena)
operations_research::sat::SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_DEPTH
@ SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_DEPTH
Definition: sat_parameters.pb.h:247
operations_research::sat::PROTOBUF_FINAL::set_cut_active_count_decay
void set_cut_active_count_decay(double value)
operations_research::sat::PROTOBUF_FINAL::clear_num_search_workers
void clear_num_search_workers()
operations_research::sat::PROTOBUF_FINAL::clear_minimize_with_propagation_num_decisions
void clear_minimize_with_propagation_num_decisions()
operations_research::sat::PROTOBUF_FINAL::use_implied_bounds
bool use_implied_bounds() const
operations_research::sat::PROTOBUF_FINAL::has_expand_element_constraints
bool has_expand_element_constraints() const
operations_research::sat::PROTOBUF_FINAL::ClauseOrdering
SatParameters_ClauseOrdering ClauseOrdering
Definition: sat_parameters.pb.h:635
operations_research::sat::PROTOBUF_FINAL::has_restart_dl_average_ratio
bool has_restart_dl_average_ratio() const
operations_research::sat::PROTOBUF_FINAL::clear_count_assumption_levels_in_lbd
void clear_count_assumption_levels_in_lbd()
operations_research::sat::PROTOBUF_FINAL::set_absolute_gap_limit
void set_absolute_gap_limit(double value)
operations_research::sat::PROTOBUF_FINAL::set_preferred_variable_order
void set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value)
operations_research::sat::PROTOBUF_FINAL::SearchBranching_Parse
static bool SearchBranching_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SearchBranching *value)
Definition: sat_parameters.pb.h:800
operations_research::sat::PROTOBUF_FINAL::set_stop_after_presolve
void set_stop_after_presolve(bool value)
operations_research::sat::PROTOBUF_FINAL::repair_hint
bool repair_hint() const
operations_research::sat::SatParameters_ClauseProtection_ClauseProtection_MAX
constexpr SatParameters_ClauseProtection SatParameters_ClauseProtection_ClauseProtection_MAX
Definition: sat_parameters.pb.h:179
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_EXPERIMENTAL
@ SatParameters_ConflictMinimizationAlgorithm_EXPERIMENTAL
Definition: sat_parameters.pb.h:125
operations_research::sat::PROTOBUF_FINAL::set_subsumption_during_conflict_analysis
void set_subsumption_during_conflict_analysis(bool value)
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MIN
constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MIN
Definition: sat_parameters.pb.h:128
operations_research::sat::PROTOBUF_FINAL::has_merge_no_overlap_work_limit
bool has_merge_no_overlap_work_limit() const
operations_research::sat::PROTOBUF_FINAL::clear_max_consecutive_inactive_count
void clear_max_consecutive_inactive_count()
operations_research::sat::SatParameters_Polarity_Polarity_MAX
constexpr SatParameters_Polarity SatParameters_Polarity_Polarity_MAX
Definition: sat_parameters.pb.h:104
operations_research::sat::PROTOBUF_FINAL::set_stop_after_first_solution
void set_stop_after_first_solution(bool value)
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MAX
constexpr SatParameters_BinaryMinizationAlgorithm SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MAX
Definition: sat_parameters.pb.h:155
operations_research::sat::PROTOBUF_FINAL::polarity_rephase_increment
::PROTOBUF_NAMESPACE_ID::int32 polarity_rephase_increment() const
operations_research::sat::PROTOBUF_FINAL::has_use_timetable_edge_finding_in_cumulative_constraint
bool has_use_timetable_edge_finding_in_cumulative_constraint() const
operations_research::sat::SatParameters_Polarity_Name
const std::string & SatParameters_Polarity_Name(T enum_t_value)
Definition: sat_parameters.pb.h:109
operations_research::sat::SatParameters_SearchBranching_AUTOMATIC_SEARCH
@ SatParameters_SearchBranching_AUTOMATIC_SEARCH
Definition: sat_parameters.pb.h:294
operations_research::sat::PROTOBUF_FINAL::has_restart_lbd_average_ratio
bool has_restart_lbd_average_ratio() const
operations_research::sat::PROTOBUF_FINAL::restart_algorithms_size
int restart_algorithms_size() const
operations_research::sat::SatParameters_ClauseProtection_ClauseProtection_ARRAYSIZE
constexpr int SatParameters_ClauseProtection_ClauseProtection_ARRAYSIZE
Definition: sat_parameters.pb.h:180
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_Parse
bool SatParameters_MaxSatStratificationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_MaxSatStratificationAlgorithm *value)
Definition: sat_parameters.pb.h:288
operations_research::sat::PROTOBUF_FINAL::set_max_sat_assumption_order
void set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value)
operations_research::sat::PROTOBUF_FINAL::clear_max_number_of_conflicts
void clear_max_number_of_conflicts()
operations_research::sat::SatParameters_ClauseProtection
SatParameters_ClauseProtection
Definition: sat_parameters.pb.h:172
operations_research::sat::PROTOBUF_FINAL::clear_pb_cleanup_increment
void clear_pb_cleanup_increment()
operations_research::sat::PROTOBUF_FINAL::clear_use_precedences_in_disjunctive_constraint
void clear_use_precedences_in_disjunctive_constraint()
operations_research::sat::PROTOBUF_FINAL::clear_subsumption_during_conflict_analysis
void clear_subsumption_during_conflict_analysis()
operations_research::sat::PROTOBUF_FINAL::has_use_phase_saving
bool has_use_phase_saving() const
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_ARRAYSIZE
constexpr int SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_ARRAYSIZE
Definition: sat_parameters.pb.h:156
operations_research::sat::PROTOBUF_FINAL::has_num_search_workers
bool has_num_search_workers() const
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_Parse
bool SatParameters_ConflictMinimizationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_ConflictMinimizationAlgorithm *value)
Definition: sat_parameters.pb.h:141
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MIN
constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MIN
Definition: sat_parameters.pb.h:275
operations_research::sat::PROTOBUF_FINAL::has_pb_cleanup_increment
bool has_pb_cleanup_increment() const
operations_research::sat::PROTOBUF_FINAL::set_random_polarity_ratio
void set_random_polarity_ratio(double value)
operations_research::sat::PROTOBUF_FINAL::set_add_knapsack_cuts
void set_add_knapsack_cuts(bool value)
operations_research::sat::SatParameters_MaxSatAssumptionOrder_IsValid
bool SatParameters_MaxSatAssumptionOrder_IsValid(int value)
operations_research::sat::PROTOBUF_FINAL::presolve_use_bva
bool presolve_use_bva() const
operations_research::sat::PROTOBUF_FINAL::BinaryMinizationAlgorithm_IsValid
static bool BinaryMinizationAlgorithm_IsValid(int value)
Definition: sat_parameters.pb.h:578
operations_research::sat::PROTOBUF_FINAL::GetMetadata
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final
operations_research::sat::PROTOBUF_FINAL::has_stop_after_presolve
bool has_stop_after_presolve() const
operations_research::sat::PROTOBUF_FINAL::MaxSatStratificationAlgorithm_Name
static const std::string & MaxSatStratificationAlgorithm_Name(T enum_t_value)
Definition: sat_parameters.pb.h:754
operations_research::sat::PROTOBUF_FINAL::set_exploit_best_solution
void set_exploit_best_solution(bool value)
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST
@ SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST
Definition: sat_parameters.pb.h:148
operations_research::sat::PROTOBUF_FINAL::random_seed
::PROTOBUF_NAMESPACE_ID::int32 random_seed() const
operations_research::sat::PROTOBUF_FINAL::set_cp_model_presolve
void set_cp_model_presolve(bool value)
operations_research::sat::PROTOBUF_FINAL::catch_sigint_signal
bool catch_sigint_signal() const
operations_research::sat::PROTOBUF_FINAL::ClauseProtection_Parse
static bool ClauseProtection_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClauseProtection *value)
Definition: sat_parameters.pb.h:630
operations_research::sat::PROTOBUF_FINAL::clear_presolve_probing_deterministic_time_limit
void clear_presolve_probing_deterministic_time_limit()
operations_research::sat::PROTOBUF_FINAL::binary_search_num_conflicts
::PROTOBUF_NAMESPACE_ID::int32 binary_search_num_conflicts() const
operations_research::sat::PROTOBUF_FINAL::unknown_fields
const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet & unknown_fields() const
Definition: sat_parameters.pb.h:373
operations_research::sat::PROTOBUF_FINAL::set_repair_hint
void set_repair_hint(bool value)
operations_research::sat::PROTOBUF_FINAL::set_optimize_with_core
void set_optimize_with_core(bool value)
operations_research::sat::PROTOBUF_FINAL::set_mip_check_precision
void set_mip_check_precision(double value)
operations_research::sat::SatParameters_SearchBranching_SearchBranching_MIN
constexpr SatParameters_SearchBranching SatParameters_SearchBranching_SearchBranching_MIN
Definition: sat_parameters.pb.h:303
operations_research::sat::PROTOBUF_FINAL::cp_model_presolve
bool cp_model_presolve() const
operations_research::sat::SatParameters_Polarity_POLARITY_TRUE
@ SatParameters_Polarity_POLARITY_TRUE
Definition: sat_parameters.pb.h:96
operations_research::sat::PROTOBUF_FINAL::has_random_seed
bool has_random_seed() const
operations_research::sat::PROTOBUF_FINAL::max_memory_in_mb
::PROTOBUF_NAMESPACE_ID::int64 max_memory_in_mb() const
operations_research::sat::PROTOBUF_FINAL::exploit_best_solution
bool exploit_best_solution() const
operations_research::sat::PROTOBUF_FINAL::clear_presolve_bve_clause_weight
void clear_presolve_bve_clause_weight()
operations_research::sat::PROTOBUF_FINAL::has_min_orthogonality_for_lp_constraints
bool has_min_orthogonality_for_lp_constraints() const
operations_research::sat::SatParameters_FPRoundingMethod_PROPAGATION_ASSISTED
@ SatParameters_FPRoundingMethod_PROPAGATION_ASSISTED
Definition: sat_parameters.pb.h:325
operations_research::sat::PROTOBUF_FINAL::use_lns_only
bool use_lns_only() const
operations_research::sat::PROTOBUF_FINAL::has_initial_variables_activity
bool has_initial_variables_activity() const
operations_research::sat::PROTOBUF_FINAL::has_cut_active_count_decay
bool has_cut_active_count_decay() const
operations_research::sat::PROTOBUF_FINAL::clear_auto_detect_greater_than_at_least_one_of
void clear_auto_detect_greater_than_at_least_one_of()
operations_research::sat::PROTOBUF_FINAL::set_clause_cleanup_lbd_bound
void set_clause_cleanup_lbd_bound(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::SatParameters_ClauseOrdering_ClauseOrdering_MIN
constexpr SatParameters_ClauseOrdering SatParameters_ClauseOrdering_ClauseOrdering_MIN
Definition: sat_parameters.pb.h:201
operations_research::sat::PROTOBUF_FINAL::has_random_branches_ratio
bool has_random_branches_ratio() const
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_ARRAYSIZE
constexpr int SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_ARRAYSIZE
Definition: sat_parameters.pb.h:130
operations_research::sat::PROTOBUF_FINAL::has_glucose_decay_increment
bool has_glucose_decay_increment() const
operations_research::sat::PROTOBUF_FINAL::restart_dl_average_ratio
double restart_dl_average_ratio() const
operations_research::sat::PROTOBUF_FINAL::mutable_restart_algorithms
::PROTOBUF_NAMESPACE_ID::RepeatedField< int > * mutable_restart_algorithms()
operations_research::sat::PROTOBUF_FINAL::has_auto_detect_greater_than_at_least_one_of
bool has_auto_detect_greater_than_at_least_one_of() const
operations_research::sat::SatParameters_ClauseOrdering_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_ClauseOrdering_descriptor()
operations_research::sat::PROTOBUF_FINAL::set_glucose_decay_increment_period
void set_glucose_decay_increment_period(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::clear_fp_rounding
void clear_fp_rounding()
operations_research::sat::PROTOBUF_FINAL::has_max_integer_rounding_scaling
bool has_max_integer_rounding_scaling() const
operations_research::sat::PROTOBUF_FINAL::set_restart_algorithms
void set_restart_algorithms(int index, ::operations_research::sat::SatParameters_RestartAlgorithm value)
operations_research::sat::PROTOBUF_FINAL::set_max_consecutive_inactive_count
void set_max_consecutive_inactive_count(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_presolve_blocked_clause
bool has_presolve_blocked_clause() const
operations_research::sat::PROTOBUF_FINAL::set_cp_model_max_num_presolve_operations
void set_cp_model_max_num_presolve_operations(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::clear_max_cut_rounds_at_level_zero
void clear_max_cut_rounds_at_level_zero()
operations_research::sat::PROTOBUF_FINAL::set_cut_cleanup_target
void set_cut_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_clause_cleanup_lbd_bound
bool has_clause_cleanup_lbd_bound() const
operations_research::sat::PROTOBUF_FINAL::set_default_restart_algorithms
void set_default_restart_algorithms(const char *value, size_t size)
operations_research::sat::PROTOBUF_FINAL::use_overload_checker_in_cumulative_constraint
bool use_overload_checker_in_cumulative_constraint() const
operations_research::sat::SatParameters_ClauseOrdering_ClauseOrdering_ARRAYSIZE
constexpr int SatParameters_ClauseOrdering_ClauseOrdering_ARRAYSIZE
Definition: sat_parameters.pb.h:203
operations_research::sat::PROTOBUF_FINAL::has_minimize_core
bool has_minimize_core() const
operations_research::sat::PROTOBUF_FINAL::clear_mip_check_precision
void clear_mip_check_precision()
operations_research::sat::PROTOBUF_FINAL::set_use_lns_only
void set_use_lns_only(bool value)
operations_research::sat::PROTOBUF_FINAL::set_also_bump_variables_in_conflict_reasons
void set_also_bump_variables_in_conflict_reasons(bool value)
operations_research::sat::SatParameters_RestartAlgorithm_Name
const std::string & SatParameters_RestartAlgorithm_Name(T enum_t_value)
Definition: sat_parameters.pb.h:233
operations_research::sat::PROTOBUF_FINAL::cover_optimization
bool cover_optimization() const
operations_research::sat::PROTOBUF_FINAL::cp_model_max_num_presolve_operations
::PROTOBUF_NAMESPACE_ID::int32 cp_model_max_num_presolve_operations() const
operations_research::sat::SatParameters_Polarity_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_Polarity_descriptor()
operations_research::sat::PROTOBUF_FINAL::set_max_clause_activity_value
void set_max_clause_activity_value(double value)
operations_research::sat::PROTOBUF_FINAL::clear_use_branching_in_lp
void clear_use_branching_in_lp()
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_Parse
bool SatParameters_BinaryMinizationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_BinaryMinizationAlgorithm *value)
Definition: sat_parameters.pb.h:167
operations_research::sat::PROTOBUF_FINAL::has_exploit_objective
bool has_exploit_objective() const
operations_research::sat::PROTOBUF_FINAL::max_sat_assumption_order
::operations_research::sat::SatParameters_MaxSatAssumptionOrder max_sat_assumption_order() const
operations_research::sat::PROTOBUF_FINAL::has_initial_polarity
bool has_initial_polarity() const
operations_research::sat::PROTOBUF_FINAL::GetDescriptor
static const ::PROTOBUF_NAMESPACE_ID::Descriptor * GetDescriptor()
Definition: sat_parameters.pb.h:383
operations_research::sat::SatParameters_ClauseOrdering_CLAUSE_ACTIVITY
@ SatParameters_ClauseOrdering_CLAUSE_ACTIVITY
Definition: sat_parameters.pb.h:197
operations_research::sat::PROTOBUF_FINAL::set_allocated_default_restart_algorithms
void set_allocated_default_restart_algorithms(std::string *default_restart_algorithms)
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_BinaryMinizationAlgorithm_descriptor()
operations_research::sat::PROTOBUF_FINAL::treat_binary_clauses_separately
bool treat_binary_clauses_separately() const
operations_research::sat::PROTOBUF_FINAL::set_pb_cleanup_increment
void set_pb_cleanup_increment(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::clear_clause_cleanup_target
void clear_clause_cleanup_target()
operations_research::sat::PROTOBUF_FINAL::RestartAlgorithm_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * RestartAlgorithm_descriptor()
Definition: sat_parameters.pb.h:686
operations_research::sat::PROTOBUF_FINAL::use_optimization_hints
bool use_optimization_hints() const
operations_research::sat::SatParameters_RestartAlgorithm_LUBY_RESTART
@ SatParameters_RestartAlgorithm_LUBY_RESTART
Definition: sat_parameters.pb.h:221
operations_research::sat::PROTOBUF_FINAL::clear_presolve_blocked_clause
void clear_presolve_blocked_clause()
operations_research::sat::PROTOBUF_FINAL::MaxSatAssumptionOrder_Name
static const std::string & MaxSatAssumptionOrder_Name(T enum_t_value)
Definition: sat_parameters.pb.h:722
operations_research::sat::SatParameters_ClauseOrdering
SatParameters_ClauseOrdering
Definition: sat_parameters.pb.h:196
operations_research::sat::SatParameters_VariableOrder_Parse
bool SatParameters_VariableOrder_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_VariableOrder *value)
Definition: sat_parameters.pb.h:90
operations_research::sat::PROTOBUF_FINAL::clear_lns_focus_on_decision_variables
void clear_lns_focus_on_decision_variables()
operations_research::sat::PROTOBUF_FINAL::clause_cleanup_ordering
::operations_research::sat::SatParameters_ClauseOrdering clause_cleanup_ordering() const
operations_research::sat::PROTOBUF_FINAL::has_use_exact_lp_reason
bool has_use_exact_lp_reason() const
operations_research::sat::PROTOBUF_FINAL::has_use_optional_variables
bool has_use_optional_variables() const
operations_research::sat::SatParameters_VariableOrder_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_VariableOrder_descriptor()
operations_research::sat::PROTOBUF_FINAL::random_branches_ratio
double random_branches_ratio() const
operations_research::sat::PROTOBUF_FINAL::release_default_restart_algorithms
std::string * release_default_restart_algorithms()
operations_research::sat::PROTOBUF_FINAL::has_diversify_lns_params
bool has_diversify_lns_params() const
operations_research::sat::PROTOBUF_FINAL::set_cover_optimization
void set_cover_optimization(bool value)
operations_research::sat::PROTOBUF_FINAL::binary_minimization_algorithm
::operations_research::sat::SatParameters_BinaryMinizationAlgorithm binary_minimization_algorithm() const
operations_research::sat::PROTOBUF_FINAL::restart_algorithms
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int > & restart_algorithms() const
operations_research::sat::PROTOBUF_FINAL::VariableOrder_IsValid
static bool VariableOrder_IsValid(int value)
Definition: sat_parameters.pb.h:472
operations_research::sat::PROTOBUF_FINAL::clear_clause_cleanup_lbd_bound
void clear_clause_cleanup_lbd_bound()
operations_research::sat::PROTOBUF_FINAL::set_diversify_lns_params
void set_diversify_lns_params(bool value)
operations_research::sat::PROTOBUF_FINAL::has_max_variable_activity_value
bool has_max_variable_activity_value() const
operations_research::sat::PROTOBUF_FINAL::has_add_lp_constraints_lazily
bool has_add_lp_constraints_lazily() const
operations_research::sat::PROTOBUF_FINAL::set_binary_search_num_conflicts
void set_binary_search_num_conflicts(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::use_erwa_heuristic
bool use_erwa_heuristic() const
operations_research::sat::PROTOBUF_FINAL::clear_catch_sigint_signal
void clear_catch_sigint_signal()
TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto::PROTOBUF_SECTION_VARIABLE
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] PROTOBUF_SECTION_VARIABLE(protodesc_cold)
operations_research::sat::PROTOBUF_FINAL::has_probing_period_at_root
bool has_probing_period_at_root() const
operations_research::sat::PROTOBUF_FINAL::clear_expand_table_constraints
void clear_expand_table_constraints()
operations_research::sat::PROTOBUF_FINAL::exploit_integer_lp_solution
bool exploit_integer_lp_solution() const
operations_research::sat::PROTOBUF_FINAL::set_pseudo_cost_reliability_threshold
void set_pseudo_cost_reliability_threshold(::PROTOBUF_NAMESPACE_ID::int64 value)
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_NONE
@ SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_NONE
Definition: sat_parameters.pb.h:270
operations_research::sat::PROTOBUF_FINAL::set_add_mir_cuts
void set_add_mir_cuts(bool value)
operations_research::sat::PROTOBUF_FINAL::set_add_lin_max_cuts
void set_add_lin_max_cuts(bool value)
operations_research::sat::SatParameters_FPRoundingMethod_LOCK_BASED
@ SatParameters_FPRoundingMethod_LOCK_BASED
Definition: sat_parameters.pb.h:323
operations_research::sat::PROTOBUF_FINAL::cut_max_active_count_value
double cut_max_active_count_value() const
operations_research::sat::PROTOBUF_FINAL::clear_use_implied_bounds
void clear_use_implied_bounds()
operations_research::sat::PROTOBUF_FINAL::presolve_bve_threshold
::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_threshold() const
operations_research::sat::PROTOBUF_FINAL::clause_cleanup_target
::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_target() const
operations_research::sat::PROTOBUF_FINAL::glucose_decay_increment
double glucose_decay_increment() const
operations_research::sat::PROTOBUF_FINAL::has_cp_model_use_sat_presolve
bool has_cp_model_use_sat_presolve() const
operations_research::sat::PROTOBUF_FINAL::set_pb_cleanup_ratio
void set_pb_cleanup_ratio(double value)
operations_research::sat::PROTOBUF_FINAL::Polarity_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * Polarity_descriptor()
Definition: sat_parameters.pb.h:518
operations_research::sat::PROTOBUF_FINAL::set_search_randomization_tolerance
void set_search_randomization_tolerance(::PROTOBUF_NAMESPACE_ID::int64 value)
operations_research::sat::PROTOBUF_FINAL::set_add_cg_cuts
void set_add_cg_cuts(bool value)
operations_research::sat::SatParameters_VariableOrder
SatParameters_VariableOrder
Definition: sat_parameters.pb.h:71
operations_research::sat::PROTOBUF_FINAL::~SatParameters
virtual ~SatParameters()
operations_research::sat::PROTOBUF_FINAL::set_mip_automatically_scale_variables
void set_mip_automatically_scale_variables(bool value)
operations_research::sat::PROTOBUF_FINAL::presolve_bva_threshold
::PROTOBUF_NAMESPACE_ID::int32 presolve_bva_threshold() const
operations_research::sat::PROTOBUF_FINAL::has_clause_cleanup_period
bool has_clause_cleanup_period() const
operations_research::sat::PROTOBUF_FINAL::set_use_combined_no_overlap
void set_use_combined_no_overlap(bool value)
operations_research::sat::PROTOBUF_FINAL::minimize_reduction_during_pb_resolution
bool minimize_reduction_during_pb_resolution() const
operations_research::sat::PROTOBUF_FINAL::has_use_sat_inprocessing
bool has_use_sat_inprocessing() const
operations_research::sat::PROTOBUF_FINAL::RestartAlgorithm_Name
static const std::string & RestartAlgorithm_Name(T enum_t_value)
Definition: sat_parameters.pb.h:690
operations_research::sat::PROTOBUF_FINAL::CopyFrom
void CopyFrom(const SatParameters &from)
operations_research::sat::PROTOBUF_FINAL::set_minimize_with_propagation_num_decisions
void set_minimize_with_propagation_num_decisions(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_cp_model_probing_level
bool has_cp_model_probing_level() const
operations_research::sat::PROTOBUF_FINAL::clear_use_relaxation_lns
void clear_use_relaxation_lns()
operations_research::sat::PROTOBUF_FINAL::clear_merge_no_overlap_work_limit
void clear_merge_no_overlap_work_limit()
operations_research::sat::PROTOBUF_FINAL::stop_after_presolve
bool stop_after_presolve() const
operations_research::sat::PROTOBUF_FINAL::clear_glucose_decay_increment_period
void clear_glucose_decay_increment_period()
operations_research::sat::PROTOBUF_FINAL::clear_max_sat_reverse_assumption_order
void clear_max_sat_reverse_assumption_order()
operations_research::sat::PROTOBUF_FINAL::has_reduce_memory_usage_in_interleave_mode
bool has_reduce_memory_usage_in_interleave_mode() const
operations_research::sat::PROTOBUF_FINAL::set_use_precedences_in_disjunctive_constraint
void set_use_precedences_in_disjunctive_constraint(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_use_feasibility_pump
void clear_use_feasibility_pump()
operations_research::sat::PROTOBUF_FINAL::clear_strategy_change_increase_ratio
void clear_strategy_change_increase_ratio()
operations_research::sat::PROTOBUF_FINAL::has_use_implied_bounds
bool has_use_implied_bounds() const
operations_research::sat::SatParameters_ClauseOrdering_Parse
bool SatParameters_ClauseOrdering_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_ClauseOrdering *value)
Definition: sat_parameters.pb.h:214
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_RECURSIVE
@ SatParameters_ConflictMinimizationAlgorithm_RECURSIVE
Definition: sat_parameters.pb.h:124
operations_research::sat::SatParameters_Polarity
SatParameters_Polarity
Definition: sat_parameters.pb.h:95
operations_research::sat::PROTOBUF_FINAL::set_min_orthogonality_for_lp_constraints
void set_min_orthogonality_for_lp_constraints(double value)
operations_research::sat::SatParameters_VariableOrder_IN_ORDER
@ SatParameters_VariableOrder_IN_ORDER
Definition: sat_parameters.pb.h:72
operations_research::sat::PROTOBUF_FINAL::set_use_disjunctive_constraint_in_cumulative_constraint
void set_use_disjunctive_constraint_in_cumulative_constraint(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_interleave_search
void clear_interleave_search()
operations_research::sat::SatParameters_Polarity_IsValid
bool SatParameters_Polarity_IsValid(int value)
operations_research::sat::PROTOBUF_FINAL::glucose_max_decay
double glucose_max_decay() const
operations_research::sat::PROTOBUF_FINAL::set_presolve_bve_threshold
void set_presolve_bve_threshold(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_mip_wanted_precision
bool has_mip_wanted_precision() const
operations_research::sat::SatParameters_RestartAlgorithm_DL_MOVING_AVERAGE_RESTART
@ SatParameters_RestartAlgorithm_DL_MOVING_AVERAGE_RESTART
Definition: sat_parameters.pb.h:222
operations_research::sat::PROTOBUF_FINAL::Clear
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final
operations_research::sat::PROTOBUF_FINAL::set_use_branching_in_lp
void set_use_branching_in_lp(bool value)
operations_research::sat::PROTOBUF_FINAL::max_time_in_seconds
double max_time_in_seconds() const
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_Name
const std::string & SatParameters_BinaryMinizationAlgorithm_Name(T enum_t_value)
Definition: sat_parameters.pb.h:160
operations_research::sat::PROTOBUF_FINAL::max_num_cuts
::PROTOBUF_NAMESPACE_ID::int32 max_num_cuts() const
operations_research::sat::PROTOBUF_FINAL::has_mip_check_precision
bool has_mip_check_precision() const
operations_research::sat::PROTOBUF_FINAL::MergeFrom
void MergeFrom(const SatParameters &from)
operations_research
Definition: cp_model.h:52
operations_research::sat::PROTOBUF_FINAL::clear_use_blocking_restart
void clear_use_blocking_restart()
operations_research::sat::PROTOBUF_FINAL::clear_use_timetable_edge_finding_in_cumulative_constraint
void clear_use_timetable_edge_finding_in_cumulative_constraint()
operations_research::sat::PROTOBUF_FINAL::MaxSatStratificationAlgorithm_Parse
static bool MaxSatStratificationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MaxSatStratificationAlgorithm *value)
Definition: sat_parameters.pb.h:760
operations_research::sat::PROTOBUF_FINAL::set_use_exact_lp_reason
void set_use_exact_lp_reason(bool value)
operations_research::sat::PROTOBUF_FINAL::add_lin_max_cuts
bool add_lin_max_cuts() const
operations_research::sat::PROTOBUF_FINAL::set_search_branching
void set_search_branching(::operations_research::sat::SatParameters_SearchBranching value)
operations_research::sat::PROTOBUF_FINAL::SatParameters
SatParameters()
Definition: sat_parameters.pb.h:351
operations_research::sat::SatParameters_BinaryMinizationAlgorithm
SatParameters_BinaryMinizationAlgorithm
Definition: sat_parameters.pb.h:146
operations_research::sat::PROTOBUF_FINAL::set_clause_cleanup_protection
void set_clause_cleanup_protection(::operations_research::sat::SatParameters_ClauseProtection value)
operations_research::sat::PROTOBUF_FINAL::clause_cleanup_period
::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_period() const
operations_research::sat::SatParameters_SearchBranching_SearchBranching_MAX
constexpr SatParameters_SearchBranching SatParameters_SearchBranching_SearchBranching_MAX
Definition: sat_parameters.pb.h:304
operations_research::sat::PROTOBUF_FINAL::MergeFrom
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message &from) final
operations_research::sat::PROTOBUF_FINAL::has_blocking_restart_multiplier
bool has_blocking_restart_multiplier() const
operations_research::sat::PROTOBUF_FINAL::clear_restart_running_window_size
void clear_restart_running_window_size()
operations_research::sat::PROTOBUF_FINAL::has_use_combined_no_overlap
bool has_use_combined_no_overlap() const
operations_research::sat::PROTOBUF_FINAL::has_add_knapsack_cuts
bool has_add_knapsack_cuts() const
operations_research::sat::PROTOBUF_FINAL::has_share_level_zero_bounds
bool has_share_level_zero_bounds() const
operations_research::sat::SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MAX
constexpr SatParameters_MaxSatAssumptionOrder SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MAX
Definition: sat_parameters.pb.h:252
operations_research::sat::PROTOBUF_FINAL::RestartAlgorithm
SatParameters_RestartAlgorithm RestartAlgorithm
Definition: sat_parameters.pb.h:665
operations_research::sat::PROTOBUF_FINAL::clear_glucose_max_decay
void clear_glucose_max_decay()
operations_research::sat::PROTOBUF_FINAL::set_clause_cleanup_period
void set_clause_cleanup_period(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::hint_conflict_limit
::PROTOBUF_NAMESPACE_ID::int32 hint_conflict_limit() const
operations_research::sat::PROTOBUF_FINAL::set_log_search_progress
void set_log_search_progress(bool value)
operations_research::sat::PROTOBUF_FINAL::cut_active_count_decay
double cut_active_count_decay() const
operations_research::sat::PROTOBUF_FINAL::has_presolve_bva_threshold
bool has_presolve_bva_threshold() const
operations_research::sat::PROTOBUF_FINAL::set_blocking_restart_multiplier
void set_blocking_restart_multiplier(double value)
operations_research::sat::PROTOBUF_FINAL::cp_model_probing_level
::PROTOBUF_NAMESPACE_ID::int32 cp_model_probing_level() const
operations_research::sat::PROTOBUF_FINAL::ConflictMinimizationAlgorithm_IsValid
static bool ConflictMinimizationAlgorithm_IsValid(int value)
Definition: sat_parameters.pb.h:542
operations_research::sat::_SatParameters_default_instance_
SatParametersDefaultTypeInternal _SatParameters_default_instance_
operations_research::sat::PROTOBUF_FINAL::has_interleave_batch_size
bool has_interleave_batch_size() const
operations_research::sat::PROTOBUF_FINAL::instantiate_all_variables
bool instantiate_all_variables() const
operations_research::sat::PROTOBUF_FINAL::set_cut_max_active_count_value
void set_cut_max_active_count_value(double value)
operations_research::sat::PROTOBUF_FINAL::set_max_num_cuts
void set_max_num_cuts(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::clear_absolute_gap_limit
void clear_absolute_gap_limit()
operations_research::sat::PROTOBUF_FINAL::set_presolve_use_bva
void set_presolve_use_bva(bool value)
operations_research::sat::SatParameters_SearchBranching_PSEUDO_COST_SEARCH
@ SatParameters_SearchBranching_PSEUDO_COST_SEARCH
Definition: sat_parameters.pb.h:298
operations_research::sat::PROTOBUF_FINAL::has_max_num_cuts
bool has_max_num_cuts() const
operations_research::sat::PROTOBUF_FINAL::set_use_optional_variables
void set_use_optional_variables(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_interleave_batch_size
void clear_interleave_batch_size()
operations_research::sat::PROTOBUF_FINAL::set_lns_focus_on_decision_variables
void set_lns_focus_on_decision_variables(bool value)
operations_research::sat::PROTOBUF_FINAL::has_presolve_bve_threshold
bool has_presolve_bve_threshold() const
operations_research::sat::PROTOBUF_FINAL::has_default_restart_algorithms
bool has_default_restart_algorithms() const
operations_research::sat::PROTOBUF_FINAL::CopyFrom
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message &from) final
operations_research::sat::PROTOBUF_FINAL::clear_max_sat_assumption_order
void clear_max_sat_assumption_order()
operations_research::sat::PROTOBUF_FINAL::max_consecutive_inactive_count
::PROTOBUF_NAMESPACE_ID::int32 max_consecutive_inactive_count() const
operations_research::sat::PROTOBUF_FINAL::max_deterministic_time
double max_deterministic_time() const
operations_research::sat::SatParameters_RestartAlgorithm_NO_RESTART
@ SatParameters_RestartAlgorithm_NO_RESTART
Definition: sat_parameters.pb.h:220
operations_research::sat::PROTOBUF_FINAL::has_repair_hint
bool has_repair_hint() const
operations_research::sat::PROTOBUF_FINAL::clear_clause_activity_decay
void clear_clause_activity_decay()
operations_research::sat::PROTOBUF_FINAL::clear_probing_period_at_root
void clear_probing_period_at_root()
operations_research::sat::SatParameters_SearchBranching_FIXED_SEARCH
@ SatParameters_SearchBranching_FIXED_SEARCH
Definition: sat_parameters.pb.h:295
operations_research::sat::PROTOBUF_FINAL::set_max_number_of_conflicts
void set_max_number_of_conflicts(::PROTOBUF_NAMESPACE_ID::int64 value)
operations_research::sat::PROTOBUF_FINAL::set_polarity_rephase_increment
void set_polarity_rephase_increment(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::blocking_restart_multiplier
double blocking_restart_multiplier() const
operations_research::sat::PROTOBUF_FINAL::clear_default_restart_algorithms
void clear_default_restart_algorithms()
operations_research::sat::PROTOBUF_FINAL::has_variable_activity_decay
bool has_variable_activity_decay() const
TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto::PROTOBUF_SECTION_VARIABLE
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1] PROTOBUF_SECTION_VARIABLE(protodesc_cold)
operations_research::sat::SatParameters_MaxSatAssumptionOrder_DEFAULT_ASSUMPTION_ORDER
@ SatParameters_MaxSatAssumptionOrder_DEFAULT_ASSUMPTION_ORDER
Definition: sat_parameters.pb.h:246
operations_research::sat::PROTOBUF_FINAL::MaxSatStratificationAlgorithm_IsValid
static bool MaxSatStratificationAlgorithm_IsValid(int value)
Definition: sat_parameters.pb.h:740
operations_research::sat::PROTOBUF_FINAL::has_num_conflicts_before_strategy_changes
bool has_num_conflicts_before_strategy_changes() const
operations_research::sat::PROTOBUF_FINAL::set_max_deterministic_time
void set_max_deterministic_time(double value)
operations_research::sat::PROTOBUF_FINAL::clear_mip_max_activity_exponent
void clear_mip_max_activity_exponent()
operations_research::sat::PROTOBUF_FINAL::reduce_memory_usage_in_interleave_mode
bool reduce_memory_usage_in_interleave_mode() const
operations_research::sat::SatParameters_FPRoundingMethod_FPRoundingMethod_ARRAYSIZE
constexpr int SatParameters_FPRoundingMethod_FPRoundingMethod_ARRAYSIZE
Definition: sat_parameters.pb.h:330
operations_research::sat::PROTOBUF_FINAL::set_use_relaxation_lns
void set_use_relaxation_lns(bool value)
operations_research::sat::PROTOBUF_FINAL::has_search_branching
bool has_search_branching() const
operations_research::sat::PROTOBUF_FINAL::BinaryMinizationAlgorithm_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * BinaryMinizationAlgorithm_descriptor()
Definition: sat_parameters.pb.h:588
operations_research::sat::PROTOBUF_FINAL::set_num_search_workers
void set_num_search_workers(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_glucose_decay_increment_period
bool has_glucose_decay_increment_period() const
operations_research::sat::PROTOBUF_FINAL::set_cp_model_postsolve_with_full_solver
void set_cp_model_postsolve_with_full_solver(bool value)
operations_research::sat::PROTOBUF_FINAL::linearization_level
::PROTOBUF_NAMESPACE_ID::int32 linearization_level() const
operations_research::sat::PROTOBUF_FINAL::log_search_progress
bool log_search_progress() const
operations_research::sat::SatParameters_FPRoundingMethod
SatParameters_FPRoundingMethod
Definition: sat_parameters.pb.h:321
operations_research::sat::PROTOBUF_FINAL::optimize_with_max_hs
bool optimize_with_max_hs() const
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_NO_BINARY_MINIMIZATION
@ SatParameters_BinaryMinizationAlgorithm_NO_BINARY_MINIMIZATION
Definition: sat_parameters.pb.h:147
operations_research::sat::PROTOBUF_FINAL::set_max_time_in_seconds
void set_max_time_in_seconds(double value)
operations_research::sat::PROTOBUF_FINAL::set_auto_detect_greater_than_at_least_one_of
void set_auto_detect_greater_than_at_least_one_of(bool value)
operations_research::sat::SatParameters_ClauseProtection_Parse
bool SatParameters_ClauseProtection_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_ClauseProtection *value)
Definition: sat_parameters.pb.h:191
operations_research::sat::PROTOBUF_FINAL::clear_restart_lbd_average_ratio
void clear_restart_lbd_average_ratio()
operations_research::sat::SatParameters_ClauseOrdering_IsValid
bool SatParameters_ClauseOrdering_IsValid(int value)
operations_research::sat::PROTOBUF_FINAL::set_max_variable_activity_value
void set_max_variable_activity_value(double value)
operations_research::sat::PROTOBUF_FINAL::add_lp_constraints_lazily
bool add_lp_constraints_lazily() const
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm
SatParameters_ConflictMinimizationAlgorithm
Definition: sat_parameters.pb.h:121
operations_research::sat::PROTOBUF_FINAL::descriptor
static const ::PROTOBUF_NAMESPACE_ID::Descriptor * descriptor()
Definition: sat_parameters.pb.h:380
operations_research::sat::SatParameters_Polarity_POLARITY_REVERSE_WEIGHTED_SIGN
@ SatParameters_Polarity_POLARITY_REVERSE_WEIGHTED_SIGN
Definition: sat_parameters.pb.h:100
operations_research::sat::PROTOBUF_FINAL::use_branching_in_lp
bool use_branching_in_lp() const
operations_research::sat::SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_WEIGHT
@ SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_WEIGHT
Definition: sat_parameters.pb.h:248
operations_research::sat::PROTOBUF_FINAL::has_cp_model_presolve
bool has_cp_model_presolve() const
operations_research::sat::PROTOBUF_FINAL::has_pb_cleanup_ratio
bool has_pb_cleanup_ratio() const
operations_research::sat::PROTOBUF_FINAL::set_exploit_relaxation_solution
void set_exploit_relaxation_solution(bool value)
operations_research::sat::PROTOBUF_FINAL::minimize_with_propagation_restart_period
::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_restart_period() const
operations_research::sat::PROTOBUF_FINAL::set_default_restart_algorithms
void set_default_restart_algorithms(const std::string &value)
operations_research::sat::PROTOBUF_FINAL::has_find_multiple_cores
bool has_find_multiple_cores() const
operations_research::sat::PROTOBUF_FINAL::has_cp_model_max_num_presolve_operations
bool has_cp_model_max_num_presolve_operations() const
operations_research::sat::SatParameters_ClauseProtection_IsValid
bool SatParameters_ClauseProtection_IsValid(int value)
operations_research::sat::PROTOBUF_FINAL::set_clause_cleanup_target
void set_clause_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::clear_use_overload_checker_in_cumulative_constraint
void clear_use_overload_checker_in_cumulative_constraint()
operations_research::sat::PROTOBUF_FINAL::clear_optimize_with_max_hs
void clear_optimize_with_max_hs()
operations_research::sat::PROTOBUF_FINAL::set_presolve_blocked_clause
void set_presolve_blocked_clause(bool value)
operations_research::sat::PROTOBUF_FINAL::max_sat_stratification
::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm max_sat_stratification() const
operations_research::sat::PROTOBUF_FINAL::cp_model_use_sat_presolve
bool cp_model_use_sat_presolve() const
operations_research::sat::PROTOBUF_FINAL::clear_use_lns_only
void clear_use_lns_only()
operations_research::sat::SatParameters_Polarity_POLARITY_FALSE
@ SatParameters_Polarity_POLARITY_FALSE
Definition: sat_parameters.pb.h:97
operations_research::sat::PROTOBUF_FINAL::has_presolve_use_bva
bool has_presolve_use_bva() const
operations_research::sat::PROTOBUF_FINAL::set_clause_activity_decay
void set_clause_activity_decay(double value)
operations_research::sat::SatParameters_FPRoundingMethod_FPRoundingMethod_MIN
constexpr SatParameters_FPRoundingMethod SatParameters_FPRoundingMethod_FPRoundingMethod_MIN
Definition: sat_parameters.pb.h:328
operations_research::sat::PROTOBUF_FINAL::has_search_randomization_tolerance
bool has_search_randomization_tolerance() const
operations_research::sat::PROTOBUF_FINAL::clear_random_branches_ratio
void clear_random_branches_ratio()
operations_research::sat::PROTOBUF_FINAL::set_use_erwa_heuristic
void set_use_erwa_heuristic(bool value)
operations_research::sat::PROTOBUF_FINAL::set_linearization_level
void set_linearization_level(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::VariableOrder_Parse
static bool VariableOrder_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VariableOrder *value)
Definition: sat_parameters.pb.h:492
operations_research::sat::PROTOBUF_FINAL::clear_diversify_lns_params
void clear_diversify_lns_params()
operations_research::sat::PROTOBUF_FINAL::has_max_number_of_conflicts
bool has_max_number_of_conflicts() const
operations_research::sat::PROTOBUF_FINAL::clear_pseudo_cost_reliability_threshold
void clear_pseudo_cost_reliability_threshold()
operations_research::sat::PROTOBUF_FINAL::clear_random_seed
void clear_random_seed()
operations_research::sat::SatParameters_SearchBranching_Name
const std::string & SatParameters_SearchBranching_Name(T enum_t_value)
Definition: sat_parameters.pb.h:309
operations_research::sat::PROTOBUF_FINAL::fill_tightened_domains_in_response
bool fill_tightened_domains_in_response() const
operations_research::sat::PROTOBUF_FINAL::random_polarity_ratio
double random_polarity_ratio() const
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_MaxSatStratificationAlgorithm_descriptor()
operations_research::sat::PROTOBUF_FINAL::VariableOrder
SatParameters_VariableOrder VariableOrder
Definition: sat_parameters.pb.h:465
operations_research::sat::PROTOBUF_FINAL::set_restart_running_window_size
void set_restart_running_window_size(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::mip_check_precision
double mip_check_precision() const
operations_research::sat::PROTOBUF_FINAL::MaxSatAssumptionOrder
SatParameters_MaxSatAssumptionOrder MaxSatAssumptionOrder
Definition: sat_parameters.pb.h:701
operations_research::sat::PROTOBUF_FINAL::clear_add_lp_constraints_lazily
void clear_add_lp_constraints_lazily()
operations_research::sat::SatParameters_Polarity_Polarity_MIN
constexpr SatParameters_Polarity SatParameters_Polarity_Polarity_MIN
Definition: sat_parameters.pb.h:103
operations_research::sat::PROTOBUF_FINAL::clear_use_optional_variables
void clear_use_optional_variables()
operations_research::sat::PROTOBUF_FINAL::clause_cleanup_protection
::operations_research::sat::SatParameters_ClauseProtection clause_cleanup_protection() const
operations_research::sat::PROTOBUF_FINAL::has_treat_binary_clauses_separately
bool has_treat_binary_clauses_separately() const
operations_research::sat::PROTOBUF_FINAL::set_blocking_restart_window_size
void set_blocking_restart_window_size(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::set_merge_no_overlap_work_limit
void set_merge_no_overlap_work_limit(double value)
operations_research::sat::PROTOBUF_FINAL::relative_gap_limit
double relative_gap_limit() const
operations_research::sat::PROTOBUF_FINAL::has_max_deterministic_time
bool has_max_deterministic_time() const
operations_research::sat::PROTOBUF_FINAL::use_rins_lns
bool use_rins_lns() const
operations_research::sat::PROTOBUF_FINAL::clear_use_combined_no_overlap
void clear_use_combined_no_overlap()
operations_research::sat::PROTOBUF_FINAL::ClauseProtection_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * ClauseProtection_descriptor()
Definition: sat_parameters.pb.h:620
operations_research::sat::PROTOBUF_FINAL::mip_var_scaling
double mip_var_scaling() const
operations_research::sat::PROTOBUF_FINAL::auto_detect_greater_than_at_least_one_of
bool auto_detect_greater_than_at_least_one_of() const
operations_research::sat::PROTOBUF_FINAL::clear_fill_tightened_domains_in_response
void clear_fill_tightened_domains_in_response()
operations_research::sat::PROTOBUF_FINAL::initial_polarity
::operations_research::sat::SatParameters_Polarity initial_polarity() const
operations_research::sat::PROTOBUF_FINAL::set_use_overload_checker_in_cumulative_constraint
void set_use_overload_checker_in_cumulative_constraint(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_hint_conflict_limit
void clear_hint_conflict_limit()
operations_research::sat::PROTOBUF_FINAL::has_use_feasibility_pump
bool has_use_feasibility_pump() const
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_ARRAYSIZE
constexpr int SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_ARRAYSIZE
Definition: sat_parameters.pb.h:277
operations_research::sat::PROTOBUF_FINAL::has_randomize_search
bool has_randomize_search() const
operations_research::sat::PROTOBUF_FINAL::max_clause_activity_value
double max_clause_activity_value() const
operations_research::sat::PROTOBUF_FINAL::has_restart_running_window_size
bool has_restart_running_window_size() const
operations_research::sat::SatParameters_VariableOrder_VariableOrder_MAX
constexpr SatParameters_VariableOrder SatParameters_VariableOrder_VariableOrder_MAX
Definition: sat_parameters.pb.h:78
operations_research::sat::SatParameters_ClauseOrdering_CLAUSE_LBD
@ SatParameters_ClauseOrdering_CLAUSE_LBD
Definition: sat_parameters.pb.h:198
operations_research::sat::PROTOBUF_FINAL::has_presolve_substitution_level
bool has_presolve_substitution_level() const
operations_research::sat::SatParameters_SearchBranching_Parse
bool SatParameters_SearchBranching_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_SearchBranching *value)
Definition: sat_parameters.pb.h:316
operations_research::sat::PROTOBUF_FINAL::set_probing_period_at_root
void set_probing_period_at_root(::PROTOBUF_NAMESPACE_ID::int64 value)
operations_research::sat::PROTOBUF_FINAL::has_add_lin_max_cuts
bool has_add_lin_max_cuts() const
operations_research::sat::PROTOBUF_FINAL::has_lns_focus_on_decision_variables
bool has_lns_focus_on_decision_variables() const
operations_research::sat::PROTOBUF_FINAL::UnsafeArenaSwap
void UnsafeArenaSwap(SatParameters *other)
Definition: sat_parameters.pb.h:410
operations_research::sat::PROTOBUF_FINAL::clear_restart_dl_average_ratio
void clear_restart_dl_average_ratio()
operations_research::sat::PROTOBUF_FINAL::clear_random_polarity_ratio
void clear_random_polarity_ratio()
operations_research::sat::PROTOBUF_FINAL::diversify_lns_params
bool diversify_lns_params() const
operations_research::sat::PROTOBUF_FINAL::set_catch_sigint_signal
void set_catch_sigint_signal(bool value)
operations_research::sat::PROTOBUF_FINAL::has_use_blocking_restart
bool has_use_blocking_restart() const
operations_research::sat::PROTOBUF_FINAL::Polarity_Name
static const std::string & Polarity_Name(T enum_t_value)
Definition: sat_parameters.pb.h:522
operations_research::sat::PROTOBUF_FINAL::MaxSatStratificationAlgorithm_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * MaxSatStratificationAlgorithm_descriptor()
Definition: sat_parameters.pb.h:750
operations_research::sat::PROTOBUF_FINAL::ClauseOrdering_Parse
static bool ClauseOrdering_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClauseOrdering *value)
Definition: sat_parameters.pb.h:660
operations_research::sat::PROTOBUF_FINAL::set_only_add_cuts_at_level_zero
void set_only_add_cuts_at_level_zero(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_exploit_integer_lp_solution
void clear_exploit_integer_lp_solution()
operations_research::sat::PROTOBUF_FINAL::exploit_all_lp_solution
bool exploit_all_lp_solution() const
operations_research::sat::PROTOBUF_FINAL::clear_expand_automaton_constraints
void clear_expand_automaton_constraints()
operations_research::sat::PROTOBUF_FINAL::MaxSatAssumptionOrder_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * MaxSatAssumptionOrder_descriptor()
Definition: sat_parameters.pb.h:718
operations_research::sat::PROTOBUF_FINAL::expand_table_constraints
bool expand_table_constraints() const
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_DESCENT
@ SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_DESCENT
Definition: sat_parameters.pb.h:271
operations_research::sat::PROTOBUF_FINAL::mip_automatically_scale_variables
bool mip_automatically_scale_variables() const
operations_research::sat::PROTOBUF_FINAL::min_orthogonality_for_lp_constraints
double min_orthogonality_for_lp_constraints() const
operations_research::sat::SatParameters_SearchBranching_PORTFOLIO_SEARCH
@ SatParameters_SearchBranching_PORTFOLIO_SEARCH
Definition: sat_parameters.pb.h:296
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MIN
constexpr SatParameters_BinaryMinizationAlgorithm SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MIN
Definition: sat_parameters.pb.h:154
operations_research::sat::PROTOBUF_FINAL::set_mip_wanted_precision
void set_mip_wanted_precision(double value)
operations_research::sat::PROTOBUF_FINAL::set_glucose_decay_increment
void set_glucose_decay_increment(double value)
operations_research::sat::PROTOBUF_FINAL::set_reduce_memory_usage_in_interleave_mode
void set_reduce_memory_usage_in_interleave_mode(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_cut_max_active_count_value
void clear_cut_max_active_count_value()
operations_research::sat::PROTOBUF_FINAL::mip_wanted_precision
double mip_wanted_precision() const
operations_research::sat::PROTOBUF_FINAL::set_restart_lbd_average_ratio
void set_restart_lbd_average_ratio(double value)
operations_research::sat::PROTOBUF_FINAL::clear_exploit_objective
void clear_exploit_objective()
operations_research::sat::PROTOBUF_FINAL::has_max_sat_stratification
bool has_max_sat_stratification() const
operations_research::sat::SatParameters_Polarity_Parse
bool SatParameters_Polarity_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_Polarity *value)
Definition: sat_parameters.pb.h:116
operations_research::sat::PROTOBUF_FINAL::clear_initial_polarity
void clear_initial_polarity()
operations_research::sat::PROTOBUF_FINAL::clear_clause_cleanup_protection
void clear_clause_cleanup_protection()
operations_research::sat::PROTOBUF_FINAL::set_interleave_search
void set_interleave_search(bool value)
operations_research::sat::PROTOBUF_FINAL::SearchBranching
SatParameters_SearchBranching SearchBranching
Definition: sat_parameters.pb.h:765
operations_research::sat::PROTOBUF_FINAL::clear_instantiate_all_variables
void clear_instantiate_all_variables()
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_WITH_REACHABILITY
@ SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_WITH_REACHABILITY
Definition: sat_parameters.pb.h:150
operations_research::sat::SatParameters_VariableOrder_Name
const std::string & SatParameters_VariableOrder_Name(T enum_t_value)
Definition: sat_parameters.pb.h:83
operations_research::sat::PROTOBUF_FINAL::set_max_cut_rounds_at_level_zero
void set_max_cut_rounds_at_level_zero(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::use_precedences_in_disjunctive_constraint
bool use_precedences_in_disjunctive_constraint() const
operations_research::sat::PROTOBUF_FINAL::share_level_zero_bounds
bool share_level_zero_bounds() const
operations_research::sat::PROTOBUF_FINAL::MaxSatAssumptionOrder_IsValid
static bool MaxSatAssumptionOrder_IsValid(int value)
Definition: sat_parameters.pb.h:708
operations_research::sat::PROTOBUF_FINAL::restart_running_window_size
::PROTOBUF_NAMESPACE_ID::int32 restart_running_window_size() const
operations_research::sat::PROTOBUF_FINAL::clear_add_knapsack_cuts
void clear_add_knapsack_cuts()
operations_research::sat::PROTOBUF_FINAL::clear_use_optimization_hints
void clear_use_optimization_hints()
operations_research::sat::PROTOBUF_FINAL::set_randomize_search
void set_randomize_search(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_enumerate_all_solutions
void clear_enumerate_all_solutions()
operations_research::sat::SatParameters_FPRoundingMethod_Name
const std::string & SatParameters_FPRoundingMethod_Name(T enum_t_value)
Definition: sat_parameters.pb.h:334
operations_research::sat::PROTOBUF_FINAL::RestartAlgorithm_IsValid
static bool RestartAlgorithm_IsValid(int value)
Definition: sat_parameters.pb.h:676
operations_research::sat::PROTOBUF_FINAL::mutable_unknown_fields
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet * mutable_unknown_fields()
Definition: sat_parameters.pb.h:376
operations_research::sat::PROTOBUF_FINAL::clear_blocking_restart_window_size
void clear_blocking_restart_window_size()
operations_research::sat::SatParameters_RestartAlgorithm_RestartAlgorithm_MAX
constexpr SatParameters_RestartAlgorithm SatParameters_RestartAlgorithm_RestartAlgorithm_MAX
Definition: sat_parameters.pb.h:228
operations_research::sat::PROTOBUF_FINAL::minimization_algorithm
::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm minimization_algorithm() const
operations_research::sat::PROTOBUF_FINAL::mip_max_activity_exponent
::PROTOBUF_NAMESPACE_ID::int32 mip_max_activity_exponent() const
operations_research::sat::PROTOBUF_FINAL::use_blocking_restart
bool use_blocking_restart() const
operations_research::sat::PROTOBUF_FINAL::set_restart_period
void set_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::SatParameters_ClauseOrdering_Name
const std::string & SatParameters_ClauseOrdering_Name(T enum_t_value)
Definition: sat_parameters.pb.h:207
operations_research::sat::PROTOBUF_FINAL::clear_use_sat_inprocessing
void clear_use_sat_inprocessing()
operations_research::sat::PROTOBUF_FINAL::default_restart_algorithms
const std::string & default_restart_algorithms() const
operations_research::sat::PROTOBUF_FINAL::FPRoundingMethod_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * FPRoundingMethod_descriptor()
Definition: sat_parameters.pb.h:824
operations_research::sat::SatParameters_RestartAlgorithm_Parse
bool SatParameters_RestartAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_RestartAlgorithm *value)
Definition: sat_parameters.pb.h:240
operations_research::sat::PROTOBUF_FINAL::clear_max_num_cuts
void clear_max_num_cuts()
operations_research::sat::PROTOBUF_FINAL::has_exploit_relaxation_solution
bool has_exploit_relaxation_solution() const
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_EXPERIMENTAL_BINARY_MINIMIZATION
@ SatParameters_BinaryMinizationAlgorithm_EXPERIMENTAL_BINARY_MINIMIZATION
Definition: sat_parameters.pb.h:151
operations_research::sat::PROTOBUF_FINAL::expand_element_constraints
bool expand_element_constraints() const
operations_research::sat::PROTOBUF_FINAL::set_use_implied_bounds
void set_use_implied_bounds(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_cp_model_postsolve_with_full_solver
void clear_cp_model_postsolve_with_full_solver()
operations_research::sat::PROTOBUF_FINAL::enumerate_all_solutions
bool enumerate_all_solutions() const
operations_research::sat::PROTOBUF_FINAL::has_presolve_probing_deterministic_time_limit
bool has_presolve_probing_deterministic_time_limit() const
operations_research::sat::PROTOBUF_FINAL::clear_also_bump_variables_in_conflict_reasons
void clear_also_bump_variables_in_conflict_reasons()
operations_research::sat::PROTOBUF_FINAL::max_all_diff_cut_size
::PROTOBUF_NAMESPACE_ID::int32 max_all_diff_cut_size() const
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm
SatParameters_MaxSatStratificationAlgorithm
Definition: sat_parameters.pb.h:269
operations_research::sat::PROTOBUF_FINAL::has_new_constraints_batch_size
bool has_new_constraints_batch_size() const
operations_research::sat::PROTOBUF_FINAL::has_interleave_search
bool has_interleave_search() const
operations_research::sat::PROTOBUF_FINAL::has_fp_rounding
bool has_fp_rounding() const
operations_research::sat::PROTOBUF_FINAL::new_constraints_batch_size
::PROTOBUF_NAMESPACE_ID::int32 new_constraints_batch_size() const
operations_research::sat::PROTOBUF_FINAL::clear_optimize_with_core
void clear_optimize_with_core()
operations_research::sat::PROTOBUF_FINAL::InitAsDefaultInstance
static void InitAsDefaultInstance()
operations_research::sat::PROTOBUF_FINAL::has_use_branching_in_lp
bool has_use_branching_in_lp() const
operations_research::sat::PROTOBUF_FINAL::max_sat_reverse_assumption_order
bool max_sat_reverse_assumption_order() const
operations_research::sat::SatParameters_FPRoundingMethod_IsValid
bool SatParameters_FPRoundingMethod_IsValid(int value)
operations_research::sat::PROTOBUF_FINAL::set_treat_binary_clauses_separately
void set_treat_binary_clauses_separately(bool value)
operations_research::sat::PROTOBUF_FINAL::add_mir_cuts
bool add_mir_cuts() const
operations_research::sat::PROTOBUF_FINAL::set_optimize_with_max_hs
void set_optimize_with_max_hs(bool value)
operations_research::sat::PROTOBUF_FINAL::set_initial_variables_activity
void set_initial_variables_activity(double value)
operations_research::sat::PROTOBUF_FINAL::ConflictMinimizationAlgorithm_Parse
static bool ConflictMinimizationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConflictMinimizationAlgorithm *value)
Definition: sat_parameters.pb.h:562
operations_research::sat::PROTOBUF_FINAL::set_exploit_objective
void set_exploit_objective(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_exploit_all_lp_solution
void clear_exploit_all_lp_solution()
operations_research::sat::PROTOBUF_FINAL::New
SatParameters * New() const final
Definition: sat_parameters.pb.h:418
operations_research::sat::PROTOBUF_FINAL::presolve_substitution_level
::PROTOBUF_NAMESPACE_ID::int32 presolve_substitution_level() const
operations_research::sat::PROTOBUF_FINAL::clear_max_integer_rounding_scaling
void clear_max_integer_rounding_scaling()
operations_research::sat::PROTOBUF_FINAL::has_use_disjunctive_constraint_in_cumulative_constraint
bool has_use_disjunctive_constraint_in_cumulative_constraint() const
operations_research::sat::PROTOBUF_FINAL::mutable_default_restart_algorithms
std::string * mutable_default_restart_algorithms()
operations_research::sat::PROTOBUF_FINAL::has_mip_automatically_scale_variables
bool has_mip_automatically_scale_variables() const
operations_research::sat::PROTOBUF_FINAL::count_assumption_levels_in_lbd
bool count_assumption_levels_in_lbd() const
operations_research::sat::PROTOBUF_FINAL::set_binary_minimization_algorithm
void set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value)
operations_research::sat::PROTOBUF_FINAL::clear_mip_var_scaling
void clear_mip_var_scaling()
operations_research::sat::PROTOBUF_FINAL::set_presolve_substitution_level
void set_presolve_substitution_level(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::clear_stop_after_first_solution
void clear_stop_after_first_solution()
operations_research::sat::PROTOBUF_FINAL::SatParameters
SatParameters(const SatParameters &from)
operations_research::sat::SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_ARRAYSIZE
constexpr int SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_ARRAYSIZE
Definition: sat_parameters.pb.h:253
operations_research::sat::PROTOBUF_FINAL::BinaryMinizationAlgorithm
SatParameters_BinaryMinizationAlgorithm BinaryMinizationAlgorithm
Definition: sat_parameters.pb.h:567
operations_research::sat::PROTOBUF_FINAL::use_combined_no_overlap
bool use_combined_no_overlap() const
operations_research::sat::PROTOBUF_FINAL::set_exploit_integer_lp_solution
void set_exploit_integer_lp_solution(bool value)
operations_research::sat::PROTOBUF_FINAL::set_fp_rounding
void set_fp_rounding(::operations_research::sat::SatParameters_FPRoundingMethod value)
descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto
operations_research::sat::SatParameters_VariableOrder_VariableOrder_ARRAYSIZE
constexpr int SatParameters_VariableOrder_VariableOrder_ARRAYSIZE
Definition: sat_parameters.pb.h:79
operations_research::sat::PROTOBUF_FINAL::initial_variables_activity
double initial_variables_activity() const
operations_research::sat::PROTOBUF_FINAL::clear_glucose_decay_increment
void clear_glucose_decay_increment()
operations_research::sat::PROTOBUF_FINAL::add_knapsack_cuts
bool add_knapsack_cuts() const
operations_research::sat::PROTOBUF_FINAL::num_search_workers
::PROTOBUF_NAMESPACE_ID::int32 num_search_workers() const
operations_research::sat::SatParameters_RestartAlgorithm_FIXED_RESTART
@ SatParameters_RestartAlgorithm_FIXED_RESTART
Definition: sat_parameters.pb.h:224
operations_research::sat::PROTOBUF_FINAL::clear_cp_model_max_num_presolve_operations
void clear_cp_model_max_num_presolve_operations()
operations_research::sat::PROTOBUF_FINAL::set_mip_max_activity_exponent
void set_mip_max_activity_exponent(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_exploit_all_lp_solution
bool has_exploit_all_lp_solution() const
operations_research::sat::SatParameters_RestartAlgorithm_RestartAlgorithm_ARRAYSIZE
constexpr int SatParameters_RestartAlgorithm_RestartAlgorithm_ARRAYSIZE
Definition: sat_parameters.pb.h:229
operations_research::sat::PROTOBUF_FINAL::SearchBranching_Name
static const std::string & SearchBranching_Name(T enum_t_value)
Definition: sat_parameters.pb.h:794
operations_research::sat::PROTOBUF_FINAL::has_hint_conflict_limit
bool has_hint_conflict_limit() const
operations_research::sat::PROTOBUF_FINAL::clear_treat_binary_clauses_separately
void clear_treat_binary_clauses_separately()
operations_research::sat::SatParameters_MaxSatAssumptionOrder_Parse
bool SatParameters_MaxSatAssumptionOrder_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_MaxSatAssumptionOrder *value)
Definition: sat_parameters.pb.h:264
operations_research::sat::PROTOBUF_FINAL::use_optional_variables
bool use_optional_variables() const
operations_research::sat::SatParameters_RestartAlgorithm
SatParameters_RestartAlgorithm
Definition: sat_parameters.pb.h:219
operations_research::sat::PROTOBUF_FINAL::set_boolean_encoding_level
void set_boolean_encoding_level(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::SatParameters_RestartAlgorithm_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_RestartAlgorithm_descriptor()
operations_research::sat::PROTOBUF_FINAL::has_clause_cleanup_target
bool has_clause_cleanup_target() const
operations_research::sat::PROTOBUF_FINAL::has_mip_max_activity_exponent
bool has_mip_max_activity_exponent() const
operations_research::sat::PROTOBUF_FINAL::clear_binary_search_num_conflicts
void clear_binary_search_num_conflicts()
operations_research::sat::PROTOBUF_FINAL::clause_cleanup_lbd_bound
::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_lbd_bound() const
operations_research::sat::PROTOBUF_FINAL::clear_clause_cleanup_period
void clear_clause_cleanup_period()
operations_research::sat::PROTOBUF_FINAL::has_cut_cleanup_target
bool has_cut_cleanup_target() const
operations_research::sat::PROTOBUF_FINAL::clear_max_presolve_iterations
void clear_max_presolve_iterations()
operations_research::sat::PROTOBUF_FINAL::set_minimize_with_propagation_restart_period
void set_minimize_with_propagation_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_max_sat_reverse_assumption_order
bool has_max_sat_reverse_assumption_order() const
operations_research::sat::PROTOBUF_FINAL::set_default_restart_algorithms
void set_default_restart_algorithms(const char *value)
operations_research::sat::PROTOBUF_FINAL::stop_after_first_solution
bool stop_after_first_solution() const
operations_research::sat::PROTOBUF_FINAL::clear_minimization_algorithm
void clear_minimization_algorithm()
operations_research::sat::PROTOBUF_FINAL::restart_lbd_average_ratio
double restart_lbd_average_ratio() const
operations_research::sat::PROTOBUF_FINAL::randomize_search
bool randomize_search() const
operations_research::sat::PROTOBUF_FINAL::has_strategy_change_increase_ratio
bool has_strategy_change_increase_ratio() const
operations_research::sat::PROTOBUF_FINAL::clear_use_exact_lp_reason
void clear_use_exact_lp_reason()
operations_research::sat::PROTOBUF_FINAL::clear_max_all_diff_cut_size
void clear_max_all_diff_cut_size()
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_Name
const std::string & SatParameters_ConflictMinimizationAlgorithm_Name(T enum_t_value)
Definition: sat_parameters.pb.h:134
operations_research::sat::PROTOBUF_FINAL::clear_log_search_progress
void clear_log_search_progress()
operations_research::sat::PROTOBUF_FINAL::has_enumerate_all_solutions
bool has_enumerate_all_solutions() const
operations_research::sat::PROTOBUF_FINAL::operator=
SatParameters & operator=(const SatParameters &from)
Definition: sat_parameters.pb.h:360
operations_research::sat::PROTOBUF_FINAL::set_share_level_zero_bounds
void set_share_level_zero_bounds(bool value)
operations_research::sat::PROTOBUF_FINAL::has_merge_at_most_one_work_limit
bool has_merge_at_most_one_work_limit() const
operations_research::sat::PROTOBUF_FINAL::New
SatParameters * New(::PROTOBUF_NAMESPACE_ID::Arena *arena) const final
Definition: sat_parameters.pb.h:422
operations_research::sat::PROTOBUF_FINAL::set_max_presolve_iterations
void set_max_presolve_iterations(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_clause_cleanup_ordering
bool has_clause_cleanup_ordering() const
operations_research::sat::PROTOBUF_FINAL::has_mip_var_scaling
bool has_mip_var_scaling() const
operations_research::sat::PROTOBUF_FINAL::has_use_precedences_in_disjunctive_constraint
bool has_use_precedences_in_disjunctive_constraint() const
operations_research::sat::PROTOBUF_FINAL::clear_mip_wanted_precision
void clear_mip_wanted_precision()
operations_research::sat::PROTOBUF_FINAL::has_max_presolve_iterations
bool has_max_presolve_iterations() const
operations_research::sat::PROTOBUF_FINAL::set_add_lp_constraints_lazily
void set_add_lp_constraints_lazily(bool value)
operations_research::sat::PROTOBUF_FINAL::MaxSatAssumptionOrder_Parse
static bool MaxSatAssumptionOrder_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MaxSatAssumptionOrder *value)
Definition: sat_parameters.pb.h:728
operations_research::sat::PROTOBUF_FINAL::clear_share_objective_bounds
void clear_share_objective_bounds()
operations_research::sat::PROTOBUF_FINAL::ConflictMinimizationAlgorithm
SatParameters_ConflictMinimizationAlgorithm ConflictMinimizationAlgorithm
Definition: sat_parameters.pb.h:533
operations_research::sat::PROTOBUF_FINAL::set_minimize_reduction_during_pb_resolution
void set_minimize_reduction_during_pb_resolution(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_exploit_best_solution
void clear_exploit_best_solution()
operations_research::sat::PROTOBUF_FINAL::probing_period_at_root
::PROTOBUF_NAMESPACE_ID::int64 probing_period_at_root() const
operations_research::sat::PROTOBUF_FINAL::pb_cleanup_increment
::PROTOBUF_NAMESPACE_ID::int32 pb_cleanup_increment() const
operations_research::sat::PROTOBUF_FINAL::has_polarity_rephase_increment
bool has_polarity_rephase_increment() const
operations_research::sat::PROTOBUF_FINAL::has_minimize_with_propagation_num_decisions
bool has_minimize_with_propagation_num_decisions() const
operations_research::sat::SatParameters_SearchBranching_SearchBranching_ARRAYSIZE
constexpr int SatParameters_SearchBranching_SearchBranching_ARRAYSIZE
Definition: sat_parameters.pb.h:305
operations_research::sat::PROTOBUF_FINAL::merge_no_overlap_work_limit
double merge_no_overlap_work_limit() const
operations_research::sat::PROTOBUF_FINAL::Swap
void Swap(SatParameters *other)
Definition: sat_parameters.pb.h:402
operations_research::sat::PROTOBUF_FINAL::cut_cleanup_target
::PROTOBUF_NAMESPACE_ID::int32 cut_cleanup_target() const
operations_research::sat::PROTOBUF_FINAL::has_stop_after_first_solution
bool has_stop_after_first_solution() const
operations_research::sat::PROTOBUF_FINAL::set_clause_cleanup_ordering
void set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value)
operations_research::sat::PROTOBUF_FINAL::clear_restart_algorithms
void clear_restart_algorithms()
operations_research::sat::PROTOBUF_FINAL::set_find_multiple_cores
void set_find_multiple_cores(bool value)
operations_research::sat::PROTOBUF_FINAL::ClauseOrdering_IsValid
static bool ClauseOrdering_IsValid(int value)
Definition: sat_parameters.pb.h:640
operations_research::sat::PROTOBUF_FINAL::clear_cut_cleanup_target
void clear_cut_cleanup_target()
operations_research::sat::SatParameters_ClauseProtection_PROTECTION_LBD
@ SatParameters_ClauseProtection_PROTECTION_LBD
Definition: sat_parameters.pb.h:175
operations_research::sat::PROTOBUF_FINAL::_i_give_permission_to_break_this_code_default_default_restart_algorithms_
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed< std::string > _i_give_permission_to_break_this_code_default_default_restart_algorithms_
Definition: sat_parameters.pb.h:2895
operations_research::sat::PROTOBUF_FINAL::set_num_conflicts_before_strategy_changes
void set_num_conflicts_before_strategy_changes(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::interleave_search
bool interleave_search() const
operations_research::sat::SatParameters_MaxSatAssumptionOrder_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_MaxSatAssumptionOrder_descriptor()
operations_research::sat::PROTOBUF_FINAL::also_bump_variables_in_conflict_reasons
bool also_bump_variables_in_conflict_reasons() const
operations_research::sat::PROTOBUF_FINAL::has_relative_gap_limit
bool has_relative_gap_limit() const
operations_research::sat::PROTOBUF_FINAL::use_sat_inprocessing
bool use_sat_inprocessing() const
operations_research::sat::PROTOBUF_FINAL::find_multiple_cores
bool find_multiple_cores() const
operations_research::sat::PROTOBUF_FINAL::clear_add_cg_cuts
void clear_add_cg_cuts()
operations_research::sat::PROTOBUF_FINAL::minimize_core
bool minimize_core() const
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_Name
const std::string & SatParameters_MaxSatStratificationAlgorithm_Name(T enum_t_value)
Definition: sat_parameters.pb.h:281
operations_research::sat::PROTOBUF_FINAL::max_integer_rounding_scaling
::PROTOBUF_NAMESPACE_ID::int32 max_integer_rounding_scaling() const
operations_research::sat::PROTOBUF_FINAL::clear_mip_automatically_scale_variables
void clear_mip_automatically_scale_variables()
operations_research::sat::SatParameters_RestartAlgorithm_RestartAlgorithm_MIN
constexpr SatParameters_RestartAlgorithm SatParameters_RestartAlgorithm_RestartAlgorithm_MIN
Definition: sat_parameters.pb.h:227
operations_research::sat::PROTOBUF_FINAL::clear_cp_model_presolve
void clear_cp_model_presolve()
operations_research::sat::PROTOBUF_FINAL::has_cut_max_active_count_value
bool has_cut_max_active_count_value() const
operations_research::sat::PROTOBUF_FINAL::has_cover_optimization
bool has_cover_optimization() const
operations_research::sat::SatParameters_Polarity_POLARITY_RANDOM
@ SatParameters_Polarity_POLARITY_RANDOM
Definition: sat_parameters.pb.h:98
operations_research::sat::PROTOBUF_FINAL::set_presolve_bva_threshold
void set_presolve_bva_threshold(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::use_phase_saving
bool use_phase_saving() const
operations_research::sat::PROTOBUF_FINAL::ConflictMinimizationAlgorithm_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * ConflictMinimizationAlgorithm_descriptor()
Definition: sat_parameters.pb.h:552
operations_research::sat::PROTOBUF_FINAL::use_disjunctive_constraint_in_cumulative_constraint
bool use_disjunctive_constraint_in_cumulative_constraint() const
operations_research::sat::PROTOBUF_FINAL::Polarity_IsValid
static bool Polarity_IsValid(int value)
Definition: sat_parameters.pb.h:508
operations_research::sat::SatParameters_SearchBranching
SatParameters_SearchBranching
Definition: sat_parameters.pb.h:293
operations_research::sat::PROTOBUF_FINAL::max_variable_activity_value
double max_variable_activity_value() const
operations_research::sat::SatParameters_FPRoundingMethod_FPRoundingMethod_MAX
constexpr SatParameters_FPRoundingMethod SatParameters_FPRoundingMethod_FPRoundingMethod_MAX
Definition: sat_parameters.pb.h:329
operations_research::sat::PROTOBUF_FINAL::preferred_variable_order
::operations_research::sat::SatParameters_VariableOrder preferred_variable_order() const
operations_research::sat::PROTOBUF_FINAL::MaxSatStratificationAlgorithm
SatParameters_MaxSatStratificationAlgorithm MaxSatStratificationAlgorithm
Definition: sat_parameters.pb.h:733
operations_research::sat::PROTOBUF_FINAL::max_cut_rounds_at_level_zero
::PROTOBUF_NAMESPACE_ID::int32 max_cut_rounds_at_level_zero() const
operations_research::sat::SatParameters_MaxSatAssumptionOrder_Name
const std::string & SatParameters_MaxSatAssumptionOrder_Name(T enum_t_value)
Definition: sat_parameters.pb.h:257
operations_research::sat::PROTOBUF_FINAL::has_linearization_level
bool has_linearization_level() const
operations_research::sat::PROTOBUF_FINAL::has_random_polarity_ratio
bool has_random_polarity_ratio() const
operations_research::sat::PROTOBUF_FINAL::clear_initial_variables_activity
void clear_initial_variables_activity()
operations_research::sat::PROTOBUF_FINAL::set_cp_model_use_sat_presolve
void set_cp_model_use_sat_presolve(bool value)
operations_research::sat::PROTOBUF_FINAL::ClauseProtection_Name
static const std::string & ClauseProtection_Name(T enum_t_value)
Definition: sat_parameters.pb.h:624
operations_research::sat::PROTOBUF_FINAL::has_use_optimization_hints
bool has_use_optimization_hints() const
operations_research::sat::PROTOBUF_FINAL::set_glucose_max_decay
void set_glucose_max_decay(double value)
operations_research::sat::SatParameters_ClauseProtection_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_ClauseProtection_descriptor()
operations_research::sat::SatParameters_MaxSatAssumptionOrder
SatParameters_MaxSatAssumptionOrder
Definition: sat_parameters.pb.h:245
operations_research::sat::SatParameters_FPRoundingMethod_ACTIVE_LOCK_BASED
@ SatParameters_FPRoundingMethod_ACTIVE_LOCK_BASED
Definition: sat_parameters.pb.h:324
operations_research::sat::PROTOBUF_FINAL::clear_use_erwa_heuristic
void clear_use_erwa_heuristic()
operations_research::sat::PROTOBUF_FINAL::share_objective_bounds
bool share_objective_bounds() const
operations_research::sat::PROTOBUF_FINAL::has_max_cut_rounds_at_level_zero
bool has_max_cut_rounds_at_level_zero() const
operations_research::sat::PROTOBUF_FINAL::BinaryMinizationAlgorithm_Parse
static bool BinaryMinizationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BinaryMinizationAlgorithm *value)
Definition: sat_parameters.pb.h:598
operations_research::sat::PROTOBUF_FINAL::set_expand_automaton_constraints
void set_expand_automaton_constraints(bool value)
operations_research::sat::PROTOBUF_FINAL::mip_max_bound
double mip_max_bound() const
operations_research::sat::PROTOBUF_FINAL::pb_cleanup_ratio
double pb_cleanup_ratio() const
operations_research::sat::PROTOBUF_FINAL::set_fill_tightened_domains_in_response
void set_fill_tightened_domains_in_response(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_clause_cleanup_ordering
void clear_clause_cleanup_ordering()
operations_research::sat::PROTOBUF_FINAL::clear_presolve_bva_threshold
void clear_presolve_bva_threshold()
operations_research::sat::PROTOBUF_FINAL::set_instantiate_all_variables
void set_instantiate_all_variables(bool value)
operations_research::sat::PROTOBUF_FINAL::has_max_all_diff_cut_size
bool has_max_all_diff_cut_size() const
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_IsValid
bool SatParameters_ConflictMinimizationAlgorithm_IsValid(int value)
operations_research::sat::PROTOBUF_FINAL::set_relative_gap_limit
void set_relative_gap_limit(double value)
operations_research::sat::PROTOBUF_FINAL::clear_max_sat_stratification
void clear_max_sat_stratification()
operations_research::sat::PROTOBUF_FINAL::VariableOrder_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * VariableOrder_descriptor()
Definition: sat_parameters.pb.h:482
TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto::field_metadata
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]
Definition: sat_parameters.pb.h:53
operations_research::sat::SatParameters_Polarity_Polarity_ARRAYSIZE
constexpr int SatParameters_Polarity_Polarity_ARRAYSIZE
Definition: sat_parameters.pb.h:105
operations_research::sat::PROTOBUF_FINAL::set_use_phase_saving
void set_use_phase_saving(bool value)
operations_research::sat::PROTOBUF_FINAL::set_new_constraints_batch_size
void set_new_constraints_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::internal_default_instance
static const SatParameters * internal_default_instance()
Definition: sat_parameters.pb.h:392
operations_research::sat::PROTOBUF_FINAL::set_interleave_batch_size
void set_interleave_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::SatParameters_RestartAlgorithm_IsValid
bool SatParameters_RestartAlgorithm_IsValid(int value)
operations_research::sat::PROTOBUF_FINAL::use_pb_resolution
bool use_pb_resolution() const
operations_research::sat::PROTOBUF_FINAL::set_mip_max_bound
void set_mip_max_bound(double value)
operations_research::sat::PROTOBUF_FINAL::clear_presolve_use_bva
void clear_presolve_use_bva()
operations_research::sat::SatParameters_SearchBranching_IsValid
bool SatParameters_SearchBranching_IsValid(int value)
operations_research::sat::PROTOBUF_FINAL::clear_cut_active_count_decay
void clear_cut_active_count_decay()
operations_research::sat::PROTOBUF_FINAL::optimize_with_core
bool optimize_with_core() const
operations_research::sat::PROTOBUF_FINAL::clear_polarity_rephase_increment
void clear_polarity_rephase_increment()
operations_research::sat::PROTOBUF_FINAL::max_presolve_iterations
::PROTOBUF_NAMESPACE_ID::int32 max_presolve_iterations() const
operations_research::sat::PROTOBUF_FINAL::ClauseOrdering_Name
static const std::string & ClauseOrdering_Name(T enum_t_value)
Definition: sat_parameters.pb.h:654
operations_research::sat::PROTOBUF_FINAL::set_max_sat_stratification
void set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value)
operations_research::sat::PROTOBUF_FINAL::pseudo_cost_reliability_threshold
::PROTOBUF_NAMESPACE_ID::int64 pseudo_cost_reliability_threshold() const
operations_research::sat::PROTOBUF_FINAL::clear_search_randomization_tolerance
void clear_search_randomization_tolerance()
operations_research::sat::PROTOBUF_FINAL::clear_use_disjunctive_constraint_in_cumulative_constraint
void clear_use_disjunctive_constraint_in_cumulative_constraint()
operations_research::sat::PROTOBUF_FINAL::clear_only_add_cuts_at_level_zero
void clear_only_add_cuts_at_level_zero()
operations_research::sat::PROTOBUF_FINAL::clear_boolean_encoding_level
void clear_boolean_encoding_level()
operations_research::sat::PROTOBUF_FINAL::has_binary_minimization_algorithm
bool has_binary_minimization_algorithm() const
operations_research::sat::PROTOBUF_FINAL::clear_blocking_restart_multiplier
void clear_blocking_restart_multiplier()
operations_research::sat::PROTOBUF_FINAL::clear_max_deterministic_time
void clear_max_deterministic_time()
operations_research::sat::PROTOBUF_FINAL::add_restart_algorithms
void add_restart_algorithms(::operations_research::sat::SatParameters_RestartAlgorithm value)
operations_research::sat::PROTOBUF_FINAL::Polarity_Parse
static bool Polarity_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Polarity *value)
Definition: sat_parameters.pb.h:528
operations_research::sat::PROTOBUF_FINAL::use_relaxation_lns
bool use_relaxation_lns() const
operations_research::sat::PROTOBUF_FINAL::has_clause_cleanup_protection
bool has_clause_cleanup_protection() const
operations_research::sat::PROTOBUF_FINAL::use_exact_lp_reason
bool use_exact_lp_reason() const
operations_research::sat::SatParameters_SearchBranching_PORTFOLIO_WITH_QUICK_RESTART_SEARCH
@ SatParameters_SearchBranching_PORTFOLIO_WITH_QUICK_RESTART_SEARCH
Definition: sat_parameters.pb.h:299
operations_research::sat::PROTOBUF_FINAL::blocking_restart_window_size
::PROTOBUF_NAMESPACE_ID::int32 blocking_restart_window_size() const
operations_research::sat::PROTOBUF_FINAL::has_blocking_restart_window_size
bool has_blocking_restart_window_size() const
operations_research::sat::PROTOBUF_FINAL::clear_share_level_zero_bounds
void clear_share_level_zero_bounds()
operations_research::sat::SatParameters_SearchBranching_LP_SEARCH
@ SatParameters_SearchBranching_LP_SEARCH
Definition: sat_parameters.pb.h:297
operations_research::sat::PROTOBUF_FINAL::merge_at_most_one_work_limit
double merge_at_most_one_work_limit() const
operations_research::sat::PROTOBUF_FINAL::ConflictMinimizationAlgorithm_Name
static const std::string & ConflictMinimizationAlgorithm_Name(T enum_t_value)
Definition: sat_parameters.pb.h:556
operations_research::sat::PROTOBUF_FINAL::clear_presolve_bve_threshold
void clear_presolve_bve_threshold()
operations_research::sat::PROTOBUF_FINAL::FPRoundingMethod_Parse
static bool FPRoundingMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FPRoundingMethod *value)
Definition: sat_parameters.pb.h:834
operations_research::sat::PROTOBUF_FINAL::cp_model_postsolve_with_full_solver
bool cp_model_postsolve_with_full_solver() const
TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto::serialization_table
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]
Definition: sat_parameters.pb.h:54
operations_research::sat::PROTOBUF_FINAL::clear_presolve_substitution_level
void clear_presolve_substitution_level()
operations_research::sat::PROTOBUF_FINAL::use_feasibility_pump
bool use_feasibility_pump() const
operations_research::sat::PROTOBUF_FINAL::set_max_all_diff_cut_size
void set_max_all_diff_cut_size(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::glucose_decay_increment_period
::PROTOBUF_NAMESPACE_ID::int32 glucose_decay_increment_period() const
operations_research::sat::SatParameters_RestartAlgorithm_LBD_MOVING_AVERAGE_RESTART
@ SatParameters_RestartAlgorithm_LBD_MOVING_AVERAGE_RESTART
Definition: sat_parameters.pb.h:223
operations_research::sat::PROTOBUF_FINAL::has_catch_sigint_signal
bool has_catch_sigint_signal() const
operations_research::sat::PROTOBUF_FINAL::clear_add_lin_max_cuts
void clear_add_lin_max_cuts()
operations_research::sat::PROTOBUF_FINAL::set_default_restart_algorithms
void set_default_restart_algorithms(std::string &&value)
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MAX
constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MAX
Definition: sat_parameters.pb.h:129
operations_research::sat::PROTOBUF_FINAL::set_use_blocking_restart
void set_use_blocking_restart(bool value)
operations_research::sat::PROTOBUF_FINAL::set_share_objective_bounds
void set_share_objective_bounds(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_search_branching
void clear_search_branching()
operations_research::sat::PROTOBUF_FINAL::set_mip_var_scaling
void set_mip_var_scaling(double value)
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION
@ SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION
Definition: sat_parameters.pb.h:149
operations_research::sat::SatParameters_FPRoundingMethod_NEAREST_INTEGER
@ SatParameters_FPRoundingMethod_NEAREST_INTEGER
Definition: sat_parameters.pb.h:322
operations_research::sat::PROTOBUF_FINAL::set_random_seed
void set_random_seed(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_boolean_encoding_level
bool has_boolean_encoding_level() const
operations_research::sat::PROTOBUF_FINAL::FPRoundingMethod_IsValid
static bool FPRoundingMethod_IsValid(int value)
Definition: sat_parameters.pb.h:814
operations_research::sat::PROTOBUF_FINAL::has_use_pb_resolution
bool has_use_pb_resolution() const
operations_research::sat::PROTOBUF_FINAL::set_presolve_bve_clause_weight
void set_presolve_bve_clause_weight(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::Polarity
SatParameters_Polarity Polarity
Definition: sat_parameters.pb.h:497
operations_research::sat::PROTOBUF_FINAL::has_use_erwa_heuristic
bool has_use_erwa_heuristic() const
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_NONE
@ SatParameters_ConflictMinimizationAlgorithm_NONE
Definition: sat_parameters.pb.h:122
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_SIMPLE
@ SatParameters_ConflictMinimizationAlgorithm_SIMPLE
Definition: sat_parameters.pb.h:123
operations_research::sat::PROTOBUF_FINAL::has_optimize_with_max_hs
bool has_optimize_with_max_hs() const
operations_research::sat::SatParameters_ClauseProtection_ClauseProtection_MIN
constexpr SatParameters_ClauseProtection SatParameters_ClauseProtection_ClauseProtection_MIN
Definition: sat_parameters.pb.h:178
operations_research::sat::PROTOBUF_FINAL::fp_rounding
::operations_research::sat::SatParameters_FPRoundingMethod fp_rounding() const
operations_research::sat::PROTOBUF_FINAL::variable_activity_decay
double variable_activity_decay() const
operations_research::sat::PROTOBUF_FINAL::has_max_time_in_seconds
bool has_max_time_in_seconds() const
operations_research::sat::PROTOBUF_FINAL::has_minimization_algorithm
bool has_minimization_algorithm() const
operations_research::sat::PROTOBUF_FINAL::set_use_rins_lns
void set_use_rins_lns(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_num_conflicts_before_strategy_changes
void clear_num_conflicts_before_strategy_changes()
operations_research::sat::PROTOBUF_FINAL::has_mip_max_bound
bool has_mip_max_bound() const
operations_research::sat::PROTOBUF_FINAL::expand_automaton_constraints
bool expand_automaton_constraints() const
operations_research::sat::PROTOBUF_FINAL::search_branching
::operations_research::sat::SatParameters_SearchBranching search_branching() const
operations_research::sat::PROTOBUF_FINAL::has_log_search_progress
bool has_log_search_progress() const
operations_research::sat::PROTOBUF_FINAL::clear_min_orthogonality_for_lp_constraints
void clear_min_orthogonality_for_lp_constraints()
operations_research::sat::PROTOBUF_FINAL::clear_use_rins_lns
void clear_use_rins_lns()
operations_research::sat::PROTOBUF_FINAL::has_add_mir_cuts
bool has_add_mir_cuts() const
operations_research::sat::PROTOBUF_FINAL::clear_cp_model_probing_level
void clear_cp_model_probing_level()
operations_research::sat::PROTOBUF_FINAL::clear_minimize_core
void clear_minimize_core()
operations_research::sat::SatParameters_SearchBranching_HINT_SEARCH
@ SatParameters_SearchBranching_HINT_SEARCH
Definition: sat_parameters.pb.h:300
operations_research::sat::PROTOBUF_FINAL::clear_merge_at_most_one_work_limit
void clear_merge_at_most_one_work_limit()
operations_research::sat::PROTOBUF_FINAL::minimize_with_propagation_num_decisions
::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_num_decisions() const
operations_research::sat::PROTOBUF_FINAL::set_expand_element_constraints
void set_expand_element_constraints(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_use_pb_resolution
void clear_use_pb_resolution()
operations_research::sat::PROTOBUF_FINAL::has_restart_period
bool has_restart_period() const
operations_research::sat::PROTOBUF_FINAL::has_presolve_bve_clause_weight
bool has_presolve_bve_clause_weight() const
operations_research::sat::PROTOBUF_FINAL::set_strategy_change_increase_ratio
void set_strategy_change_increase_ratio(double value)
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MAX
constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MAX
Definition: sat_parameters.pb.h:276
operations_research::sat::PROTOBUF_FINAL::has_max_clause_activity_value
bool has_max_clause_activity_value() const
operations_research::sat::PROTOBUF_FINAL::max_number_of_conflicts
::PROTOBUF_NAMESPACE_ID::int64 max_number_of_conflicts() const
operations_research::sat::PROTOBUF_FINAL::SatParameters
SatParameters(SatParameters &&from) noexcept
Definition: sat_parameters.pb.h:355
operations_research::sat::PROTOBUF_FINAL::has_share_objective_bounds
bool has_share_objective_bounds() const
operations_research::sat::PROTOBUF_FINAL::search_randomization_tolerance
::PROTOBUF_NAMESPACE_ID::int64 search_randomization_tolerance() const
operations_research::sat::SatParameters_FPRoundingMethod_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_FPRoundingMethod_descriptor()
operations_research::sat::PROTOBUF_FINAL::set_minimization_algorithm
void set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value)
operations_research::sat::PROTOBUF_FINAL::clear_variable_activity_decay
void clear_variable_activity_decay()
operations_research::sat::PROTOBUF_FINAL::ClauseProtection
SatParameters_ClauseProtection ClauseProtection
Definition: sat_parameters.pb.h:603
operations_research::sat::PROTOBUF_FINAL::subsumption_during_conflict_analysis
bool subsumption_during_conflict_analysis() const
operations_research::sat::PROTOBUF_FINAL::set_random_branches_ratio
void set_random_branches_ratio(double value)
operations_research::sat::PROTOBUF_FINAL::has_minimize_with_propagation_restart_period
bool has_minimize_with_propagation_restart_period() const
operations_research::sat::PROTOBUF_FINAL::has_use_overload_checker_in_cumulative_constraint
bool has_use_overload_checker_in_cumulative_constraint() const
internal
Definition: boolean_problem.pb.h:39
operations_research::sat::PROTOBUF_FINAL::set_max_memory_in_mb
void set_max_memory_in_mb(::PROTOBUF_NAMESPACE_ID::int64 value)
operations_research::sat::PROTOBUF_FINAL::BinaryMinizationAlgorithm_Name
static const std::string & BinaryMinizationAlgorithm_Name(T enum_t_value)
Definition: sat_parameters.pb.h:592
operations_research::sat::PROTOBUF_FINAL::RestartAlgorithm_Parse
static bool RestartAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RestartAlgorithm *value)
Definition: sat_parameters.pb.h:696
operations_research::sat::PROTOBUF_FINAL::set_exploit_all_lp_solution
void set_exploit_all_lp_solution(bool value)
operations_research::sat::SatParameters_ClauseProtection_PROTECTION_ALWAYS
@ SatParameters_ClauseProtection_PROTECTION_ALWAYS
Definition: sat_parameters.pb.h:174
operations_research::sat::PROTOBUF_FINAL::set_cp_model_probing_level
void set_cp_model_probing_level(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_preferred_variable_order
bool has_preferred_variable_order() const
operations_research::sat::PROTOBUF_FINAL::use_timetable_edge_finding_in_cumulative_constraint
bool use_timetable_edge_finding_in_cumulative_constraint() const
operations_research::sat::PROTOBUF_FINAL::has_cp_model_postsolve_with_full_solver
bool has_cp_model_postsolve_with_full_solver() const
TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto::PROTOBUF_SECTION_VARIABLE
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold)
operations_research::sat::PROTOBUF_FINAL::absolute_gap_limit
double absolute_gap_limit() const
operations_research::sat::PROTOBUF_FINAL::clear_find_multiple_cores
void clear_find_multiple_cores()
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_ASCENT
@ SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_ASCENT
Definition: sat_parameters.pb.h:272
operations_research::sat::PROTOBUF_FINAL::has_exploit_best_solution
bool has_exploit_best_solution() const
operations_research::sat::PROTOBUF_FINAL::set_variable_activity_decay
void set_variable_activity_decay(double value)
operations_research::sat::PROTOBUF_FINAL::clear_restart_period
void clear_restart_period()
operations_research::sat::PROTOBUF_FINAL::VariableOrder_Name
static const std::string & VariableOrder_Name(T enum_t_value)
Definition: sat_parameters.pb.h:486
operations_research::sat::PROTOBUF_FINAL::has_also_bump_variables_in_conflict_reasons
bool has_also_bump_variables_in_conflict_reasons() const
operations_research::sat::PROTOBUF_FINAL::clear_max_memory_in_mb
void clear_max_memory_in_mb()
operations_research::sat::PROTOBUF_FINAL::has_pseudo_cost_reliability_threshold
bool has_pseudo_cost_reliability_threshold() const
operations_research::sat::PROTOBUF_FINAL::has_exploit_integer_lp_solution
bool has_exploit_integer_lp_solution() const
operations_research::sat::PROTOBUF_FINAL::only_add_cuts_at_level_zero
bool only_add_cuts_at_level_zero() const
operations_research::sat::PROTOBUF_FINAL::set_enumerate_all_solutions
void set_enumerate_all_solutions(bool value)
operations_research::sat::PROTOBUF_FINAL::boolean_encoding_level
::PROTOBUF_NAMESPACE_ID::int32 boolean_encoding_level() const
operations_research::sat::PROTOBUF_FINAL::set_use_feasibility_pump
void set_use_feasibility_pump(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_linearization_level
void clear_linearization_level()
operations_research::sat::SatParameters_Polarity_POLARITY_WEIGHTED_SIGN
@ SatParameters_Polarity_POLARITY_WEIGHTED_SIGN
Definition: sat_parameters.pb.h:99
operations_research::sat::PROTOBUF_FINAL::set_presolve_probing_deterministic_time_limit
void set_presolve_probing_deterministic_time_limit(double value)
operations_research::sat::SatParameters_ClauseOrdering_ClauseOrdering_MAX
constexpr SatParameters_ClauseOrdering SatParameters_ClauseOrdering_ClauseOrdering_MAX
Definition: sat_parameters.pb.h:202
operations_research::sat::PROTOBUF_FINAL::set_minimize_core
void set_minimize_core(bool value)
operations_research::sat::PROTOBUF_FINAL::set_max_sat_reverse_assumption_order
void set_max_sat_reverse_assumption_order(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_add_mir_cuts
void clear_add_mir_cuts()
operations_research::sat::PROTOBUF_FINAL::clear_mip_max_bound
void clear_mip_max_bound()
operations_research::sat::PROTOBUF_FINAL::presolve_bve_clause_weight
::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_clause_weight() const
operations_research::sat::PROTOBUF_FINAL::set_max_integer_rounding_scaling
void set_max_integer_rounding_scaling(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::presolve_blocked_clause
bool presolve_blocked_clause() const
operations_research::sat::PROTOBUF_FINAL::clear_relative_gap_limit
void clear_relative_gap_limit()
operations_research::sat::PROTOBUF_FINAL::set_count_assumption_levels_in_lbd
void set_count_assumption_levels_in_lbd(bool value)
TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto::offsets
static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]
Definition: sat_parameters.pb.h:55
operations_research::sat::PROTOBUF_FINAL::has_fill_tightened_domains_in_response
bool has_fill_tightened_domains_in_response() const
operations_research::sat::PROTOBUF_FINAL::has_use_lns_only
bool has_use_lns_only() const
operations_research::sat::PROTOBUF_FINAL::clear_max_variable_activity_value
void clear_max_variable_activity_value()
operations_research::sat::SatParameters_VariableOrder_IN_RANDOM_ORDER
@ SatParameters_VariableOrder_IN_RANDOM_ORDER
Definition: sat_parameters.pb.h:74
operations_research::sat::SatParameters_FPRoundingMethod_Parse
bool SatParameters_FPRoundingMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_FPRoundingMethod *value)
Definition: sat_parameters.pb.h:341
operations_research::sat::PROTOBUF_FINAL::add_cg_cuts
bool add_cg_cuts() const
operations_research::sat::PROTOBUF_FINAL::has_max_consecutive_inactive_count
bool has_max_consecutive_inactive_count() const
operations_research::sat::PROTOBUF_FINAL::ClauseOrdering_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * ClauseOrdering_descriptor()
Definition: sat_parameters.pb.h:650
operations_research::sat::SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MIN
constexpr SatParameters_MaxSatAssumptionOrder SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MIN
Definition: sat_parameters.pb.h:251
operations_research::sat::PROTOBUF_FINAL::interleave_batch_size
::PROTOBUF_NAMESPACE_ID::int32 interleave_batch_size() const
operations_research::sat::PROTOBUF_FINAL::set_hint_conflict_limit
void set_hint_conflict_limit(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::restart_period
::PROTOBUF_NAMESPACE_ID::int32 restart_period() const
operations_research::sat::PROTOBUF_FINAL::has_expand_table_constraints
bool has_expand_table_constraints() const
operations_research::sat::PROTOBUF_FINAL::clear_exploit_relaxation_solution
void clear_exploit_relaxation_solution()
operations_research::sat::PROTOBUF_FINAL::clear_preferred_variable_order
void clear_preferred_variable_order()
operations_research::sat::PROTOBUF_FINAL::has_binary_search_num_conflicts
bool has_binary_search_num_conflicts() const
operations_research::sat::PROTOBUF_FINAL::default_instance
static const SatParameters & default_instance()
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_IsValid
bool SatParameters_MaxSatStratificationAlgorithm_IsValid(int value)
operations_research::sat::SatParameters_ClauseProtection_PROTECTION_NONE
@ SatParameters_ClauseProtection_PROTECTION_NONE
Definition: sat_parameters.pb.h:173
operations_research::sat::PROTOBUF_FINAL::FPRoundingMethod
SatParameters_FPRoundingMethod FPRoundingMethod
Definition: sat_parameters.pb.h:805
operations_research::sat::PROTOBUF_FINAL::has_only_add_cuts_at_level_zero
bool has_only_add_cuts_at_level_zero() const
operations_research::sat::PROTOBUF_FINAL::has_use_relaxation_lns
bool has_use_relaxation_lns() const
operations_research::sat::PROTOBUF_FINAL::clear_repair_hint
void clear_repair_hint()
operations_research::sat::PROTOBUF_FINAL::set_initial_polarity
void set_initial_polarity(::operations_research::sat::SatParameters_Polarity value)
operations_research::sat::PROTOBUF_FINAL::has_glucose_max_decay
bool has_glucose_max_decay() const
operations_research::sat::PROTOBUF_FINAL::has_count_assumption_levels_in_lbd
bool has_count_assumption_levels_in_lbd() const
operations_research::sat::PROTOBUF_FINAL::clear_randomize_search
void clear_randomize_search()
operations_research::sat::PROTOBUF_FINAL::clear_use_phase_saving
void clear_use_phase_saving()
operations_research::sat::PROTOBUF_FINAL::set_use_timetable_edge_finding_in_cumulative_constraint
void set_use_timetable_edge_finding_in_cumulative_constraint(bool value)
operations_research::sat::PROTOBUF_FINAL::has_expand_automaton_constraints
bool has_expand_automaton_constraints() const
TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto
Definition: sat_parameters.pb.h:46
operations_research::sat::PROTOBUF_FINAL::has_instantiate_all_variables
bool has_instantiate_all_variables() const
operations_research::sat::PROTOBUF_FINAL::num_conflicts_before_strategy_changes
::PROTOBUF_NAMESPACE_ID::int32 num_conflicts_before_strategy_changes() const
operations_research::sat::PROTOBUF_FINAL::restart_algorithms
::operations_research::sat::SatParameters_RestartAlgorithm restart_algorithms(int index) const
operations_research::sat::PROTOBUF_FINAL::has_max_sat_assumption_order
bool has_max_sat_assumption_order() const
operations_research::sat::PROTOBUF_FINAL::has_minimize_reduction_during_pb_resolution
bool has_minimize_reduction_during_pb_resolution() const
operations_research::sat::PROTOBUF_FINAL::SearchBranching_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SearchBranching_descriptor()
Definition: sat_parameters.pb.h:790
operations_research::sat::PROTOBUF_FINAL::GetReflection
static const ::PROTOBUF_NAMESPACE_ID::Reflection * GetReflection()
Definition: sat_parameters.pb.h:386
operations_research::sat::PROTOBUF_FINAL::clear_reduce_memory_usage_in_interleave_mode
void clear_reduce_memory_usage_in_interleave_mode()
operations_research::sat::SatParameters_VariableOrder_IsValid
bool SatParameters_VariableOrder_IsValid(int value)
operations_research::sat::PROTOBUF_FINAL::set_expand_table_constraints
void set_expand_table_constraints(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_binary_minimization_algorithm
void clear_binary_minimization_algorithm()
operations_research::sat::PROTOBUF_FINAL::clear_cp_model_use_sat_presolve
void clear_cp_model_use_sat_presolve()
operations_research::sat::PROTOBUF_FINAL::has_use_rins_lns
bool has_use_rins_lns() const
operations_research::sat::PROTOBUF_FINAL::FPRoundingMethod_Name
static const std::string & FPRoundingMethod_Name(T enum_t_value)
Definition: sat_parameters.pb.h:828
operations_research::sat::PROTOBUF_FINAL::has_optimize_with_core
bool has_optimize_with_core() const
operations_research::sat::PROTOBUF_FINAL::clear_max_clause_activity_value
void clear_max_clause_activity_value()
operations_research::sat::PROTOBUF_FINAL::clear_stop_after_presolve
void clear_stop_after_presolve()
operations_research::sat::PROTOBUF_FINAL::clear_minimize_with_propagation_restart_period
void clear_minimize_with_propagation_restart_period()
operations_research::sat::PROTOBUF_FINAL::set_use_pb_resolution
void set_use_pb_resolution(bool value)
operations_research::sat::PROTOBUF_FINAL::set_use_optimization_hints
void set_use_optimization_hints(bool value)
operations_research::sat::SatParameters_ClauseProtection_Name
const std::string & SatParameters_ClauseProtection_Name(T enum_t_value)
Definition: sat_parameters.pb.h:184
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_ConflictMinimizationAlgorithm_descriptor()
operations_research::sat::PROTOBUF_FINAL::clear_minimize_reduction_during_pb_resolution
void clear_minimize_reduction_during_pb_resolution()
operations_research::sat::PROTOBUF_FINAL::clear_max_time_in_seconds
void clear_max_time_in_seconds()
operations_research::sat::PROTOBUF_FINAL::clause_activity_decay
double clause_activity_decay() const
operations_research::sat::PROTOBUF_FINAL::has_clause_activity_decay
bool has_clause_activity_decay() const
operations_research::sat::PROTOBUF_FINAL::exploit_objective
bool exploit_objective() const
operations_research::sat::PROTOBUF_FINAL::clear_new_constraints_batch_size
void clear_new_constraints_batch_size()
operations_research::sat::PROTOBUF_FINAL::strategy_change_increase_ratio
double strategy_change_increase_ratio() const
operations_research::sat::PROTOBUF_FINAL::has_absolute_gap_limit
bool has_absolute_gap_limit() const
operations_research::sat::PROTOBUF_FINAL::clear_expand_element_constraints
void clear_expand_element_constraints()
operations_research::sat::PROTOBUF_FINAL::set_merge_at_most_one_work_limit
void set_merge_at_most_one_work_limit(double value)
operations_research::sat::SatParameters_SearchBranching_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_SearchBranching_descriptor()
operations_research::sat::SatParameters_VariableOrder_VariableOrder_MIN
constexpr SatParameters_VariableOrder SatParameters_VariableOrder_VariableOrder_MIN
Definition: sat_parameters.pb.h:77
operations_research::sat::PROTOBUF_FINAL::ClauseProtection_IsValid
static bool ClauseProtection_IsValid(int value)
Definition: sat_parameters.pb.h:610
operations_research::sat::PROTOBUF_FINAL::SearchBranching_IsValid
static bool SearchBranching_IsValid(int value)
Definition: sat_parameters.pb.h:780
operations_research::sat::PROTOBUF_FINAL::presolve_probing_deterministic_time_limit
double presolve_probing_deterministic_time_limit() const
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_IsValid
bool SatParameters_BinaryMinizationAlgorithm_IsValid(int value)
operations_research::sat::PROTOBUF_FINAL::set_use_sat_inprocessing
void set_use_sat_inprocessing(bool value)
operations_research::sat::PROTOBUF_FINAL::set_restart_dl_average_ratio
void set_restart_dl_average_ratio(double value)
operations_research::sat::PROTOBUF_FINAL::has_max_memory_in_mb
bool has_max_memory_in_mb() const
operations_research::sat::SatParameters_VariableOrder_IN_REVERSE_ORDER
@ SatParameters_VariableOrder_IN_REVERSE_ORDER
Definition: sat_parameters.pb.h:73
operations_research::sat::PROTOBUF_FINAL::clear_cover_optimization
void clear_cover_optimization()
operations_research::sat::PROTOBUF_FINAL::lns_focus_on_decision_variables
bool lns_focus_on_decision_variables() const