Google OR-Tools v9.15
a fast and portable software suite for combinatorial optimization
Loading...
Searching...
No Matches
parameters.pb.h
Go to the documentation of this file.
1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// NO CHECKED-IN PROTOBUF GENCODE
3// source: ortools/glop/parameters.proto
4// Protobuf C++ Version: 6.33.1
5
6#ifndef ortools_2fglop_2fparameters_2eproto_2epb_2eh
7#define ortools_2fglop_2fparameters_2eproto_2epb_2eh
8
9#include <limits>
10#include <string>
11#include <type_traits>
12#include <utility>
13
14#include "google/protobuf/runtime_version.h"
15#if PROTOBUF_VERSION != 6033001
16#error "Protobuf C++ gencode is built with an incompatible version of"
17#error "Protobuf C++ headers/runtime. See"
18#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
19#endif
20#include "google/protobuf/io/coded_stream.h"
21#include "google/protobuf/arena.h"
22#include "google/protobuf/arenastring.h"
23#include "google/protobuf/generated_message_tctable_decl.h"
24#include "google/protobuf/generated_message_util.h"
25#include "google/protobuf/metadata_lite.h"
26#include "google/protobuf/generated_message_reflection.h"
27#include "google/protobuf/message.h"
28#include "google/protobuf/message_lite.h"
29#include "google/protobuf/repeated_field.h" // IWYU pragma: export
30#include "google/protobuf/extension_set.h" // IWYU pragma: export
31#include "google/protobuf/generated_enum_reflection.h"
32#include "google/protobuf/unknown_field_set.h"
33// @@protoc_insertion_point(includes)
34
35// Must be included last.
36#include "google/protobuf/port_def.inc"
37
38#define PROTOBUF_INTERNAL_EXPORT_ortools_2fglop_2fparameters_2eproto OR_PROTO_DLL
39
40namespace google {
41namespace protobuf {
42namespace internal {
43template <typename T>
44::absl::string_view GetAnyMessageName();
45} // namespace internal
46} // namespace protobuf
47} // namespace google
48
49// Internal implementation detail -- do not use these members.
50struct OR_PROTO_DLL TableStruct_ortools_2fglop_2fparameters_2eproto {
51 static const ::uint32_t offsets[];
52};
53extern "C" {
54OR_PROTO_DLL extern const ::google::protobuf::internal::DescriptorTable descriptor_table_ortools_2fglop_2fparameters_2eproto;
55} // extern "C"
56namespace operations_research {
57namespace glop {
58enum GlopParameters_CostScalingAlgorithm : int;
59OR_PROTO_DLL extern const uint32_t GlopParameters_CostScalingAlgorithm_internal_data_[];
60enum GlopParameters_InitialBasisHeuristic : int;
61OR_PROTO_DLL extern const uint32_t GlopParameters_InitialBasisHeuristic_internal_data_[];
62enum GlopParameters_PricingRule : int;
63OR_PROTO_DLL extern const uint32_t GlopParameters_PricingRule_internal_data_[];
64enum GlopParameters_ScalingAlgorithm : int;
65OR_PROTO_DLL extern const uint32_t GlopParameters_ScalingAlgorithm_internal_data_[];
66enum GlopParameters_SolverBehavior : int;
67OR_PROTO_DLL extern const uint32_t GlopParameters_SolverBehavior_internal_data_[];
68class GlopParameters;
69struct GlopParametersDefaultTypeInternal;
70OR_PROTO_DLL extern GlopParametersDefaultTypeInternal _GlopParameters_default_instance_;
71OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull GlopParameters_class_data_;
72} // namespace glop
73} // namespace operations_research
74namespace google {
75namespace protobuf {
76template <>
77internal::EnumTraitsT<::operations_research::glop::GlopParameters_CostScalingAlgorithm_internal_data_>
78 internal::EnumTraitsImpl::value<::operations_research::glop::GlopParameters_CostScalingAlgorithm>;
79template <>
80internal::EnumTraitsT<::operations_research::glop::GlopParameters_InitialBasisHeuristic_internal_data_>
81 internal::EnumTraitsImpl::value<::operations_research::glop::GlopParameters_InitialBasisHeuristic>;
82template <>
83internal::EnumTraitsT<::operations_research::glop::GlopParameters_PricingRule_internal_data_>
84 internal::EnumTraitsImpl::value<::operations_research::glop::GlopParameters_PricingRule>;
85template <>
86internal::EnumTraitsT<::operations_research::glop::GlopParameters_ScalingAlgorithm_internal_data_>
87 internal::EnumTraitsImpl::value<::operations_research::glop::GlopParameters_ScalingAlgorithm>;
88template <>
89internal::EnumTraitsT<::operations_research::glop::GlopParameters_SolverBehavior_internal_data_>
90 internal::EnumTraitsImpl::value<::operations_research::glop::GlopParameters_SolverBehavior>;
91} // namespace protobuf
92} // namespace google
93
94namespace operations_research {
95namespace glop {
101
102OR_PROTO_DLL extern const uint32_t GlopParameters_ScalingAlgorithm_internal_data_[];
103inline constexpr GlopParameters_ScalingAlgorithm GlopParameters_ScalingAlgorithm_ScalingAlgorithm_MIN =
104 static_cast<GlopParameters_ScalingAlgorithm>(0);
105inline constexpr GlopParameters_ScalingAlgorithm GlopParameters_ScalingAlgorithm_ScalingAlgorithm_MAX =
106 static_cast<GlopParameters_ScalingAlgorithm>(2);
107inline bool GlopParameters_ScalingAlgorithm_IsValid(int value) {
108 return 0 <= value && value <= 2;
109}
110inline constexpr int GlopParameters_ScalingAlgorithm_ScalingAlgorithm_ARRAYSIZE = 2 + 1;
111OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL GlopParameters_ScalingAlgorithm_descriptor();
112template <typename T>
113const ::std::string& GlopParameters_ScalingAlgorithm_Name(T value) {
114 static_assert(::std::is_same<T, GlopParameters_ScalingAlgorithm>::value ||
115 ::std::is_integral<T>::value,
116 "Incorrect type passed to ScalingAlgorithm_Name().");
117 return GlopParameters_ScalingAlgorithm_Name(static_cast<GlopParameters_ScalingAlgorithm>(value));
118}
119template <>
120inline const ::std::string& GlopParameters_ScalingAlgorithm_Name(GlopParameters_ScalingAlgorithm value) {
121 return ::google::protobuf::internal::NameOfDenseEnum<GlopParameters_ScalingAlgorithm_descriptor, 0, 2>(
122 static_cast<int>(value));
123}
124inline bool GlopParameters_ScalingAlgorithm_Parse(
125 ::absl::string_view name, GlopParameters_ScalingAlgorithm* PROTOBUF_NONNULL value) {
126 return ::google::protobuf::internal::ParseNamedEnum<GlopParameters_ScalingAlgorithm>(GlopParameters_ScalingAlgorithm_descriptor(), name,
127 value);
128}
134
135OR_PROTO_DLL extern const uint32_t GlopParameters_SolverBehavior_internal_data_[];
136inline constexpr GlopParameters_SolverBehavior GlopParameters_SolverBehavior_SolverBehavior_MIN =
137 static_cast<GlopParameters_SolverBehavior>(0);
138inline constexpr GlopParameters_SolverBehavior GlopParameters_SolverBehavior_SolverBehavior_MAX =
139 static_cast<GlopParameters_SolverBehavior>(2);
140inline bool GlopParameters_SolverBehavior_IsValid(int value) {
141 return 0 <= value && value <= 2;
142}
143inline constexpr int GlopParameters_SolverBehavior_SolverBehavior_ARRAYSIZE = 2 + 1;
144OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL GlopParameters_SolverBehavior_descriptor();
145template <typename T>
146const ::std::string& GlopParameters_SolverBehavior_Name(T value) {
147 static_assert(::std::is_same<T, GlopParameters_SolverBehavior>::value ||
148 ::std::is_integral<T>::value,
149 "Incorrect type passed to SolverBehavior_Name().");
150 return GlopParameters_SolverBehavior_Name(static_cast<GlopParameters_SolverBehavior>(value));
151}
152template <>
153inline const ::std::string& GlopParameters_SolverBehavior_Name(GlopParameters_SolverBehavior value) {
154 return ::google::protobuf::internal::NameOfDenseEnum<GlopParameters_SolverBehavior_descriptor, 0, 2>(
155 static_cast<int>(value));
156}
157inline bool GlopParameters_SolverBehavior_Parse(
158 ::absl::string_view name, GlopParameters_SolverBehavior* PROTOBUF_NONNULL value) {
159 return ::google::protobuf::internal::ParseNamedEnum<GlopParameters_SolverBehavior>(GlopParameters_SolverBehavior_descriptor(), name,
160 value);
161}
167
168OR_PROTO_DLL extern const uint32_t GlopParameters_PricingRule_internal_data_[];
169inline constexpr GlopParameters_PricingRule GlopParameters_PricingRule_PricingRule_MIN =
170 static_cast<GlopParameters_PricingRule>(0);
171inline constexpr GlopParameters_PricingRule GlopParameters_PricingRule_PricingRule_MAX =
172 static_cast<GlopParameters_PricingRule>(2);
173inline bool GlopParameters_PricingRule_IsValid(int value) {
174 return 0 <= value && value <= 2;
175}
176inline constexpr int GlopParameters_PricingRule_PricingRule_ARRAYSIZE = 2 + 1;
177OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL GlopParameters_PricingRule_descriptor();
178template <typename T>
179const ::std::string& GlopParameters_PricingRule_Name(T value) {
180 static_assert(::std::is_same<T, GlopParameters_PricingRule>::value ||
181 ::std::is_integral<T>::value,
182 "Incorrect type passed to PricingRule_Name().");
183 return GlopParameters_PricingRule_Name(static_cast<GlopParameters_PricingRule>(value));
184}
185template <>
186inline const ::std::string& GlopParameters_PricingRule_Name(GlopParameters_PricingRule value) {
187 return ::google::protobuf::internal::NameOfDenseEnum<GlopParameters_PricingRule_descriptor, 0, 2>(
188 static_cast<int>(value));
189}
190inline bool GlopParameters_PricingRule_Parse(
191 ::absl::string_view name, GlopParameters_PricingRule* PROTOBUF_NONNULL value) {
192 return ::google::protobuf::internal::ParseNamedEnum<GlopParameters_PricingRule>(GlopParameters_PricingRule_descriptor(), name,
193 value);
194}
201
202OR_PROTO_DLL extern const uint32_t GlopParameters_InitialBasisHeuristic_internal_data_[];
203inline constexpr GlopParameters_InitialBasisHeuristic GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_MIN =
204 static_cast<GlopParameters_InitialBasisHeuristic>(0);
205inline constexpr GlopParameters_InitialBasisHeuristic GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_MAX =
206 static_cast<GlopParameters_InitialBasisHeuristic>(3);
207inline bool GlopParameters_InitialBasisHeuristic_IsValid(int value) {
208 return 0 <= value && value <= 3;
209}
210inline constexpr int GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_ARRAYSIZE = 3 + 1;
211OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL GlopParameters_InitialBasisHeuristic_descriptor();
212template <typename T>
213const ::std::string& GlopParameters_InitialBasisHeuristic_Name(T value) {
214 static_assert(::std::is_same<T, GlopParameters_InitialBasisHeuristic>::value ||
215 ::std::is_integral<T>::value,
216 "Incorrect type passed to InitialBasisHeuristic_Name().");
217 return GlopParameters_InitialBasisHeuristic_Name(static_cast<GlopParameters_InitialBasisHeuristic>(value));
218}
219template <>
220inline const ::std::string& GlopParameters_InitialBasisHeuristic_Name(GlopParameters_InitialBasisHeuristic value) {
221 return ::google::protobuf::internal::NameOfDenseEnum<GlopParameters_InitialBasisHeuristic_descriptor, 0, 3>(
222 static_cast<int>(value));
223}
224inline bool GlopParameters_InitialBasisHeuristic_Parse(
225 ::absl::string_view name, GlopParameters_InitialBasisHeuristic* PROTOBUF_NONNULL value) {
226 return ::google::protobuf::internal::ParseNamedEnum<GlopParameters_InitialBasisHeuristic>(GlopParameters_InitialBasisHeuristic_descriptor(), name,
227 value);
228}
235
236OR_PROTO_DLL extern const uint32_t GlopParameters_CostScalingAlgorithm_internal_data_[];
237inline constexpr GlopParameters_CostScalingAlgorithm GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_MIN =
238 static_cast<GlopParameters_CostScalingAlgorithm>(0);
239inline constexpr GlopParameters_CostScalingAlgorithm GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_MAX =
240 static_cast<GlopParameters_CostScalingAlgorithm>(3);
241inline bool GlopParameters_CostScalingAlgorithm_IsValid(int value) {
242 return 0 <= value && value <= 3;
243}
244inline constexpr int GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_ARRAYSIZE = 3 + 1;
245OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL GlopParameters_CostScalingAlgorithm_descriptor();
246template <typename T>
247const ::std::string& GlopParameters_CostScalingAlgorithm_Name(T value) {
248 static_assert(::std::is_same<T, GlopParameters_CostScalingAlgorithm>::value ||
249 ::std::is_integral<T>::value,
250 "Incorrect type passed to CostScalingAlgorithm_Name().");
251 return GlopParameters_CostScalingAlgorithm_Name(static_cast<GlopParameters_CostScalingAlgorithm>(value));
252}
253template <>
254inline const ::std::string& GlopParameters_CostScalingAlgorithm_Name(GlopParameters_CostScalingAlgorithm value) {
255 return ::google::protobuf::internal::NameOfDenseEnum<GlopParameters_CostScalingAlgorithm_descriptor, 0, 3>(
256 static_cast<int>(value));
257}
258inline bool GlopParameters_CostScalingAlgorithm_Parse(
259 ::absl::string_view name, GlopParameters_CostScalingAlgorithm* PROTOBUF_NONNULL value) {
260 return ::google::protobuf::internal::ParseNamedEnum<GlopParameters_CostScalingAlgorithm>(GlopParameters_CostScalingAlgorithm_descriptor(), name,
261 value);
262}
263
264// ===================================================================
265
266
267// -------------------------------------------------------------------
268
269class OR_PROTO_DLL GlopParameters final : public ::google::protobuf::Message
270/* @@protoc_insertion_point(class_definition:operations_research.glop.GlopParameters) */ {
271 public:
272 inline GlopParameters() : GlopParameters(nullptr) {}
273 ~GlopParameters() PROTOBUF_FINAL;
274
275#if defined(PROTOBUF_CUSTOM_VTABLE)
276 void operator delete(GlopParameters* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
277 SharedDtor(*msg);
278 ::google::protobuf::internal::SizedDelete(msg, sizeof(GlopParameters));
279 }
280#endif
281
282 template <typename = void>
283 explicit PROTOBUF_CONSTEXPR GlopParameters(::google::protobuf::internal::ConstantInitialized);
284
285 inline GlopParameters(const GlopParameters& from) : GlopParameters(nullptr, from) {}
286 inline GlopParameters(GlopParameters&& from) noexcept
287 : GlopParameters(nullptr, ::std::move(from)) {}
288 inline GlopParameters& operator=(const GlopParameters& from) {
289 CopyFrom(from);
290 return *this;
291 }
292 inline GlopParameters& operator=(GlopParameters&& from) noexcept {
293 if (this == &from) return *this;
294 if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
295 InternalSwap(&from);
296 } else {
297 CopyFrom(from);
298 }
299 return *this;
300 }
301
302 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
303 ABSL_ATTRIBUTE_LIFETIME_BOUND {
304 return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
305 }
306 inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
307 ABSL_ATTRIBUTE_LIFETIME_BOUND {
308 return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
309 }
310
311 static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
312 return GetDescriptor();
313 }
314 static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
315 return default_instance().GetMetadata().descriptor;
316 }
317 static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
318 return default_instance().GetMetadata().reflection;
319 }
320 static const GlopParameters& default_instance() {
321 return *reinterpret_cast<const GlopParameters*>(
322 &_GlopParameters_default_instance_);
323 }
324 static constexpr int kIndexInFileMessages = 0;
325 friend void swap(GlopParameters& a, GlopParameters& b) { a.Swap(&b); }
326 inline void Swap(GlopParameters* PROTOBUF_NONNULL other) {
327 if (other == this) return;
328 if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
329 InternalSwap(other);
330 } else {
331 ::google::protobuf::internal::GenericSwap(this, other);
332 }
333 }
334 void UnsafeArenaSwap(GlopParameters* PROTOBUF_NONNULL other) {
335 if (other == this) return;
336 ABSL_DCHECK(GetArena() == other->GetArena());
337 InternalSwap(other);
338 }
339
340 // implements Message ----------------------------------------------
341
342 GlopParameters* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
343 return ::google::protobuf::Message::DefaultConstruct<GlopParameters>(arena);
344 }
345 using ::google::protobuf::Message::CopyFrom;
346 void CopyFrom(const GlopParameters& from);
347 using ::google::protobuf::Message::MergeFrom;
348 void MergeFrom(const GlopParameters& from) { GlopParameters::MergeImpl(*this, from); }
349
350 private:
351 static void MergeImpl(::google::protobuf::MessageLite& to_msg,
352 const ::google::protobuf::MessageLite& from_msg);
353
354 public:
355 bool IsInitialized() const {
356 return true;
357 }
358 ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
359 #if defined(PROTOBUF_CUSTOM_VTABLE)
360 private:
361 static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
362 static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
363 const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
364 ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
365
366 public:
367 ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
368 ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
369 ::uint8_t* PROTOBUF_NONNULL target,
370 ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
371 return _InternalSerialize(*this, target, stream);
372 }
373 #else // PROTOBUF_CUSTOM_VTABLE
374 ::size_t ByteSizeLong() const final;
375 ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
376 ::uint8_t* PROTOBUF_NONNULL target,
377 ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
378 #endif // PROTOBUF_CUSTOM_VTABLE
379 int GetCachedSize() const { return _impl_._cached_size_.Get(); }
380
381 private:
382 void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
383 static void SharedDtor(MessageLite& self);
384 void InternalSwap(GlopParameters* PROTOBUF_NONNULL other);
385 private:
386 template <typename T>
387 friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
388 static ::absl::string_view FullMessageName() { return "operations_research.glop.GlopParameters"; }
389
390 explicit GlopParameters(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
391 GlopParameters(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const GlopParameters& from);
392 GlopParameters(
393 ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, GlopParameters&& from) noexcept
394 : GlopParameters(arena) {
395 *this = ::std::move(from);
396 }
397 const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
398 static void* PROTOBUF_NONNULL PlacementNew_(
399 const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
400 ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
401 static constexpr auto InternalNewImpl_();
402
403 public:
404 static constexpr auto InternalGenerateClassData_();
405
406 ::google::protobuf::Metadata GetMetadata() const;
407 // nested types ----------------------------------------------------
408 using ScalingAlgorithm = GlopParameters_ScalingAlgorithm;
409 static constexpr ScalingAlgorithm DEFAULT = GlopParameters_ScalingAlgorithm_DEFAULT;
410 static constexpr ScalingAlgorithm EQUILIBRATION = GlopParameters_ScalingAlgorithm_EQUILIBRATION;
411 static constexpr ScalingAlgorithm LINEAR_PROGRAM = GlopParameters_ScalingAlgorithm_LINEAR_PROGRAM;
412 static inline bool ScalingAlgorithm_IsValid(int value) {
413 return GlopParameters_ScalingAlgorithm_IsValid(value);
414 }
415 static constexpr ScalingAlgorithm ScalingAlgorithm_MIN = GlopParameters_ScalingAlgorithm_ScalingAlgorithm_MIN;
416 static constexpr ScalingAlgorithm ScalingAlgorithm_MAX = GlopParameters_ScalingAlgorithm_ScalingAlgorithm_MAX;
417 static constexpr int ScalingAlgorithm_ARRAYSIZE = GlopParameters_ScalingAlgorithm_ScalingAlgorithm_ARRAYSIZE;
418 static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL ScalingAlgorithm_descriptor() {
419 return GlopParameters_ScalingAlgorithm_descriptor();
420 }
421 template <typename T>
422 static inline const ::std::string& ScalingAlgorithm_Name(T value) {
423 return GlopParameters_ScalingAlgorithm_Name(value);
424 }
425 static inline bool ScalingAlgorithm_Parse(
426 ::absl::string_view name, ScalingAlgorithm* PROTOBUF_NONNULL value) {
427 return GlopParameters_ScalingAlgorithm_Parse(name, value);
428 }
429 using SolverBehavior = GlopParameters_SolverBehavior;
430 static constexpr SolverBehavior ALWAYS_DO = GlopParameters_SolverBehavior_ALWAYS_DO;
431 static constexpr SolverBehavior NEVER_DO = GlopParameters_SolverBehavior_NEVER_DO;
432 static constexpr SolverBehavior LET_SOLVER_DECIDE = GlopParameters_SolverBehavior_LET_SOLVER_DECIDE;
433 static inline bool SolverBehavior_IsValid(int value) {
434 return GlopParameters_SolverBehavior_IsValid(value);
435 }
436 static constexpr SolverBehavior SolverBehavior_MIN = GlopParameters_SolverBehavior_SolverBehavior_MIN;
437 static constexpr SolverBehavior SolverBehavior_MAX = GlopParameters_SolverBehavior_SolverBehavior_MAX;
438 static constexpr int SolverBehavior_ARRAYSIZE = GlopParameters_SolverBehavior_SolverBehavior_ARRAYSIZE;
439 static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SolverBehavior_descriptor() {
440 return GlopParameters_SolverBehavior_descriptor();
441 }
442 template <typename T>
443 static inline const ::std::string& SolverBehavior_Name(T value) {
444 return GlopParameters_SolverBehavior_Name(value);
445 }
446 static inline bool SolverBehavior_Parse(
447 ::absl::string_view name, SolverBehavior* PROTOBUF_NONNULL value) {
448 return GlopParameters_SolverBehavior_Parse(name, value);
449 }
450 using PricingRule = GlopParameters_PricingRule;
451 static constexpr PricingRule DANTZIG = GlopParameters_PricingRule_DANTZIG;
452 static constexpr PricingRule STEEPEST_EDGE = GlopParameters_PricingRule_STEEPEST_EDGE;
453 static constexpr PricingRule DEVEX = GlopParameters_PricingRule_DEVEX;
454 static inline bool PricingRule_IsValid(int value) {
455 return GlopParameters_PricingRule_IsValid(value);
456 }
457 static constexpr PricingRule PricingRule_MIN = GlopParameters_PricingRule_PricingRule_MIN;
458 static constexpr PricingRule PricingRule_MAX = GlopParameters_PricingRule_PricingRule_MAX;
459 static constexpr int PricingRule_ARRAYSIZE = GlopParameters_PricingRule_PricingRule_ARRAYSIZE;
460 static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL PricingRule_descriptor() {
461 return GlopParameters_PricingRule_descriptor();
462 }
463 template <typename T>
464 static inline const ::std::string& PricingRule_Name(T value) {
465 return GlopParameters_PricingRule_Name(value);
466 }
467 static inline bool PricingRule_Parse(
468 ::absl::string_view name, PricingRule* PROTOBUF_NONNULL value) {
469 return GlopParameters_PricingRule_Parse(name, value);
470 }
471 using InitialBasisHeuristic = GlopParameters_InitialBasisHeuristic;
472 static constexpr InitialBasisHeuristic NONE = GlopParameters_InitialBasisHeuristic_NONE;
473 static constexpr InitialBasisHeuristic BIXBY = GlopParameters_InitialBasisHeuristic_BIXBY;
474 static constexpr InitialBasisHeuristic TRIANGULAR = GlopParameters_InitialBasisHeuristic_TRIANGULAR;
475 static constexpr InitialBasisHeuristic MAROS = GlopParameters_InitialBasisHeuristic_MAROS;
476 static inline bool InitialBasisHeuristic_IsValid(int value) {
477 return GlopParameters_InitialBasisHeuristic_IsValid(value);
478 }
479 static constexpr InitialBasisHeuristic InitialBasisHeuristic_MIN = GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_MIN;
480 static constexpr InitialBasisHeuristic InitialBasisHeuristic_MAX = GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_MAX;
481 static constexpr int InitialBasisHeuristic_ARRAYSIZE = GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_ARRAYSIZE;
482 static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL InitialBasisHeuristic_descriptor() {
483 return GlopParameters_InitialBasisHeuristic_descriptor();
484 }
485 template <typename T>
486 static inline const ::std::string& InitialBasisHeuristic_Name(T value) {
487 return GlopParameters_InitialBasisHeuristic_Name(value);
488 }
489 static inline bool InitialBasisHeuristic_Parse(
490 ::absl::string_view name, InitialBasisHeuristic* PROTOBUF_NONNULL value) {
491 return GlopParameters_InitialBasisHeuristic_Parse(name, value);
492 }
493 using CostScalingAlgorithm = GlopParameters_CostScalingAlgorithm;
494 static constexpr CostScalingAlgorithm NO_COST_SCALING = GlopParameters_CostScalingAlgorithm_NO_COST_SCALING;
495 static constexpr CostScalingAlgorithm CONTAIN_ONE_COST_SCALING = GlopParameters_CostScalingAlgorithm_CONTAIN_ONE_COST_SCALING;
496 static constexpr CostScalingAlgorithm MEAN_COST_SCALING = GlopParameters_CostScalingAlgorithm_MEAN_COST_SCALING;
497 static constexpr CostScalingAlgorithm MEDIAN_COST_SCALING = GlopParameters_CostScalingAlgorithm_MEDIAN_COST_SCALING;
498 static inline bool CostScalingAlgorithm_IsValid(int value) {
499 return GlopParameters_CostScalingAlgorithm_IsValid(value);
500 }
501 static constexpr CostScalingAlgorithm CostScalingAlgorithm_MIN = GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_MIN;
502 static constexpr CostScalingAlgorithm CostScalingAlgorithm_MAX = GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_MAX;
503 static constexpr int CostScalingAlgorithm_ARRAYSIZE = GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_ARRAYSIZE;
504 static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL CostScalingAlgorithm_descriptor() {
505 return GlopParameters_CostScalingAlgorithm_descriptor();
506 }
507 template <typename T>
508 static inline const ::std::string& CostScalingAlgorithm_Name(T value) {
509 return GlopParameters_CostScalingAlgorithm_Name(value);
510 }
511 static inline bool CostScalingAlgorithm_Parse(
512 ::absl::string_view name, CostScalingAlgorithm* PROTOBUF_NONNULL value) {
513 return GlopParameters_CostScalingAlgorithm_Parse(name, value);
514 }
515
516 // accessors -------------------------------------------------------
517 enum : int {
518 kUseDualSimplexFieldNumber = 31,
519 kFeasibilityRuleFieldNumber = 1,
520 kOptimizationRuleFieldNumber = 2,
521 kRefactorizationThresholdFieldNumber = 6,
522 kRecomputeReducedCostsThresholdFieldNumber = 8,
523 kRecomputeEdgesNormThresholdFieldNumber = 9,
524 kPrimalFeasibilityToleranceFieldNumber = 10,
525 kDualFeasibilityToleranceFieldNumber = 11,
526 kRatioTestZeroThresholdFieldNumber = 12,
527 kHarrisToleranceRatioFieldNumber = 13,
528 kSmallPivotThresholdFieldNumber = 14,
529 kMinimumAcceptablePivotFieldNumber = 15,
530 kInitialBasisFieldNumber = 17,
531 kBasisRefactorizationPeriodFieldNumber = 19,
532 kUseScalingFieldNumber = 16,
533 kUseTransposedMatrixFieldNumber = 18,
534 kProvideStrongOptimalGuaranteeFieldNumber = 24,
535 kSolveDualProblemFieldNumber = 20,
536 kDualizerThresholdFieldNumber = 21,
537 kSolutionFeasibilityToleranceFieldNumber = 22,
538 kLuFactorizationPivotThresholdFieldNumber = 25,
539 kMaxTimeInSecondsFieldNumber = 26,
540 kMaxNumberOfIterationsFieldNumber = 27,
541 kMarkowitzSingularityThresholdFieldNumber = 30,
542 kMarkowitzZlatevParameterFieldNumber = 29,
543 kNumOmpThreadsFieldNumber = 44,
544 kPreprocessorZeroToleranceFieldNumber = 39,
545 kAllowSimplexAlgorithmChangeFieldNumber = 32,
546 kPerturbCostsInDualSimplexFieldNumber = 53,
547 kLogSearchProgressFieldNumber = 61,
548 kDualPricePrioritizeNormFieldNumber = 69,
549 kUseAbslRandomFieldNumber = 72,
550 kDevexWeightsResetPeriodFieldNumber = 33,
551 kUsePreprocessingFieldNumber = 34,
552 kUseMiddleProductFormUpdateFieldNumber = 35,
553 kInitializeDevexWithColumnNormsFieldNumber = 36,
554 kExploitSingletonColumnInInitialBasisFieldNumber = 37,
555 kDualSmallPivotThresholdFieldNumber = 38,
556 kObjectiveLowerLimitFieldNumber = 40,
557 kObjectiveUpperLimitFieldNumber = 41,
558 kDegenerateMinistepFactorFieldNumber = 42,
559 kMaxDeterministicTimeFieldNumber = 45,
560 kRandomSeedFieldNumber = 43,
561 kScalingMethodFieldNumber = 57,
562 kDropToleranceFieldNumber = 52,
563 kRelativeCostPerturbationFieldNumber = 54,
564 kRelativeMaxCostPerturbationFieldNumber = 55,
565 kMaxNumberOfReoptimizationsFieldNumber = 56,
566 kInitialConditionNumberThresholdFieldNumber = 59,
567 kCostScalingFieldNumber = 60,
568 kChangeStatusToImpreciseFieldNumber = 58,
569 kUseDedicatedDualFeasibilityAlgorithmFieldNumber = 62,
570 kDynamicallyAdjustRefactorizationPeriodFieldNumber = 63,
571 kPushToVertexFieldNumber = 65,
572 kCrossoverBoundSnappingDistanceFieldNumber = 64,
573 kMaxValidMagnitudeFieldNumber = 70,
574 kDropMagnitudeFieldNumber = 71,
575 kLogToStdoutFieldNumber = 66,
576 kUseImpliedFreePreprocessorFieldNumber = 67,
577 };
578 // optional bool use_dual_simplex = 31 [default = false];
579 bool has_use_dual_simplex() const;
580 void clear_use_dual_simplex() ;
581 bool use_dual_simplex() const;
582 void set_use_dual_simplex(bool value);
583
584 private:
585 bool _internal_use_dual_simplex() const;
586 void _internal_set_use_dual_simplex(bool value);
587
588 public:
589 // optional .operations_research.glop.GlopParameters.PricingRule feasibility_rule = 1 [default = STEEPEST_EDGE];
590 bool has_feasibility_rule() const;
591 void clear_feasibility_rule() ;
592 ::operations_research::glop::GlopParameters_PricingRule feasibility_rule() const;
593 void set_feasibility_rule(::operations_research::glop::GlopParameters_PricingRule value);
594
595 private:
596 ::operations_research::glop::GlopParameters_PricingRule _internal_feasibility_rule() const;
597 void _internal_set_feasibility_rule(::operations_research::glop::GlopParameters_PricingRule value);
598
599 public:
600 // optional .operations_research.glop.GlopParameters.PricingRule optimization_rule = 2 [default = STEEPEST_EDGE];
601 bool has_optimization_rule() const;
602 void clear_optimization_rule() ;
603 ::operations_research::glop::GlopParameters_PricingRule optimization_rule() const;
604 void set_optimization_rule(::operations_research::glop::GlopParameters_PricingRule value);
605
606 private:
607 ::operations_research::glop::GlopParameters_PricingRule _internal_optimization_rule() const;
608 void _internal_set_optimization_rule(::operations_research::glop::GlopParameters_PricingRule value);
609
610 public:
611 // optional double refactorization_threshold = 6 [default = 1e-09];
612 bool has_refactorization_threshold() const;
613 void clear_refactorization_threshold() ;
614 double refactorization_threshold() const;
615 void set_refactorization_threshold(double value);
616
617 private:
618 double _internal_refactorization_threshold() const;
619 void _internal_set_refactorization_threshold(double value);
620
621 public:
622 // optional double recompute_reduced_costs_threshold = 8 [default = 1e-08];
623 bool has_recompute_reduced_costs_threshold() const;
624 void clear_recompute_reduced_costs_threshold() ;
625 double recompute_reduced_costs_threshold() const;
626 void set_recompute_reduced_costs_threshold(double value);
627
628 private:
629 double _internal_recompute_reduced_costs_threshold() const;
630 void _internal_set_recompute_reduced_costs_threshold(double value);
631
632 public:
633 // optional double recompute_edges_norm_threshold = 9 [default = 100];
634 bool has_recompute_edges_norm_threshold() const;
635 void clear_recompute_edges_norm_threshold() ;
636 double recompute_edges_norm_threshold() const;
637 void set_recompute_edges_norm_threshold(double value);
638
639 private:
640 double _internal_recompute_edges_norm_threshold() const;
641 void _internal_set_recompute_edges_norm_threshold(double value);
642
643 public:
644 // optional double primal_feasibility_tolerance = 10 [default = 1e-08];
645 bool has_primal_feasibility_tolerance() const;
646 void clear_primal_feasibility_tolerance() ;
647 double primal_feasibility_tolerance() const;
648 void set_primal_feasibility_tolerance(double value);
649
650 private:
651 double _internal_primal_feasibility_tolerance() const;
652 void _internal_set_primal_feasibility_tolerance(double value);
653
654 public:
655 // optional double dual_feasibility_tolerance = 11 [default = 1e-08];
656 bool has_dual_feasibility_tolerance() const;
657 void clear_dual_feasibility_tolerance() ;
658 double dual_feasibility_tolerance() const;
659 void set_dual_feasibility_tolerance(double value);
660
661 private:
662 double _internal_dual_feasibility_tolerance() const;
663 void _internal_set_dual_feasibility_tolerance(double value);
664
665 public:
666 // optional double ratio_test_zero_threshold = 12 [default = 1e-09];
667 bool has_ratio_test_zero_threshold() const;
668 void clear_ratio_test_zero_threshold() ;
669 double ratio_test_zero_threshold() const;
670 void set_ratio_test_zero_threshold(double value);
671
672 private:
673 double _internal_ratio_test_zero_threshold() const;
674 void _internal_set_ratio_test_zero_threshold(double value);
675
676 public:
677 // optional double harris_tolerance_ratio = 13 [default = 0.5];
678 bool has_harris_tolerance_ratio() const;
679 void clear_harris_tolerance_ratio() ;
680 double harris_tolerance_ratio() const;
681 void set_harris_tolerance_ratio(double value);
682
683 private:
684 double _internal_harris_tolerance_ratio() const;
685 void _internal_set_harris_tolerance_ratio(double value);
686
687 public:
688 // optional double small_pivot_threshold = 14 [default = 1e-06];
689 bool has_small_pivot_threshold() const;
690 void clear_small_pivot_threshold() ;
691 double small_pivot_threshold() const;
692 void set_small_pivot_threshold(double value);
693
694 private:
695 double _internal_small_pivot_threshold() const;
696 void _internal_set_small_pivot_threshold(double value);
697
698 public:
699 // optional double minimum_acceptable_pivot = 15 [default = 1e-06];
700 bool has_minimum_acceptable_pivot() const;
701 void clear_minimum_acceptable_pivot() ;
702 double minimum_acceptable_pivot() const;
703 void set_minimum_acceptable_pivot(double value);
704
705 private:
706 double _internal_minimum_acceptable_pivot() const;
707 void _internal_set_minimum_acceptable_pivot(double value);
708
709 public:
710 // optional .operations_research.glop.GlopParameters.InitialBasisHeuristic initial_basis = 17 [default = TRIANGULAR];
711 bool has_initial_basis() const;
712 void clear_initial_basis() ;
713 ::operations_research::glop::GlopParameters_InitialBasisHeuristic initial_basis() const;
714 void set_initial_basis(::operations_research::glop::GlopParameters_InitialBasisHeuristic value);
715
716 private:
717 ::operations_research::glop::GlopParameters_InitialBasisHeuristic _internal_initial_basis() const;
718 void _internal_set_initial_basis(::operations_research::glop::GlopParameters_InitialBasisHeuristic value);
719
720 public:
721 // optional int32 basis_refactorization_period = 19 [default = 64];
722 bool has_basis_refactorization_period() const;
723 void clear_basis_refactorization_period() ;
724 ::int32_t basis_refactorization_period() const;
725 void set_basis_refactorization_period(::int32_t value);
726
727 private:
728 ::int32_t _internal_basis_refactorization_period() const;
729 void _internal_set_basis_refactorization_period(::int32_t value);
730
731 public:
732 // optional bool use_scaling = 16 [default = true];
733 bool has_use_scaling() const;
734 void clear_use_scaling() ;
735 bool use_scaling() const;
736 void set_use_scaling(bool value);
737
738 private:
739 bool _internal_use_scaling() const;
740 void _internal_set_use_scaling(bool value);
741
742 public:
743 // optional bool use_transposed_matrix = 18 [default = true];
744 bool has_use_transposed_matrix() const;
745 void clear_use_transposed_matrix() ;
746 bool use_transposed_matrix() const;
747 void set_use_transposed_matrix(bool value);
748
749 private:
750 bool _internal_use_transposed_matrix() const;
751 void _internal_set_use_transposed_matrix(bool value);
752
753 public:
754 // optional bool provide_strong_optimal_guarantee = 24 [default = true];
755 bool has_provide_strong_optimal_guarantee() const;
756 void clear_provide_strong_optimal_guarantee() ;
757 bool provide_strong_optimal_guarantee() const;
758 void set_provide_strong_optimal_guarantee(bool value);
759
760 private:
761 bool _internal_provide_strong_optimal_guarantee() const;
762 void _internal_set_provide_strong_optimal_guarantee(bool value);
763
764 public:
765 // optional .operations_research.glop.GlopParameters.SolverBehavior solve_dual_problem = 20 [default = LET_SOLVER_DECIDE];
766 bool has_solve_dual_problem() const;
767 void clear_solve_dual_problem() ;
768 ::operations_research::glop::GlopParameters_SolverBehavior solve_dual_problem() const;
769 void set_solve_dual_problem(::operations_research::glop::GlopParameters_SolverBehavior value);
770
771 private:
772 ::operations_research::glop::GlopParameters_SolverBehavior _internal_solve_dual_problem() const;
773 void _internal_set_solve_dual_problem(::operations_research::glop::GlopParameters_SolverBehavior value);
774
775 public:
776 // optional double dualizer_threshold = 21 [default = 1.5];
777 bool has_dualizer_threshold() const;
778 void clear_dualizer_threshold() ;
779 double dualizer_threshold() const;
780 void set_dualizer_threshold(double value);
781
782 private:
783 double _internal_dualizer_threshold() const;
784 void _internal_set_dualizer_threshold(double value);
785
786 public:
787 // optional double solution_feasibility_tolerance = 22 [default = 1e-06];
788 bool has_solution_feasibility_tolerance() const;
789 void clear_solution_feasibility_tolerance() ;
790 double solution_feasibility_tolerance() const;
791 void set_solution_feasibility_tolerance(double value);
792
793 private:
794 double _internal_solution_feasibility_tolerance() const;
795 void _internal_set_solution_feasibility_tolerance(double value);
796
797 public:
798 // optional double lu_factorization_pivot_threshold = 25 [default = 0.01];
799 bool has_lu_factorization_pivot_threshold() const;
800 void clear_lu_factorization_pivot_threshold() ;
801 double lu_factorization_pivot_threshold() const;
802 void set_lu_factorization_pivot_threshold(double value);
803
804 private:
805 double _internal_lu_factorization_pivot_threshold() const;
806 void _internal_set_lu_factorization_pivot_threshold(double value);
807
808 public:
809 // optional double max_time_in_seconds = 26 [default = inf];
810 bool has_max_time_in_seconds() const;
811 void clear_max_time_in_seconds() ;
812 double max_time_in_seconds() const;
813 void set_max_time_in_seconds(double value);
814
815 private:
816 double _internal_max_time_in_seconds() const;
817 void _internal_set_max_time_in_seconds(double value);
818
819 public:
820 // optional int64 max_number_of_iterations = 27 [default = -1];
821 bool has_max_number_of_iterations() const;
822 void clear_max_number_of_iterations() ;
823 ::int64_t max_number_of_iterations() const;
824 void set_max_number_of_iterations(::int64_t value);
825
826 private:
827 ::int64_t _internal_max_number_of_iterations() const;
828 void _internal_set_max_number_of_iterations(::int64_t value);
829
830 public:
831 // optional double markowitz_singularity_threshold = 30 [default = 1e-15];
832 bool has_markowitz_singularity_threshold() const;
833 void clear_markowitz_singularity_threshold() ;
834 double markowitz_singularity_threshold() const;
835 void set_markowitz_singularity_threshold(double value);
836
837 private:
838 double _internal_markowitz_singularity_threshold() const;
839 void _internal_set_markowitz_singularity_threshold(double value);
840
841 public:
842 // optional int32 markowitz_zlatev_parameter = 29 [default = 3];
843 bool has_markowitz_zlatev_parameter() const;
844 void clear_markowitz_zlatev_parameter() ;
845 ::int32_t markowitz_zlatev_parameter() const;
846 void set_markowitz_zlatev_parameter(::int32_t value);
847
848 private:
849 ::int32_t _internal_markowitz_zlatev_parameter() const;
850 void _internal_set_markowitz_zlatev_parameter(::int32_t value);
851
852 public:
853 // optional int32 num_omp_threads = 44 [default = 1];
854 bool has_num_omp_threads() const;
855 void clear_num_omp_threads() ;
856 ::int32_t num_omp_threads() const;
857 void set_num_omp_threads(::int32_t value);
858
859 private:
860 ::int32_t _internal_num_omp_threads() const;
861 void _internal_set_num_omp_threads(::int32_t value);
862
863 public:
864 // optional double preprocessor_zero_tolerance = 39 [default = 1e-09];
865 bool has_preprocessor_zero_tolerance() const;
866 void clear_preprocessor_zero_tolerance() ;
867 double preprocessor_zero_tolerance() const;
868 void set_preprocessor_zero_tolerance(double value);
869
870 private:
871 double _internal_preprocessor_zero_tolerance() const;
872 void _internal_set_preprocessor_zero_tolerance(double value);
873
874 public:
875 // optional bool allow_simplex_algorithm_change = 32 [default = false];
876 bool has_allow_simplex_algorithm_change() const;
877 void clear_allow_simplex_algorithm_change() ;
878 bool allow_simplex_algorithm_change() const;
879 void set_allow_simplex_algorithm_change(bool value);
880
881 private:
882 bool _internal_allow_simplex_algorithm_change() const;
883 void _internal_set_allow_simplex_algorithm_change(bool value);
884
885 public:
886 // optional bool perturb_costs_in_dual_simplex = 53 [default = false];
887 bool has_perturb_costs_in_dual_simplex() const;
888 void clear_perturb_costs_in_dual_simplex() ;
889 bool perturb_costs_in_dual_simplex() const;
890 void set_perturb_costs_in_dual_simplex(bool value);
891
892 private:
893 bool _internal_perturb_costs_in_dual_simplex() const;
894 void _internal_set_perturb_costs_in_dual_simplex(bool value);
895
896 public:
897 // optional bool log_search_progress = 61 [default = false];
898 bool has_log_search_progress() const;
899 void clear_log_search_progress() ;
900 bool log_search_progress() const;
901 void set_log_search_progress(bool value);
902
903 private:
904 bool _internal_log_search_progress() const;
905 void _internal_set_log_search_progress(bool value);
906
907 public:
908 // optional bool dual_price_prioritize_norm = 69 [default = false];
909 bool has_dual_price_prioritize_norm() const;
910 void clear_dual_price_prioritize_norm() ;
911 bool dual_price_prioritize_norm() const;
912 void set_dual_price_prioritize_norm(bool value);
913
914 private:
915 bool _internal_dual_price_prioritize_norm() const;
916 void _internal_set_dual_price_prioritize_norm(bool value);
917
918 public:
919 // optional bool use_absl_random = 72 [default = false];
920 bool has_use_absl_random() const;
921 void clear_use_absl_random() ;
922 bool use_absl_random() const;
923 void set_use_absl_random(bool value);
924
925 private:
926 bool _internal_use_absl_random() const;
927 void _internal_set_use_absl_random(bool value);
928
929 public:
930 // optional int32 devex_weights_reset_period = 33 [default = 150];
931 bool has_devex_weights_reset_period() const;
932 void clear_devex_weights_reset_period() ;
933 ::int32_t devex_weights_reset_period() const;
934 void set_devex_weights_reset_period(::int32_t value);
935
936 private:
937 ::int32_t _internal_devex_weights_reset_period() const;
938 void _internal_set_devex_weights_reset_period(::int32_t value);
939
940 public:
941 // optional bool use_preprocessing = 34 [default = true];
942 bool has_use_preprocessing() const;
943 void clear_use_preprocessing() ;
944 bool use_preprocessing() const;
945 void set_use_preprocessing(bool value);
946
947 private:
948 bool _internal_use_preprocessing() const;
949 void _internal_set_use_preprocessing(bool value);
950
951 public:
952 // optional bool use_middle_product_form_update = 35 [default = true];
953 bool has_use_middle_product_form_update() const;
954 void clear_use_middle_product_form_update() ;
955 bool use_middle_product_form_update() const;
956 void set_use_middle_product_form_update(bool value);
957
958 private:
959 bool _internal_use_middle_product_form_update() const;
960 void _internal_set_use_middle_product_form_update(bool value);
961
962 public:
963 // optional bool initialize_devex_with_column_norms = 36 [default = true];
964 bool has_initialize_devex_with_column_norms() const;
965 void clear_initialize_devex_with_column_norms() ;
966 bool initialize_devex_with_column_norms() const;
967 void set_initialize_devex_with_column_norms(bool value);
968
969 private:
970 bool _internal_initialize_devex_with_column_norms() const;
971 void _internal_set_initialize_devex_with_column_norms(bool value);
972
973 public:
974 // optional bool exploit_singleton_column_in_initial_basis = 37 [default = true];
975 bool has_exploit_singleton_column_in_initial_basis() const;
976 void clear_exploit_singleton_column_in_initial_basis() ;
977 bool exploit_singleton_column_in_initial_basis() const;
978 void set_exploit_singleton_column_in_initial_basis(bool value);
979
980 private:
981 bool _internal_exploit_singleton_column_in_initial_basis() const;
982 void _internal_set_exploit_singleton_column_in_initial_basis(bool value);
983
984 public:
985 // optional double dual_small_pivot_threshold = 38 [default = 0.0001];
986 bool has_dual_small_pivot_threshold() const;
987 void clear_dual_small_pivot_threshold() ;
988 double dual_small_pivot_threshold() const;
989 void set_dual_small_pivot_threshold(double value);
990
991 private:
992 double _internal_dual_small_pivot_threshold() const;
993 void _internal_set_dual_small_pivot_threshold(double value);
994
995 public:
996 // optional double objective_lower_limit = 40 [default = -inf];
997 bool has_objective_lower_limit() const;
998 void clear_objective_lower_limit() ;
999 double objective_lower_limit() const;
1000 void set_objective_lower_limit(double value);
1001
1002 private:
1003 double _internal_objective_lower_limit() const;
1004 void _internal_set_objective_lower_limit(double value);
1005
1006 public:
1007 // optional double objective_upper_limit = 41 [default = inf];
1008 bool has_objective_upper_limit() const;
1009 void clear_objective_upper_limit() ;
1010 double objective_upper_limit() const;
1011 void set_objective_upper_limit(double value);
1012
1013 private:
1014 double _internal_objective_upper_limit() const;
1015 void _internal_set_objective_upper_limit(double value);
1016
1017 public:
1018 // optional double degenerate_ministep_factor = 42 [default = 0.01];
1019 bool has_degenerate_ministep_factor() const;
1020 void clear_degenerate_ministep_factor() ;
1021 double degenerate_ministep_factor() const;
1022 void set_degenerate_ministep_factor(double value);
1023
1024 private:
1025 double _internal_degenerate_ministep_factor() const;
1026 void _internal_set_degenerate_ministep_factor(double value);
1027
1028 public:
1029 // optional double max_deterministic_time = 45 [default = inf];
1030 bool has_max_deterministic_time() const;
1031 void clear_max_deterministic_time() ;
1032 double max_deterministic_time() const;
1033 void set_max_deterministic_time(double value);
1034
1035 private:
1036 double _internal_max_deterministic_time() const;
1037 void _internal_set_max_deterministic_time(double value);
1038
1039 public:
1040 // optional int32 random_seed = 43 [default = 1];
1041 bool has_random_seed() const;
1042 void clear_random_seed() ;
1043 ::int32_t random_seed() const;
1044 void set_random_seed(::int32_t value);
1045
1046 private:
1047 ::int32_t _internal_random_seed() const;
1048 void _internal_set_random_seed(::int32_t value);
1049
1050 public:
1051 // optional .operations_research.glop.GlopParameters.ScalingAlgorithm scaling_method = 57 [default = EQUILIBRATION];
1052 bool has_scaling_method() const;
1053 void clear_scaling_method() ;
1054 ::operations_research::glop::GlopParameters_ScalingAlgorithm scaling_method() const;
1055 void set_scaling_method(::operations_research::glop::GlopParameters_ScalingAlgorithm value);
1056
1057 private:
1058 ::operations_research::glop::GlopParameters_ScalingAlgorithm _internal_scaling_method() const;
1059 void _internal_set_scaling_method(::operations_research::glop::GlopParameters_ScalingAlgorithm value);
1060
1061 public:
1062 // optional double drop_tolerance = 52 [default = 1e-14];
1063 bool has_drop_tolerance() const;
1064 void clear_drop_tolerance() ;
1065 double drop_tolerance() const;
1066 void set_drop_tolerance(double value);
1067
1068 private:
1069 double _internal_drop_tolerance() const;
1070 void _internal_set_drop_tolerance(double value);
1071
1072 public:
1073 // optional double relative_cost_perturbation = 54 [default = 1e-05];
1074 bool has_relative_cost_perturbation() const;
1075 void clear_relative_cost_perturbation() ;
1076 double relative_cost_perturbation() const;
1077 void set_relative_cost_perturbation(double value);
1078
1079 private:
1080 double _internal_relative_cost_perturbation() const;
1081 void _internal_set_relative_cost_perturbation(double value);
1082
1083 public:
1084 // optional double relative_max_cost_perturbation = 55 [default = 1e-07];
1085 bool has_relative_max_cost_perturbation() const;
1086 void clear_relative_max_cost_perturbation() ;
1087 double relative_max_cost_perturbation() const;
1088 void set_relative_max_cost_perturbation(double value);
1089
1090 private:
1091 double _internal_relative_max_cost_perturbation() const;
1092 void _internal_set_relative_max_cost_perturbation(double value);
1093
1094 public:
1095 // optional double max_number_of_reoptimizations = 56 [default = 40];
1096 bool has_max_number_of_reoptimizations() const;
1097 void clear_max_number_of_reoptimizations() ;
1098 double max_number_of_reoptimizations() const;
1099 void set_max_number_of_reoptimizations(double value);
1100
1101 private:
1102 double _internal_max_number_of_reoptimizations() const;
1103 void _internal_set_max_number_of_reoptimizations(double value);
1104
1105 public:
1106 // optional double initial_condition_number_threshold = 59 [default = 1e+50];
1107 bool has_initial_condition_number_threshold() const;
1108 void clear_initial_condition_number_threshold() ;
1109 double initial_condition_number_threshold() const;
1110 void set_initial_condition_number_threshold(double value);
1111
1112 private:
1113 double _internal_initial_condition_number_threshold() const;
1114 void _internal_set_initial_condition_number_threshold(double value);
1115
1116 public:
1117 // optional .operations_research.glop.GlopParameters.CostScalingAlgorithm cost_scaling = 60 [default = CONTAIN_ONE_COST_SCALING];
1118 bool has_cost_scaling() const;
1119 void clear_cost_scaling() ;
1120 ::operations_research::glop::GlopParameters_CostScalingAlgorithm cost_scaling() const;
1121 void set_cost_scaling(::operations_research::glop::GlopParameters_CostScalingAlgorithm value);
1122
1123 private:
1124 ::operations_research::glop::GlopParameters_CostScalingAlgorithm _internal_cost_scaling() const;
1125 void _internal_set_cost_scaling(::operations_research::glop::GlopParameters_CostScalingAlgorithm value);
1126
1127 public:
1128 // optional bool change_status_to_imprecise = 58 [default = true];
1129 bool has_change_status_to_imprecise() const;
1130 void clear_change_status_to_imprecise() ;
1131 bool change_status_to_imprecise() const;
1132 void set_change_status_to_imprecise(bool value);
1133
1134 private:
1135 bool _internal_change_status_to_imprecise() const;
1136 void _internal_set_change_status_to_imprecise(bool value);
1137
1138 public:
1139 // optional bool use_dedicated_dual_feasibility_algorithm = 62 [default = true];
1140 bool has_use_dedicated_dual_feasibility_algorithm() const;
1141 void clear_use_dedicated_dual_feasibility_algorithm() ;
1142 bool use_dedicated_dual_feasibility_algorithm() const;
1143 void set_use_dedicated_dual_feasibility_algorithm(bool value);
1144
1145 private:
1146 bool _internal_use_dedicated_dual_feasibility_algorithm() const;
1147 void _internal_set_use_dedicated_dual_feasibility_algorithm(bool value);
1148
1149 public:
1150 // optional bool dynamically_adjust_refactorization_period = 63 [default = true];
1151 bool has_dynamically_adjust_refactorization_period() const;
1152 void clear_dynamically_adjust_refactorization_period() ;
1153 bool dynamically_adjust_refactorization_period() const;
1154 void set_dynamically_adjust_refactorization_period(bool value);
1155
1156 private:
1157 bool _internal_dynamically_adjust_refactorization_period() const;
1158 void _internal_set_dynamically_adjust_refactorization_period(bool value);
1159
1160 public:
1161 // optional bool push_to_vertex = 65 [default = true];
1162 bool has_push_to_vertex() const;
1163 void clear_push_to_vertex() ;
1164 bool push_to_vertex() const;
1165 void set_push_to_vertex(bool value);
1166
1167 private:
1168 bool _internal_push_to_vertex() const;
1169 void _internal_set_push_to_vertex(bool value);
1170
1171 public:
1172 // optional double crossover_bound_snapping_distance = 64 [default = inf];
1173 bool has_crossover_bound_snapping_distance() const;
1174 void clear_crossover_bound_snapping_distance() ;
1175 double crossover_bound_snapping_distance() const;
1176 void set_crossover_bound_snapping_distance(double value);
1177
1178 private:
1179 double _internal_crossover_bound_snapping_distance() const;
1180 void _internal_set_crossover_bound_snapping_distance(double value);
1181
1182 public:
1183 // optional double max_valid_magnitude = 70 [default = 1e+30];
1184 bool has_max_valid_magnitude() const;
1185 void clear_max_valid_magnitude() ;
1186 double max_valid_magnitude() const;
1187 void set_max_valid_magnitude(double value);
1188
1189 private:
1190 double _internal_max_valid_magnitude() const;
1191 void _internal_set_max_valid_magnitude(double value);
1192
1193 public:
1194 // optional double drop_magnitude = 71 [default = 1e-30];
1195 bool has_drop_magnitude() const;
1196 void clear_drop_magnitude() ;
1197 double drop_magnitude() const;
1198 void set_drop_magnitude(double value);
1199
1200 private:
1201 double _internal_drop_magnitude() const;
1202 void _internal_set_drop_magnitude(double value);
1203
1204 public:
1205 // optional bool log_to_stdout = 66 [default = true];
1206 bool has_log_to_stdout() const;
1207 void clear_log_to_stdout() ;
1208 bool log_to_stdout() const;
1209 void set_log_to_stdout(bool value);
1210
1211 private:
1212 bool _internal_log_to_stdout() const;
1213 void _internal_set_log_to_stdout(bool value);
1214
1215 public:
1216 // optional bool use_implied_free_preprocessor = 67 [default = true];
1217 bool has_use_implied_free_preprocessor() const;
1218 void clear_use_implied_free_preprocessor() ;
1219 bool use_implied_free_preprocessor() const;
1220 void set_use_implied_free_preprocessor(bool value);
1221
1222 private:
1223 bool _internal_use_implied_free_preprocessor() const;
1224 void _internal_set_use_implied_free_preprocessor(bool value);
1225
1226 public:
1227 // @@protoc_insertion_point(class_scope:operations_research.glop.GlopParameters)
1228 private:
1229 class _Internal;
1230 friend class ::google::protobuf::internal::TcParser;
1231 static const ::google::protobuf::internal::TcParseTable<5, 59,
1232 6, 0,
1233 11>
1234 _table_;
1235
1236 friend class ::google::protobuf::MessageLite;
1237 friend class ::google::protobuf::Arena;
1238 template <typename T>
1239 friend class ::google::protobuf::Arena::InternalHelper;
1240 using InternalArenaConstructable_ = void;
1241 using DestructorSkippable_ = void;
1242 struct Impl_ {
1243 inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
1244 inline explicit Impl_(
1245 ::google::protobuf::internal::InternalVisibility visibility,
1246 ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1247 inline explicit Impl_(
1248 ::google::protobuf::internal::InternalVisibility visibility,
1249 ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
1250 const GlopParameters& from_msg);
1251 ::google::protobuf::internal::HasBits<2> _has_bits_;
1252 ::google::protobuf::internal::CachedSize _cached_size_;
1253 bool use_dual_simplex_;
1254 int feasibility_rule_;
1255 int optimization_rule_;
1256 double refactorization_threshold_;
1257 double recompute_reduced_costs_threshold_;
1258 double recompute_edges_norm_threshold_;
1259 double primal_feasibility_tolerance_;
1260 double dual_feasibility_tolerance_;
1261 double ratio_test_zero_threshold_;
1262 double harris_tolerance_ratio_;
1263 double small_pivot_threshold_;
1264 double minimum_acceptable_pivot_;
1265 int initial_basis_;
1266 ::int32_t basis_refactorization_period_;
1267 bool use_scaling_;
1268 bool use_transposed_matrix_;
1269 bool provide_strong_optimal_guarantee_;
1270 int solve_dual_problem_;
1271 double dualizer_threshold_;
1272 double solution_feasibility_tolerance_;
1273 double lu_factorization_pivot_threshold_;
1274 double max_time_in_seconds_;
1275 ::int64_t max_number_of_iterations_;
1276 double markowitz_singularity_threshold_;
1277 ::int32_t markowitz_zlatev_parameter_;
1278 ::int32_t num_omp_threads_;
1279 double preprocessor_zero_tolerance_;
1280 bool allow_simplex_algorithm_change_;
1281 bool perturb_costs_in_dual_simplex_;
1282 bool log_search_progress_;
1283 bool dual_price_prioritize_norm_;
1284 bool use_absl_random_;
1285 ::int32_t devex_weights_reset_period_;
1286 bool use_preprocessing_;
1287 bool use_middle_product_form_update_;
1288 bool initialize_devex_with_column_norms_;
1289 bool exploit_singleton_column_in_initial_basis_;
1290 double dual_small_pivot_threshold_;
1291 double objective_lower_limit_;
1292 double objective_upper_limit_;
1293 double degenerate_ministep_factor_;
1294 double max_deterministic_time_;
1295 ::int32_t random_seed_;
1296 int scaling_method_;
1297 double drop_tolerance_;
1298 double relative_cost_perturbation_;
1299 double relative_max_cost_perturbation_;
1300 double max_number_of_reoptimizations_;
1301 double initial_condition_number_threshold_;
1302 int cost_scaling_;
1303 bool change_status_to_imprecise_;
1304 bool use_dedicated_dual_feasibility_algorithm_;
1305 bool dynamically_adjust_refactorization_period_;
1306 bool push_to_vertex_;
1307 double crossover_bound_snapping_distance_;
1308 double max_valid_magnitude_;
1309 double drop_magnitude_;
1310 bool log_to_stdout_;
1311 bool use_implied_free_preprocessor_;
1312 PROTOBUF_TSAN_DECLARE_MEMBER
1313 };
1314 union { Impl_ _impl_; };
1315 friend struct ::TableStruct_ortools_2fglop_2fparameters_2eproto;
1316};
1317
1318OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull GlopParameters_class_data_;
1319
1320// ===================================================================
1321
1322
1323
1324
1325// ===================================================================
1326
1327
1328#ifdef __GNUC__
1329#pragma GCC diagnostic push
1330#pragma GCC diagnostic ignored "-Wstrict-aliasing"
1331#endif // __GNUC__
1332// -------------------------------------------------------------------
1333
1334// GlopParameters
1335
1336// optional .operations_research.glop.GlopParameters.ScalingAlgorithm scaling_method = 57 [default = EQUILIBRATION];
1337inline bool GlopParameters::has_scaling_method() const {
1338 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000800U);
1339 return value;
1340}
1341inline void GlopParameters::clear_scaling_method() {
1342 ::google::protobuf::internal::TSanWrite(&_impl_);
1343 _impl_.scaling_method_ = 1;
1344 ClearHasBit(_impl_._has_bits_[1],
1345 0x00000800U);
1346}
1347inline ::operations_research::glop::GlopParameters_ScalingAlgorithm GlopParameters::scaling_method() const {
1348 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.scaling_method)
1349 return _internal_scaling_method();
1350}
1351inline void GlopParameters::set_scaling_method(::operations_research::glop::GlopParameters_ScalingAlgorithm value) {
1352 _internal_set_scaling_method(value);
1353 SetHasBit(_impl_._has_bits_[1], 0x00000800U);
1354 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.scaling_method)
1355}
1356inline ::operations_research::glop::GlopParameters_ScalingAlgorithm GlopParameters::_internal_scaling_method() const {
1357 ::google::protobuf::internal::TSanRead(&_impl_);
1358 return static_cast<::operations_research::glop::GlopParameters_ScalingAlgorithm>(_impl_.scaling_method_);
1359}
1360inline void GlopParameters::_internal_set_scaling_method(::operations_research::glop::GlopParameters_ScalingAlgorithm value) {
1361 ::google::protobuf::internal::TSanWrite(&_impl_);
1362
1363 assert(::google::protobuf::internal::ValidateEnum(
1364 value, ::operations_research::glop::GlopParameters_ScalingAlgorithm_internal_data_));
1365 _impl_.scaling_method_ = value;
1366}
1367
1368// optional .operations_research.glop.GlopParameters.PricingRule feasibility_rule = 1 [default = STEEPEST_EDGE];
1369inline bool GlopParameters::has_feasibility_rule() const {
1370 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
1371 return value;
1372}
1373inline void GlopParameters::clear_feasibility_rule() {
1374 ::google::protobuf::internal::TSanWrite(&_impl_);
1375 _impl_.feasibility_rule_ = 1;
1376 ClearHasBit(_impl_._has_bits_[0],
1377 0x00000002U);
1378}
1379inline ::operations_research::glop::GlopParameters_PricingRule GlopParameters::feasibility_rule() const {
1380 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.feasibility_rule)
1381 return _internal_feasibility_rule();
1382}
1383inline void GlopParameters::set_feasibility_rule(::operations_research::glop::GlopParameters_PricingRule value) {
1384 _internal_set_feasibility_rule(value);
1385 SetHasBit(_impl_._has_bits_[0], 0x00000002U);
1386 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.feasibility_rule)
1387}
1388inline ::operations_research::glop::GlopParameters_PricingRule GlopParameters::_internal_feasibility_rule() const {
1389 ::google::protobuf::internal::TSanRead(&_impl_);
1390 return static_cast<::operations_research::glop::GlopParameters_PricingRule>(_impl_.feasibility_rule_);
1391}
1392inline void GlopParameters::_internal_set_feasibility_rule(::operations_research::glop::GlopParameters_PricingRule value) {
1393 ::google::protobuf::internal::TSanWrite(&_impl_);
1394
1395 assert(::google::protobuf::internal::ValidateEnum(
1396 value, ::operations_research::glop::GlopParameters_PricingRule_internal_data_));
1397 _impl_.feasibility_rule_ = value;
1398}
1399
1400// optional .operations_research.glop.GlopParameters.PricingRule optimization_rule = 2 [default = STEEPEST_EDGE];
1401inline bool GlopParameters::has_optimization_rule() const {
1402 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
1403 return value;
1404}
1405inline void GlopParameters::clear_optimization_rule() {
1406 ::google::protobuf::internal::TSanWrite(&_impl_);
1407 _impl_.optimization_rule_ = 1;
1408 ClearHasBit(_impl_._has_bits_[0],
1409 0x00000004U);
1410}
1411inline ::operations_research::glop::GlopParameters_PricingRule GlopParameters::optimization_rule() const {
1412 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.optimization_rule)
1413 return _internal_optimization_rule();
1414}
1415inline void GlopParameters::set_optimization_rule(::operations_research::glop::GlopParameters_PricingRule value) {
1416 _internal_set_optimization_rule(value);
1417 SetHasBit(_impl_._has_bits_[0], 0x00000004U);
1418 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.optimization_rule)
1419}
1420inline ::operations_research::glop::GlopParameters_PricingRule GlopParameters::_internal_optimization_rule() const {
1421 ::google::protobuf::internal::TSanRead(&_impl_);
1422 return static_cast<::operations_research::glop::GlopParameters_PricingRule>(_impl_.optimization_rule_);
1423}
1424inline void GlopParameters::_internal_set_optimization_rule(::operations_research::glop::GlopParameters_PricingRule value) {
1425 ::google::protobuf::internal::TSanWrite(&_impl_);
1426
1427 assert(::google::protobuf::internal::ValidateEnum(
1428 value, ::operations_research::glop::GlopParameters_PricingRule_internal_data_));
1429 _impl_.optimization_rule_ = value;
1430}
1431
1432// optional double refactorization_threshold = 6 [default = 1e-09];
1433inline bool GlopParameters::has_refactorization_threshold() const {
1434 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
1435 return value;
1436}
1437inline void GlopParameters::clear_refactorization_threshold() {
1438 ::google::protobuf::internal::TSanWrite(&_impl_);
1439 _impl_.refactorization_threshold_ = 1e-09;
1440 ClearHasBit(_impl_._has_bits_[0],
1441 0x00000008U);
1442}
1443inline double GlopParameters::refactorization_threshold() const {
1444 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.refactorization_threshold)
1445 return _internal_refactorization_threshold();
1446}
1447inline void GlopParameters::set_refactorization_threshold(double value) {
1448 _internal_set_refactorization_threshold(value);
1449 SetHasBit(_impl_._has_bits_[0], 0x00000008U);
1450 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.refactorization_threshold)
1451}
1452inline double GlopParameters::_internal_refactorization_threshold() const {
1453 ::google::protobuf::internal::TSanRead(&_impl_);
1454 return _impl_.refactorization_threshold_;
1455}
1456inline void GlopParameters::_internal_set_refactorization_threshold(double value) {
1457 ::google::protobuf::internal::TSanWrite(&_impl_);
1458 _impl_.refactorization_threshold_ = value;
1459}
1460
1461// optional double recompute_reduced_costs_threshold = 8 [default = 1e-08];
1462inline bool GlopParameters::has_recompute_reduced_costs_threshold() const {
1463 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
1464 return value;
1465}
1466inline void GlopParameters::clear_recompute_reduced_costs_threshold() {
1467 ::google::protobuf::internal::TSanWrite(&_impl_);
1468 _impl_.recompute_reduced_costs_threshold_ = 1e-08;
1469 ClearHasBit(_impl_._has_bits_[0],
1470 0x00000010U);
1471}
1472inline double GlopParameters::recompute_reduced_costs_threshold() const {
1473 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.recompute_reduced_costs_threshold)
1474 return _internal_recompute_reduced_costs_threshold();
1475}
1476inline void GlopParameters::set_recompute_reduced_costs_threshold(double value) {
1477 _internal_set_recompute_reduced_costs_threshold(value);
1478 SetHasBit(_impl_._has_bits_[0], 0x00000010U);
1479 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.recompute_reduced_costs_threshold)
1480}
1481inline double GlopParameters::_internal_recompute_reduced_costs_threshold() const {
1482 ::google::protobuf::internal::TSanRead(&_impl_);
1483 return _impl_.recompute_reduced_costs_threshold_;
1484}
1485inline void GlopParameters::_internal_set_recompute_reduced_costs_threshold(double value) {
1486 ::google::protobuf::internal::TSanWrite(&_impl_);
1487 _impl_.recompute_reduced_costs_threshold_ = value;
1488}
1489
1490// optional double recompute_edges_norm_threshold = 9 [default = 100];
1491inline bool GlopParameters::has_recompute_edges_norm_threshold() const {
1492 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
1493 return value;
1494}
1495inline void GlopParameters::clear_recompute_edges_norm_threshold() {
1496 ::google::protobuf::internal::TSanWrite(&_impl_);
1497 _impl_.recompute_edges_norm_threshold_ = 100;
1498 ClearHasBit(_impl_._has_bits_[0],
1499 0x00000020U);
1500}
1501inline double GlopParameters::recompute_edges_norm_threshold() const {
1502 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.recompute_edges_norm_threshold)
1503 return _internal_recompute_edges_norm_threshold();
1504}
1505inline void GlopParameters::set_recompute_edges_norm_threshold(double value) {
1506 _internal_set_recompute_edges_norm_threshold(value);
1507 SetHasBit(_impl_._has_bits_[0], 0x00000020U);
1508 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.recompute_edges_norm_threshold)
1509}
1510inline double GlopParameters::_internal_recompute_edges_norm_threshold() const {
1511 ::google::protobuf::internal::TSanRead(&_impl_);
1512 return _impl_.recompute_edges_norm_threshold_;
1513}
1514inline void GlopParameters::_internal_set_recompute_edges_norm_threshold(double value) {
1515 ::google::protobuf::internal::TSanWrite(&_impl_);
1516 _impl_.recompute_edges_norm_threshold_ = value;
1517}
1518
1519// optional double primal_feasibility_tolerance = 10 [default = 1e-08];
1520inline bool GlopParameters::has_primal_feasibility_tolerance() const {
1521 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
1522 return value;
1523}
1524inline void GlopParameters::clear_primal_feasibility_tolerance() {
1525 ::google::protobuf::internal::TSanWrite(&_impl_);
1526 _impl_.primal_feasibility_tolerance_ = 1e-08;
1527 ClearHasBit(_impl_._has_bits_[0],
1528 0x00000040U);
1529}
1530inline double GlopParameters::primal_feasibility_tolerance() const {
1531 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.primal_feasibility_tolerance)
1532 return _internal_primal_feasibility_tolerance();
1533}
1534inline void GlopParameters::set_primal_feasibility_tolerance(double value) {
1535 _internal_set_primal_feasibility_tolerance(value);
1536 SetHasBit(_impl_._has_bits_[0], 0x00000040U);
1537 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.primal_feasibility_tolerance)
1538}
1539inline double GlopParameters::_internal_primal_feasibility_tolerance() const {
1540 ::google::protobuf::internal::TSanRead(&_impl_);
1541 return _impl_.primal_feasibility_tolerance_;
1542}
1543inline void GlopParameters::_internal_set_primal_feasibility_tolerance(double value) {
1544 ::google::protobuf::internal::TSanWrite(&_impl_);
1545 _impl_.primal_feasibility_tolerance_ = value;
1546}
1547
1548// optional double dual_feasibility_tolerance = 11 [default = 1e-08];
1549inline bool GlopParameters::has_dual_feasibility_tolerance() const {
1550 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
1551 return value;
1552}
1553inline void GlopParameters::clear_dual_feasibility_tolerance() {
1554 ::google::protobuf::internal::TSanWrite(&_impl_);
1555 _impl_.dual_feasibility_tolerance_ = 1e-08;
1556 ClearHasBit(_impl_._has_bits_[0],
1557 0x00000080U);
1558}
1559inline double GlopParameters::dual_feasibility_tolerance() const {
1560 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.dual_feasibility_tolerance)
1561 return _internal_dual_feasibility_tolerance();
1562}
1563inline void GlopParameters::set_dual_feasibility_tolerance(double value) {
1564 _internal_set_dual_feasibility_tolerance(value);
1565 SetHasBit(_impl_._has_bits_[0], 0x00000080U);
1566 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.dual_feasibility_tolerance)
1567}
1568inline double GlopParameters::_internal_dual_feasibility_tolerance() const {
1569 ::google::protobuf::internal::TSanRead(&_impl_);
1570 return _impl_.dual_feasibility_tolerance_;
1571}
1572inline void GlopParameters::_internal_set_dual_feasibility_tolerance(double value) {
1573 ::google::protobuf::internal::TSanWrite(&_impl_);
1574 _impl_.dual_feasibility_tolerance_ = value;
1575}
1576
1577// optional double ratio_test_zero_threshold = 12 [default = 1e-09];
1578inline bool GlopParameters::has_ratio_test_zero_threshold() const {
1579 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
1580 return value;
1581}
1582inline void GlopParameters::clear_ratio_test_zero_threshold() {
1583 ::google::protobuf::internal::TSanWrite(&_impl_);
1584 _impl_.ratio_test_zero_threshold_ = 1e-09;
1585 ClearHasBit(_impl_._has_bits_[0],
1586 0x00000100U);
1587}
1588inline double GlopParameters::ratio_test_zero_threshold() const {
1589 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.ratio_test_zero_threshold)
1590 return _internal_ratio_test_zero_threshold();
1591}
1592inline void GlopParameters::set_ratio_test_zero_threshold(double value) {
1593 _internal_set_ratio_test_zero_threshold(value);
1594 SetHasBit(_impl_._has_bits_[0], 0x00000100U);
1595 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.ratio_test_zero_threshold)
1596}
1597inline double GlopParameters::_internal_ratio_test_zero_threshold() const {
1598 ::google::protobuf::internal::TSanRead(&_impl_);
1599 return _impl_.ratio_test_zero_threshold_;
1600}
1601inline void GlopParameters::_internal_set_ratio_test_zero_threshold(double value) {
1602 ::google::protobuf::internal::TSanWrite(&_impl_);
1603 _impl_.ratio_test_zero_threshold_ = value;
1604}
1605
1606// optional double harris_tolerance_ratio = 13 [default = 0.5];
1607inline bool GlopParameters::has_harris_tolerance_ratio() const {
1608 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
1609 return value;
1610}
1611inline void GlopParameters::clear_harris_tolerance_ratio() {
1612 ::google::protobuf::internal::TSanWrite(&_impl_);
1613 _impl_.harris_tolerance_ratio_ = 0.5;
1614 ClearHasBit(_impl_._has_bits_[0],
1615 0x00000200U);
1616}
1617inline double GlopParameters::harris_tolerance_ratio() const {
1618 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.harris_tolerance_ratio)
1619 return _internal_harris_tolerance_ratio();
1620}
1621inline void GlopParameters::set_harris_tolerance_ratio(double value) {
1622 _internal_set_harris_tolerance_ratio(value);
1623 SetHasBit(_impl_._has_bits_[0], 0x00000200U);
1624 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.harris_tolerance_ratio)
1625}
1626inline double GlopParameters::_internal_harris_tolerance_ratio() const {
1627 ::google::protobuf::internal::TSanRead(&_impl_);
1628 return _impl_.harris_tolerance_ratio_;
1629}
1630inline void GlopParameters::_internal_set_harris_tolerance_ratio(double value) {
1631 ::google::protobuf::internal::TSanWrite(&_impl_);
1632 _impl_.harris_tolerance_ratio_ = value;
1633}
1634
1635// optional double small_pivot_threshold = 14 [default = 1e-06];
1636inline bool GlopParameters::has_small_pivot_threshold() const {
1637 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
1638 return value;
1639}
1640inline void GlopParameters::clear_small_pivot_threshold() {
1641 ::google::protobuf::internal::TSanWrite(&_impl_);
1642 _impl_.small_pivot_threshold_ = 1e-06;
1643 ClearHasBit(_impl_._has_bits_[0],
1644 0x00000400U);
1645}
1646inline double GlopParameters::small_pivot_threshold() const {
1647 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.small_pivot_threshold)
1648 return _internal_small_pivot_threshold();
1649}
1650inline void GlopParameters::set_small_pivot_threshold(double value) {
1651 _internal_set_small_pivot_threshold(value);
1652 SetHasBit(_impl_._has_bits_[0], 0x00000400U);
1653 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.small_pivot_threshold)
1654}
1655inline double GlopParameters::_internal_small_pivot_threshold() const {
1656 ::google::protobuf::internal::TSanRead(&_impl_);
1657 return _impl_.small_pivot_threshold_;
1658}
1659inline void GlopParameters::_internal_set_small_pivot_threshold(double value) {
1660 ::google::protobuf::internal::TSanWrite(&_impl_);
1661 _impl_.small_pivot_threshold_ = value;
1662}
1663
1664// optional double minimum_acceptable_pivot = 15 [default = 1e-06];
1665inline bool GlopParameters::has_minimum_acceptable_pivot() const {
1666 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
1667 return value;
1668}
1669inline void GlopParameters::clear_minimum_acceptable_pivot() {
1670 ::google::protobuf::internal::TSanWrite(&_impl_);
1671 _impl_.minimum_acceptable_pivot_ = 1e-06;
1672 ClearHasBit(_impl_._has_bits_[0],
1673 0x00000800U);
1674}
1675inline double GlopParameters::minimum_acceptable_pivot() const {
1676 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.minimum_acceptable_pivot)
1677 return _internal_minimum_acceptable_pivot();
1678}
1679inline void GlopParameters::set_minimum_acceptable_pivot(double value) {
1680 _internal_set_minimum_acceptable_pivot(value);
1681 SetHasBit(_impl_._has_bits_[0], 0x00000800U);
1682 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.minimum_acceptable_pivot)
1683}
1684inline double GlopParameters::_internal_minimum_acceptable_pivot() const {
1685 ::google::protobuf::internal::TSanRead(&_impl_);
1686 return _impl_.minimum_acceptable_pivot_;
1687}
1688inline void GlopParameters::_internal_set_minimum_acceptable_pivot(double value) {
1689 ::google::protobuf::internal::TSanWrite(&_impl_);
1690 _impl_.minimum_acceptable_pivot_ = value;
1691}
1692
1693// optional double drop_tolerance = 52 [default = 1e-14];
1694inline bool GlopParameters::has_drop_tolerance() const {
1695 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00001000U);
1696 return value;
1697}
1698inline void GlopParameters::clear_drop_tolerance() {
1699 ::google::protobuf::internal::TSanWrite(&_impl_);
1700 _impl_.drop_tolerance_ = 1e-14;
1701 ClearHasBit(_impl_._has_bits_[1],
1702 0x00001000U);
1703}
1704inline double GlopParameters::drop_tolerance() const {
1705 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.drop_tolerance)
1706 return _internal_drop_tolerance();
1707}
1708inline void GlopParameters::set_drop_tolerance(double value) {
1709 _internal_set_drop_tolerance(value);
1710 SetHasBit(_impl_._has_bits_[1], 0x00001000U);
1711 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.drop_tolerance)
1712}
1713inline double GlopParameters::_internal_drop_tolerance() const {
1714 ::google::protobuf::internal::TSanRead(&_impl_);
1715 return _impl_.drop_tolerance_;
1716}
1717inline void GlopParameters::_internal_set_drop_tolerance(double value) {
1718 ::google::protobuf::internal::TSanWrite(&_impl_);
1719 _impl_.drop_tolerance_ = value;
1720}
1721
1722// optional bool use_scaling = 16 [default = true];
1723inline bool GlopParameters::has_use_scaling() const {
1724 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00004000U);
1725 return value;
1726}
1727inline void GlopParameters::clear_use_scaling() {
1728 ::google::protobuf::internal::TSanWrite(&_impl_);
1729 _impl_.use_scaling_ = true;
1730 ClearHasBit(_impl_._has_bits_[0],
1731 0x00004000U);
1732}
1733inline bool GlopParameters::use_scaling() const {
1734 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.use_scaling)
1735 return _internal_use_scaling();
1736}
1737inline void GlopParameters::set_use_scaling(bool value) {
1738 _internal_set_use_scaling(value);
1739 SetHasBit(_impl_._has_bits_[0], 0x00004000U);
1740 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.use_scaling)
1741}
1742inline bool GlopParameters::_internal_use_scaling() const {
1743 ::google::protobuf::internal::TSanRead(&_impl_);
1744 return _impl_.use_scaling_;
1745}
1746inline void GlopParameters::_internal_set_use_scaling(bool value) {
1747 ::google::protobuf::internal::TSanWrite(&_impl_);
1748 _impl_.use_scaling_ = value;
1749}
1750
1751// optional .operations_research.glop.GlopParameters.CostScalingAlgorithm cost_scaling = 60 [default = CONTAIN_ONE_COST_SCALING];
1752inline bool GlopParameters::has_cost_scaling() const {
1753 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00020000U);
1754 return value;
1755}
1756inline void GlopParameters::clear_cost_scaling() {
1757 ::google::protobuf::internal::TSanWrite(&_impl_);
1758 _impl_.cost_scaling_ = 1;
1759 ClearHasBit(_impl_._has_bits_[1],
1760 0x00020000U);
1761}
1762inline ::operations_research::glop::GlopParameters_CostScalingAlgorithm GlopParameters::cost_scaling() const {
1763 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.cost_scaling)
1764 return _internal_cost_scaling();
1765}
1766inline void GlopParameters::set_cost_scaling(::operations_research::glop::GlopParameters_CostScalingAlgorithm value) {
1767 _internal_set_cost_scaling(value);
1768 SetHasBit(_impl_._has_bits_[1], 0x00020000U);
1769 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.cost_scaling)
1770}
1771inline ::operations_research::glop::GlopParameters_CostScalingAlgorithm GlopParameters::_internal_cost_scaling() const {
1772 ::google::protobuf::internal::TSanRead(&_impl_);
1773 return static_cast<::operations_research::glop::GlopParameters_CostScalingAlgorithm>(_impl_.cost_scaling_);
1774}
1775inline void GlopParameters::_internal_set_cost_scaling(::operations_research::glop::GlopParameters_CostScalingAlgorithm value) {
1776 ::google::protobuf::internal::TSanWrite(&_impl_);
1777
1778 assert(::google::protobuf::internal::ValidateEnum(
1779 value, ::operations_research::glop::GlopParameters_CostScalingAlgorithm_internal_data_));
1780 _impl_.cost_scaling_ = value;
1781}
1782
1783// optional .operations_research.glop.GlopParameters.InitialBasisHeuristic initial_basis = 17 [default = TRIANGULAR];
1784inline bool GlopParameters::has_initial_basis() const {
1785 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
1786 return value;
1787}
1788inline void GlopParameters::clear_initial_basis() {
1789 ::google::protobuf::internal::TSanWrite(&_impl_);
1790 _impl_.initial_basis_ = 2;
1791 ClearHasBit(_impl_._has_bits_[0],
1792 0x00001000U);
1793}
1794inline ::operations_research::glop::GlopParameters_InitialBasisHeuristic GlopParameters::initial_basis() const {
1795 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.initial_basis)
1796 return _internal_initial_basis();
1797}
1798inline void GlopParameters::set_initial_basis(::operations_research::glop::GlopParameters_InitialBasisHeuristic value) {
1799 _internal_set_initial_basis(value);
1800 SetHasBit(_impl_._has_bits_[0], 0x00001000U);
1801 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.initial_basis)
1802}
1803inline ::operations_research::glop::GlopParameters_InitialBasisHeuristic GlopParameters::_internal_initial_basis() const {
1804 ::google::protobuf::internal::TSanRead(&_impl_);
1805 return static_cast<::operations_research::glop::GlopParameters_InitialBasisHeuristic>(_impl_.initial_basis_);
1806}
1807inline void GlopParameters::_internal_set_initial_basis(::operations_research::glop::GlopParameters_InitialBasisHeuristic value) {
1808 ::google::protobuf::internal::TSanWrite(&_impl_);
1809
1810 assert(::google::protobuf::internal::ValidateEnum(
1811 value, ::operations_research::glop::GlopParameters_InitialBasisHeuristic_internal_data_));
1812 _impl_.initial_basis_ = value;
1813}
1814
1815// optional bool use_transposed_matrix = 18 [default = true];
1816inline bool GlopParameters::has_use_transposed_matrix() const {
1817 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00008000U);
1818 return value;
1819}
1820inline void GlopParameters::clear_use_transposed_matrix() {
1821 ::google::protobuf::internal::TSanWrite(&_impl_);
1822 _impl_.use_transposed_matrix_ = true;
1823 ClearHasBit(_impl_._has_bits_[0],
1824 0x00008000U);
1825}
1826inline bool GlopParameters::use_transposed_matrix() const {
1827 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.use_transposed_matrix)
1828 return _internal_use_transposed_matrix();
1829}
1830inline void GlopParameters::set_use_transposed_matrix(bool value) {
1831 _internal_set_use_transposed_matrix(value);
1832 SetHasBit(_impl_._has_bits_[0], 0x00008000U);
1833 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.use_transposed_matrix)
1834}
1835inline bool GlopParameters::_internal_use_transposed_matrix() const {
1836 ::google::protobuf::internal::TSanRead(&_impl_);
1837 return _impl_.use_transposed_matrix_;
1838}
1839inline void GlopParameters::_internal_set_use_transposed_matrix(bool value) {
1840 ::google::protobuf::internal::TSanWrite(&_impl_);
1841 _impl_.use_transposed_matrix_ = value;
1842}
1843
1844// optional int32 basis_refactorization_period = 19 [default = 64];
1845inline bool GlopParameters::has_basis_refactorization_period() const {
1846 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00002000U);
1847 return value;
1848}
1849inline void GlopParameters::clear_basis_refactorization_period() {
1850 ::google::protobuf::internal::TSanWrite(&_impl_);
1851 _impl_.basis_refactorization_period_ = 64;
1852 ClearHasBit(_impl_._has_bits_[0],
1853 0x00002000U);
1854}
1855inline ::int32_t GlopParameters::basis_refactorization_period() const {
1856 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.basis_refactorization_period)
1857 return _internal_basis_refactorization_period();
1858}
1859inline void GlopParameters::set_basis_refactorization_period(::int32_t value) {
1860 _internal_set_basis_refactorization_period(value);
1861 SetHasBit(_impl_._has_bits_[0], 0x00002000U);
1862 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.basis_refactorization_period)
1863}
1864inline ::int32_t GlopParameters::_internal_basis_refactorization_period() const {
1865 ::google::protobuf::internal::TSanRead(&_impl_);
1866 return _impl_.basis_refactorization_period_;
1867}
1868inline void GlopParameters::_internal_set_basis_refactorization_period(::int32_t value) {
1869 ::google::protobuf::internal::TSanWrite(&_impl_);
1870 _impl_.basis_refactorization_period_ = value;
1871}
1872
1873// optional bool dynamically_adjust_refactorization_period = 63 [default = true];
1874inline bool GlopParameters::has_dynamically_adjust_refactorization_period() const {
1875 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00100000U);
1876 return value;
1877}
1878inline void GlopParameters::clear_dynamically_adjust_refactorization_period() {
1879 ::google::protobuf::internal::TSanWrite(&_impl_);
1880 _impl_.dynamically_adjust_refactorization_period_ = true;
1881 ClearHasBit(_impl_._has_bits_[1],
1882 0x00100000U);
1883}
1884inline bool GlopParameters::dynamically_adjust_refactorization_period() const {
1885 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.dynamically_adjust_refactorization_period)
1886 return _internal_dynamically_adjust_refactorization_period();
1887}
1888inline void GlopParameters::set_dynamically_adjust_refactorization_period(bool value) {
1889 _internal_set_dynamically_adjust_refactorization_period(value);
1890 SetHasBit(_impl_._has_bits_[1], 0x00100000U);
1891 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.dynamically_adjust_refactorization_period)
1892}
1893inline bool GlopParameters::_internal_dynamically_adjust_refactorization_period() const {
1894 ::google::protobuf::internal::TSanRead(&_impl_);
1895 return _impl_.dynamically_adjust_refactorization_period_;
1896}
1897inline void GlopParameters::_internal_set_dynamically_adjust_refactorization_period(bool value) {
1898 ::google::protobuf::internal::TSanWrite(&_impl_);
1899 _impl_.dynamically_adjust_refactorization_period_ = value;
1900}
1901
1902// optional .operations_research.glop.GlopParameters.SolverBehavior solve_dual_problem = 20 [default = LET_SOLVER_DECIDE];
1903inline bool GlopParameters::has_solve_dual_problem() const {
1904 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00020000U);
1905 return value;
1906}
1907inline void GlopParameters::clear_solve_dual_problem() {
1908 ::google::protobuf::internal::TSanWrite(&_impl_);
1909 _impl_.solve_dual_problem_ = 2;
1910 ClearHasBit(_impl_._has_bits_[0],
1911 0x00020000U);
1912}
1913inline ::operations_research::glop::GlopParameters_SolverBehavior GlopParameters::solve_dual_problem() const {
1914 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.solve_dual_problem)
1915 return _internal_solve_dual_problem();
1916}
1917inline void GlopParameters::set_solve_dual_problem(::operations_research::glop::GlopParameters_SolverBehavior value) {
1918 _internal_set_solve_dual_problem(value);
1919 SetHasBit(_impl_._has_bits_[0], 0x00020000U);
1920 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.solve_dual_problem)
1921}
1922inline ::operations_research::glop::GlopParameters_SolverBehavior GlopParameters::_internal_solve_dual_problem() const {
1923 ::google::protobuf::internal::TSanRead(&_impl_);
1924 return static_cast<::operations_research::glop::GlopParameters_SolverBehavior>(_impl_.solve_dual_problem_);
1925}
1926inline void GlopParameters::_internal_set_solve_dual_problem(::operations_research::glop::GlopParameters_SolverBehavior value) {
1927 ::google::protobuf::internal::TSanWrite(&_impl_);
1928
1929 assert(::google::protobuf::internal::ValidateEnum(
1930 value, ::operations_research::glop::GlopParameters_SolverBehavior_internal_data_));
1931 _impl_.solve_dual_problem_ = value;
1932}
1933
1934// optional double dualizer_threshold = 21 [default = 1.5];
1935inline bool GlopParameters::has_dualizer_threshold() const {
1936 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00040000U);
1937 return value;
1938}
1939inline void GlopParameters::clear_dualizer_threshold() {
1940 ::google::protobuf::internal::TSanWrite(&_impl_);
1941 _impl_.dualizer_threshold_ = 1.5;
1942 ClearHasBit(_impl_._has_bits_[0],
1943 0x00040000U);
1944}
1945inline double GlopParameters::dualizer_threshold() const {
1946 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.dualizer_threshold)
1947 return _internal_dualizer_threshold();
1948}
1949inline void GlopParameters::set_dualizer_threshold(double value) {
1950 _internal_set_dualizer_threshold(value);
1951 SetHasBit(_impl_._has_bits_[0], 0x00040000U);
1952 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.dualizer_threshold)
1953}
1954inline double GlopParameters::_internal_dualizer_threshold() const {
1955 ::google::protobuf::internal::TSanRead(&_impl_);
1956 return _impl_.dualizer_threshold_;
1957}
1958inline void GlopParameters::_internal_set_dualizer_threshold(double value) {
1959 ::google::protobuf::internal::TSanWrite(&_impl_);
1960 _impl_.dualizer_threshold_ = value;
1961}
1962
1963// optional double solution_feasibility_tolerance = 22 [default = 1e-06];
1964inline bool GlopParameters::has_solution_feasibility_tolerance() const {
1965 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00080000U);
1966 return value;
1967}
1968inline void GlopParameters::clear_solution_feasibility_tolerance() {
1969 ::google::protobuf::internal::TSanWrite(&_impl_);
1970 _impl_.solution_feasibility_tolerance_ = 1e-06;
1971 ClearHasBit(_impl_._has_bits_[0],
1972 0x00080000U);
1973}
1974inline double GlopParameters::solution_feasibility_tolerance() const {
1975 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.solution_feasibility_tolerance)
1976 return _internal_solution_feasibility_tolerance();
1977}
1978inline void GlopParameters::set_solution_feasibility_tolerance(double value) {
1979 _internal_set_solution_feasibility_tolerance(value);
1980 SetHasBit(_impl_._has_bits_[0], 0x00080000U);
1981 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.solution_feasibility_tolerance)
1982}
1983inline double GlopParameters::_internal_solution_feasibility_tolerance() const {
1984 ::google::protobuf::internal::TSanRead(&_impl_);
1985 return _impl_.solution_feasibility_tolerance_;
1986}
1987inline void GlopParameters::_internal_set_solution_feasibility_tolerance(double value) {
1988 ::google::protobuf::internal::TSanWrite(&_impl_);
1989 _impl_.solution_feasibility_tolerance_ = value;
1990}
1991
1992// optional bool provide_strong_optimal_guarantee = 24 [default = true];
1993inline bool GlopParameters::has_provide_strong_optimal_guarantee() const {
1994 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00010000U);
1995 return value;
1996}
1997inline void GlopParameters::clear_provide_strong_optimal_guarantee() {
1998 ::google::protobuf::internal::TSanWrite(&_impl_);
1999 _impl_.provide_strong_optimal_guarantee_ = true;
2000 ClearHasBit(_impl_._has_bits_[0],
2001 0x00010000U);
2002}
2003inline bool GlopParameters::provide_strong_optimal_guarantee() const {
2004 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.provide_strong_optimal_guarantee)
2005 return _internal_provide_strong_optimal_guarantee();
2006}
2007inline void GlopParameters::set_provide_strong_optimal_guarantee(bool value) {
2008 _internal_set_provide_strong_optimal_guarantee(value);
2009 SetHasBit(_impl_._has_bits_[0], 0x00010000U);
2010 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.provide_strong_optimal_guarantee)
2011}
2012inline bool GlopParameters::_internal_provide_strong_optimal_guarantee() const {
2013 ::google::protobuf::internal::TSanRead(&_impl_);
2014 return _impl_.provide_strong_optimal_guarantee_;
2015}
2016inline void GlopParameters::_internal_set_provide_strong_optimal_guarantee(bool value) {
2017 ::google::protobuf::internal::TSanWrite(&_impl_);
2018 _impl_.provide_strong_optimal_guarantee_ = value;
2019}
2020
2021// optional bool change_status_to_imprecise = 58 [default = true];
2022inline bool GlopParameters::has_change_status_to_imprecise() const {
2023 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00040000U);
2024 return value;
2025}
2026inline void GlopParameters::clear_change_status_to_imprecise() {
2027 ::google::protobuf::internal::TSanWrite(&_impl_);
2028 _impl_.change_status_to_imprecise_ = true;
2029 ClearHasBit(_impl_._has_bits_[1],
2030 0x00040000U);
2031}
2032inline bool GlopParameters::change_status_to_imprecise() const {
2033 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.change_status_to_imprecise)
2034 return _internal_change_status_to_imprecise();
2035}
2036inline void GlopParameters::set_change_status_to_imprecise(bool value) {
2037 _internal_set_change_status_to_imprecise(value);
2038 SetHasBit(_impl_._has_bits_[1], 0x00040000U);
2039 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.change_status_to_imprecise)
2040}
2041inline bool GlopParameters::_internal_change_status_to_imprecise() const {
2042 ::google::protobuf::internal::TSanRead(&_impl_);
2043 return _impl_.change_status_to_imprecise_;
2044}
2045inline void GlopParameters::_internal_set_change_status_to_imprecise(bool value) {
2046 ::google::protobuf::internal::TSanWrite(&_impl_);
2047 _impl_.change_status_to_imprecise_ = value;
2048}
2049
2050// optional double max_number_of_reoptimizations = 56 [default = 40];
2051inline bool GlopParameters::has_max_number_of_reoptimizations() const {
2052 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00008000U);
2053 return value;
2054}
2055inline void GlopParameters::clear_max_number_of_reoptimizations() {
2056 ::google::protobuf::internal::TSanWrite(&_impl_);
2057 _impl_.max_number_of_reoptimizations_ = 40;
2058 ClearHasBit(_impl_._has_bits_[1],
2059 0x00008000U);
2060}
2061inline double GlopParameters::max_number_of_reoptimizations() const {
2062 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.max_number_of_reoptimizations)
2063 return _internal_max_number_of_reoptimizations();
2064}
2065inline void GlopParameters::set_max_number_of_reoptimizations(double value) {
2066 _internal_set_max_number_of_reoptimizations(value);
2067 SetHasBit(_impl_._has_bits_[1], 0x00008000U);
2068 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.max_number_of_reoptimizations)
2069}
2070inline double GlopParameters::_internal_max_number_of_reoptimizations() const {
2071 ::google::protobuf::internal::TSanRead(&_impl_);
2072 return _impl_.max_number_of_reoptimizations_;
2073}
2074inline void GlopParameters::_internal_set_max_number_of_reoptimizations(double value) {
2075 ::google::protobuf::internal::TSanWrite(&_impl_);
2076 _impl_.max_number_of_reoptimizations_ = value;
2077}
2078
2079// optional double lu_factorization_pivot_threshold = 25 [default = 0.01];
2080inline bool GlopParameters::has_lu_factorization_pivot_threshold() const {
2081 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00100000U);
2082 return value;
2083}
2084inline void GlopParameters::clear_lu_factorization_pivot_threshold() {
2085 ::google::protobuf::internal::TSanWrite(&_impl_);
2086 _impl_.lu_factorization_pivot_threshold_ = 0.01;
2087 ClearHasBit(_impl_._has_bits_[0],
2088 0x00100000U);
2089}
2090inline double GlopParameters::lu_factorization_pivot_threshold() const {
2091 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.lu_factorization_pivot_threshold)
2092 return _internal_lu_factorization_pivot_threshold();
2093}
2094inline void GlopParameters::set_lu_factorization_pivot_threshold(double value) {
2095 _internal_set_lu_factorization_pivot_threshold(value);
2096 SetHasBit(_impl_._has_bits_[0], 0x00100000U);
2097 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.lu_factorization_pivot_threshold)
2098}
2099inline double GlopParameters::_internal_lu_factorization_pivot_threshold() const {
2100 ::google::protobuf::internal::TSanRead(&_impl_);
2101 return _impl_.lu_factorization_pivot_threshold_;
2102}
2103inline void GlopParameters::_internal_set_lu_factorization_pivot_threshold(double value) {
2104 ::google::protobuf::internal::TSanWrite(&_impl_);
2105 _impl_.lu_factorization_pivot_threshold_ = value;
2106}
2107
2108// optional double max_time_in_seconds = 26 [default = inf];
2109inline bool GlopParameters::has_max_time_in_seconds() const {
2110 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00200000U);
2111 return value;
2112}
2113inline void GlopParameters::clear_max_time_in_seconds() {
2114 ::google::protobuf::internal::TSanWrite(&_impl_);
2115 _impl_.max_time_in_seconds_ = std::numeric_limits<double>::infinity();
2116 ClearHasBit(_impl_._has_bits_[0],
2117 0x00200000U);
2118}
2119inline double GlopParameters::max_time_in_seconds() const {
2120 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.max_time_in_seconds)
2121 return _internal_max_time_in_seconds();
2122}
2123inline void GlopParameters::set_max_time_in_seconds(double value) {
2124 _internal_set_max_time_in_seconds(value);
2125 SetHasBit(_impl_._has_bits_[0], 0x00200000U);
2126 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.max_time_in_seconds)
2127}
2128inline double GlopParameters::_internal_max_time_in_seconds() const {
2129 ::google::protobuf::internal::TSanRead(&_impl_);
2130 return _impl_.max_time_in_seconds_;
2131}
2132inline void GlopParameters::_internal_set_max_time_in_seconds(double value) {
2133 ::google::protobuf::internal::TSanWrite(&_impl_);
2134 _impl_.max_time_in_seconds_ = value;
2135}
2136
2137// optional double max_deterministic_time = 45 [default = inf];
2138inline bool GlopParameters::has_max_deterministic_time() const {
2139 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000200U);
2140 return value;
2141}
2142inline void GlopParameters::clear_max_deterministic_time() {
2143 ::google::protobuf::internal::TSanWrite(&_impl_);
2144 _impl_.max_deterministic_time_ = std::numeric_limits<double>::infinity();
2145 ClearHasBit(_impl_._has_bits_[1],
2146 0x00000200U);
2147}
2148inline double GlopParameters::max_deterministic_time() const {
2149 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.max_deterministic_time)
2150 return _internal_max_deterministic_time();
2151}
2152inline void GlopParameters::set_max_deterministic_time(double value) {
2153 _internal_set_max_deterministic_time(value);
2154 SetHasBit(_impl_._has_bits_[1], 0x00000200U);
2155 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.max_deterministic_time)
2156}
2157inline double GlopParameters::_internal_max_deterministic_time() const {
2158 ::google::protobuf::internal::TSanRead(&_impl_);
2159 return _impl_.max_deterministic_time_;
2160}
2161inline void GlopParameters::_internal_set_max_deterministic_time(double value) {
2162 ::google::protobuf::internal::TSanWrite(&_impl_);
2163 _impl_.max_deterministic_time_ = value;
2164}
2165
2166// optional int64 max_number_of_iterations = 27 [default = -1];
2167inline bool GlopParameters::has_max_number_of_iterations() const {
2168 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00400000U);
2169 return value;
2170}
2171inline void GlopParameters::clear_max_number_of_iterations() {
2172 ::google::protobuf::internal::TSanWrite(&_impl_);
2173 _impl_.max_number_of_iterations_ = ::int64_t{-1};
2174 ClearHasBit(_impl_._has_bits_[0],
2175 0x00400000U);
2176}
2177inline ::int64_t GlopParameters::max_number_of_iterations() const {
2178 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.max_number_of_iterations)
2179 return _internal_max_number_of_iterations();
2180}
2181inline void GlopParameters::set_max_number_of_iterations(::int64_t value) {
2182 _internal_set_max_number_of_iterations(value);
2183 SetHasBit(_impl_._has_bits_[0], 0x00400000U);
2184 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.max_number_of_iterations)
2185}
2186inline ::int64_t GlopParameters::_internal_max_number_of_iterations() const {
2187 ::google::protobuf::internal::TSanRead(&_impl_);
2188 return _impl_.max_number_of_iterations_;
2189}
2190inline void GlopParameters::_internal_set_max_number_of_iterations(::int64_t value) {
2191 ::google::protobuf::internal::TSanWrite(&_impl_);
2192 _impl_.max_number_of_iterations_ = value;
2193}
2194
2195// optional int32 markowitz_zlatev_parameter = 29 [default = 3];
2196inline bool GlopParameters::has_markowitz_zlatev_parameter() const {
2197 bool value = CheckHasBit(_impl_._has_bits_[0], 0x01000000U);
2198 return value;
2199}
2200inline void GlopParameters::clear_markowitz_zlatev_parameter() {
2201 ::google::protobuf::internal::TSanWrite(&_impl_);
2202 _impl_.markowitz_zlatev_parameter_ = 3;
2203 ClearHasBit(_impl_._has_bits_[0],
2204 0x01000000U);
2205}
2206inline ::int32_t GlopParameters::markowitz_zlatev_parameter() const {
2207 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.markowitz_zlatev_parameter)
2208 return _internal_markowitz_zlatev_parameter();
2209}
2210inline void GlopParameters::set_markowitz_zlatev_parameter(::int32_t value) {
2211 _internal_set_markowitz_zlatev_parameter(value);
2212 SetHasBit(_impl_._has_bits_[0], 0x01000000U);
2213 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.markowitz_zlatev_parameter)
2214}
2215inline ::int32_t GlopParameters::_internal_markowitz_zlatev_parameter() const {
2216 ::google::protobuf::internal::TSanRead(&_impl_);
2217 return _impl_.markowitz_zlatev_parameter_;
2218}
2219inline void GlopParameters::_internal_set_markowitz_zlatev_parameter(::int32_t value) {
2220 ::google::protobuf::internal::TSanWrite(&_impl_);
2221 _impl_.markowitz_zlatev_parameter_ = value;
2222}
2223
2224// optional double markowitz_singularity_threshold = 30 [default = 1e-15];
2225inline bool GlopParameters::has_markowitz_singularity_threshold() const {
2226 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00800000U);
2227 return value;
2228}
2229inline void GlopParameters::clear_markowitz_singularity_threshold() {
2230 ::google::protobuf::internal::TSanWrite(&_impl_);
2231 _impl_.markowitz_singularity_threshold_ = 1e-15;
2232 ClearHasBit(_impl_._has_bits_[0],
2233 0x00800000U);
2234}
2235inline double GlopParameters::markowitz_singularity_threshold() const {
2236 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.markowitz_singularity_threshold)
2237 return _internal_markowitz_singularity_threshold();
2238}
2239inline void GlopParameters::set_markowitz_singularity_threshold(double value) {
2240 _internal_set_markowitz_singularity_threshold(value);
2241 SetHasBit(_impl_._has_bits_[0], 0x00800000U);
2242 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.markowitz_singularity_threshold)
2243}
2244inline double GlopParameters::_internal_markowitz_singularity_threshold() const {
2245 ::google::protobuf::internal::TSanRead(&_impl_);
2246 return _impl_.markowitz_singularity_threshold_;
2247}
2248inline void GlopParameters::_internal_set_markowitz_singularity_threshold(double value) {
2249 ::google::protobuf::internal::TSanWrite(&_impl_);
2250 _impl_.markowitz_singularity_threshold_ = value;
2251}
2252
2253// optional bool use_dual_simplex = 31 [default = false];
2254inline bool GlopParameters::has_use_dual_simplex() const {
2255 bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
2256 return value;
2257}
2258inline void GlopParameters::clear_use_dual_simplex() {
2259 ::google::protobuf::internal::TSanWrite(&_impl_);
2260 _impl_.use_dual_simplex_ = false;
2261 ClearHasBit(_impl_._has_bits_[0],
2262 0x00000001U);
2263}
2264inline bool GlopParameters::use_dual_simplex() const {
2265 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.use_dual_simplex)
2266 return _internal_use_dual_simplex();
2267}
2268inline void GlopParameters::set_use_dual_simplex(bool value) {
2269 _internal_set_use_dual_simplex(value);
2270 SetHasBit(_impl_._has_bits_[0], 0x00000001U);
2271 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.use_dual_simplex)
2272}
2273inline bool GlopParameters::_internal_use_dual_simplex() const {
2274 ::google::protobuf::internal::TSanRead(&_impl_);
2275 return _impl_.use_dual_simplex_;
2276}
2277inline void GlopParameters::_internal_set_use_dual_simplex(bool value) {
2278 ::google::protobuf::internal::TSanWrite(&_impl_);
2279 _impl_.use_dual_simplex_ = value;
2280}
2281
2282// optional bool allow_simplex_algorithm_change = 32 [default = false];
2283inline bool GlopParameters::has_allow_simplex_algorithm_change() const {
2284 bool value = CheckHasBit(_impl_._has_bits_[0], 0x08000000U);
2285 return value;
2286}
2287inline void GlopParameters::clear_allow_simplex_algorithm_change() {
2288 ::google::protobuf::internal::TSanWrite(&_impl_);
2289 _impl_.allow_simplex_algorithm_change_ = false;
2290 ClearHasBit(_impl_._has_bits_[0],
2291 0x08000000U);
2292}
2293inline bool GlopParameters::allow_simplex_algorithm_change() const {
2294 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.allow_simplex_algorithm_change)
2295 return _internal_allow_simplex_algorithm_change();
2296}
2297inline void GlopParameters::set_allow_simplex_algorithm_change(bool value) {
2298 _internal_set_allow_simplex_algorithm_change(value);
2299 SetHasBit(_impl_._has_bits_[0], 0x08000000U);
2300 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.allow_simplex_algorithm_change)
2301}
2302inline bool GlopParameters::_internal_allow_simplex_algorithm_change() const {
2303 ::google::protobuf::internal::TSanRead(&_impl_);
2304 return _impl_.allow_simplex_algorithm_change_;
2305}
2306inline void GlopParameters::_internal_set_allow_simplex_algorithm_change(bool value) {
2307 ::google::protobuf::internal::TSanWrite(&_impl_);
2308 _impl_.allow_simplex_algorithm_change_ = value;
2309}
2310
2311// optional int32 devex_weights_reset_period = 33 [default = 150];
2312inline bool GlopParameters::has_devex_weights_reset_period() const {
2313 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000001U);
2314 return value;
2315}
2316inline void GlopParameters::clear_devex_weights_reset_period() {
2317 ::google::protobuf::internal::TSanWrite(&_impl_);
2318 _impl_.devex_weights_reset_period_ = 150;
2319 ClearHasBit(_impl_._has_bits_[1],
2320 0x00000001U);
2321}
2322inline ::int32_t GlopParameters::devex_weights_reset_period() const {
2323 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.devex_weights_reset_period)
2324 return _internal_devex_weights_reset_period();
2325}
2326inline void GlopParameters::set_devex_weights_reset_period(::int32_t value) {
2327 _internal_set_devex_weights_reset_period(value);
2328 SetHasBit(_impl_._has_bits_[1], 0x00000001U);
2329 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.devex_weights_reset_period)
2330}
2331inline ::int32_t GlopParameters::_internal_devex_weights_reset_period() const {
2332 ::google::protobuf::internal::TSanRead(&_impl_);
2333 return _impl_.devex_weights_reset_period_;
2334}
2335inline void GlopParameters::_internal_set_devex_weights_reset_period(::int32_t value) {
2336 ::google::protobuf::internal::TSanWrite(&_impl_);
2337 _impl_.devex_weights_reset_period_ = value;
2338}
2339
2340// optional bool use_preprocessing = 34 [default = true];
2341inline bool GlopParameters::has_use_preprocessing() const {
2342 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000002U);
2343 return value;
2344}
2345inline void GlopParameters::clear_use_preprocessing() {
2346 ::google::protobuf::internal::TSanWrite(&_impl_);
2347 _impl_.use_preprocessing_ = true;
2348 ClearHasBit(_impl_._has_bits_[1],
2349 0x00000002U);
2350}
2351inline bool GlopParameters::use_preprocessing() const {
2352 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.use_preprocessing)
2353 return _internal_use_preprocessing();
2354}
2355inline void GlopParameters::set_use_preprocessing(bool value) {
2356 _internal_set_use_preprocessing(value);
2357 SetHasBit(_impl_._has_bits_[1], 0x00000002U);
2358 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.use_preprocessing)
2359}
2360inline bool GlopParameters::_internal_use_preprocessing() const {
2361 ::google::protobuf::internal::TSanRead(&_impl_);
2362 return _impl_.use_preprocessing_;
2363}
2364inline void GlopParameters::_internal_set_use_preprocessing(bool value) {
2365 ::google::protobuf::internal::TSanWrite(&_impl_);
2366 _impl_.use_preprocessing_ = value;
2367}
2368
2369// optional bool use_middle_product_form_update = 35 [default = true];
2370inline bool GlopParameters::has_use_middle_product_form_update() const {
2371 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000004U);
2372 return value;
2373}
2374inline void GlopParameters::clear_use_middle_product_form_update() {
2375 ::google::protobuf::internal::TSanWrite(&_impl_);
2376 _impl_.use_middle_product_form_update_ = true;
2377 ClearHasBit(_impl_._has_bits_[1],
2378 0x00000004U);
2379}
2380inline bool GlopParameters::use_middle_product_form_update() const {
2381 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.use_middle_product_form_update)
2382 return _internal_use_middle_product_form_update();
2383}
2384inline void GlopParameters::set_use_middle_product_form_update(bool value) {
2385 _internal_set_use_middle_product_form_update(value);
2386 SetHasBit(_impl_._has_bits_[1], 0x00000004U);
2387 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.use_middle_product_form_update)
2388}
2389inline bool GlopParameters::_internal_use_middle_product_form_update() const {
2390 ::google::protobuf::internal::TSanRead(&_impl_);
2391 return _impl_.use_middle_product_form_update_;
2392}
2393inline void GlopParameters::_internal_set_use_middle_product_form_update(bool value) {
2394 ::google::protobuf::internal::TSanWrite(&_impl_);
2395 _impl_.use_middle_product_form_update_ = value;
2396}
2397
2398// optional bool initialize_devex_with_column_norms = 36 [default = true];
2399inline bool GlopParameters::has_initialize_devex_with_column_norms() const {
2400 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000008U);
2401 return value;
2402}
2403inline void GlopParameters::clear_initialize_devex_with_column_norms() {
2404 ::google::protobuf::internal::TSanWrite(&_impl_);
2405 _impl_.initialize_devex_with_column_norms_ = true;
2406 ClearHasBit(_impl_._has_bits_[1],
2407 0x00000008U);
2408}
2409inline bool GlopParameters::initialize_devex_with_column_norms() const {
2410 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.initialize_devex_with_column_norms)
2411 return _internal_initialize_devex_with_column_norms();
2412}
2413inline void GlopParameters::set_initialize_devex_with_column_norms(bool value) {
2414 _internal_set_initialize_devex_with_column_norms(value);
2415 SetHasBit(_impl_._has_bits_[1], 0x00000008U);
2416 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.initialize_devex_with_column_norms)
2417}
2418inline bool GlopParameters::_internal_initialize_devex_with_column_norms() const {
2419 ::google::protobuf::internal::TSanRead(&_impl_);
2420 return _impl_.initialize_devex_with_column_norms_;
2421}
2422inline void GlopParameters::_internal_set_initialize_devex_with_column_norms(bool value) {
2423 ::google::protobuf::internal::TSanWrite(&_impl_);
2424 _impl_.initialize_devex_with_column_norms_ = value;
2425}
2426
2427// optional bool exploit_singleton_column_in_initial_basis = 37 [default = true];
2428inline bool GlopParameters::has_exploit_singleton_column_in_initial_basis() const {
2429 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000010U);
2430 return value;
2431}
2432inline void GlopParameters::clear_exploit_singleton_column_in_initial_basis() {
2433 ::google::protobuf::internal::TSanWrite(&_impl_);
2434 _impl_.exploit_singleton_column_in_initial_basis_ = true;
2435 ClearHasBit(_impl_._has_bits_[1],
2436 0x00000010U);
2437}
2438inline bool GlopParameters::exploit_singleton_column_in_initial_basis() const {
2439 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.exploit_singleton_column_in_initial_basis)
2440 return _internal_exploit_singleton_column_in_initial_basis();
2441}
2442inline void GlopParameters::set_exploit_singleton_column_in_initial_basis(bool value) {
2443 _internal_set_exploit_singleton_column_in_initial_basis(value);
2444 SetHasBit(_impl_._has_bits_[1], 0x00000010U);
2445 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.exploit_singleton_column_in_initial_basis)
2446}
2447inline bool GlopParameters::_internal_exploit_singleton_column_in_initial_basis() const {
2448 ::google::protobuf::internal::TSanRead(&_impl_);
2449 return _impl_.exploit_singleton_column_in_initial_basis_;
2450}
2451inline void GlopParameters::_internal_set_exploit_singleton_column_in_initial_basis(bool value) {
2452 ::google::protobuf::internal::TSanWrite(&_impl_);
2453 _impl_.exploit_singleton_column_in_initial_basis_ = value;
2454}
2455
2456// optional double dual_small_pivot_threshold = 38 [default = 0.0001];
2457inline bool GlopParameters::has_dual_small_pivot_threshold() const {
2458 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000020U);
2459 return value;
2460}
2461inline void GlopParameters::clear_dual_small_pivot_threshold() {
2462 ::google::protobuf::internal::TSanWrite(&_impl_);
2463 _impl_.dual_small_pivot_threshold_ = 0.0001;
2464 ClearHasBit(_impl_._has_bits_[1],
2465 0x00000020U);
2466}
2467inline double GlopParameters::dual_small_pivot_threshold() const {
2468 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.dual_small_pivot_threshold)
2469 return _internal_dual_small_pivot_threshold();
2470}
2471inline void GlopParameters::set_dual_small_pivot_threshold(double value) {
2472 _internal_set_dual_small_pivot_threshold(value);
2473 SetHasBit(_impl_._has_bits_[1], 0x00000020U);
2474 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.dual_small_pivot_threshold)
2475}
2476inline double GlopParameters::_internal_dual_small_pivot_threshold() const {
2477 ::google::protobuf::internal::TSanRead(&_impl_);
2478 return _impl_.dual_small_pivot_threshold_;
2479}
2480inline void GlopParameters::_internal_set_dual_small_pivot_threshold(double value) {
2481 ::google::protobuf::internal::TSanWrite(&_impl_);
2482 _impl_.dual_small_pivot_threshold_ = value;
2483}
2484
2485// optional double preprocessor_zero_tolerance = 39 [default = 1e-09];
2486inline bool GlopParameters::has_preprocessor_zero_tolerance() const {
2487 bool value = CheckHasBit(_impl_._has_bits_[0], 0x04000000U);
2488 return value;
2489}
2490inline void GlopParameters::clear_preprocessor_zero_tolerance() {
2491 ::google::protobuf::internal::TSanWrite(&_impl_);
2492 _impl_.preprocessor_zero_tolerance_ = 1e-09;
2493 ClearHasBit(_impl_._has_bits_[0],
2494 0x04000000U);
2495}
2496inline double GlopParameters::preprocessor_zero_tolerance() const {
2497 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.preprocessor_zero_tolerance)
2498 return _internal_preprocessor_zero_tolerance();
2499}
2500inline void GlopParameters::set_preprocessor_zero_tolerance(double value) {
2501 _internal_set_preprocessor_zero_tolerance(value);
2502 SetHasBit(_impl_._has_bits_[0], 0x04000000U);
2503 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.preprocessor_zero_tolerance)
2504}
2505inline double GlopParameters::_internal_preprocessor_zero_tolerance() const {
2506 ::google::protobuf::internal::TSanRead(&_impl_);
2507 return _impl_.preprocessor_zero_tolerance_;
2508}
2509inline void GlopParameters::_internal_set_preprocessor_zero_tolerance(double value) {
2510 ::google::protobuf::internal::TSanWrite(&_impl_);
2511 _impl_.preprocessor_zero_tolerance_ = value;
2512}
2513
2514// optional double objective_lower_limit = 40 [default = -inf];
2515inline bool GlopParameters::has_objective_lower_limit() const {
2516 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000040U);
2517 return value;
2518}
2519inline void GlopParameters::clear_objective_lower_limit() {
2520 ::google::protobuf::internal::TSanWrite(&_impl_);
2521 _impl_.objective_lower_limit_ = -std::numeric_limits<double>::infinity();
2522 ClearHasBit(_impl_._has_bits_[1],
2523 0x00000040U);
2524}
2525inline double GlopParameters::objective_lower_limit() const {
2526 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.objective_lower_limit)
2527 return _internal_objective_lower_limit();
2528}
2529inline void GlopParameters::set_objective_lower_limit(double value) {
2530 _internal_set_objective_lower_limit(value);
2531 SetHasBit(_impl_._has_bits_[1], 0x00000040U);
2532 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.objective_lower_limit)
2533}
2534inline double GlopParameters::_internal_objective_lower_limit() const {
2535 ::google::protobuf::internal::TSanRead(&_impl_);
2536 return _impl_.objective_lower_limit_;
2537}
2538inline void GlopParameters::_internal_set_objective_lower_limit(double value) {
2539 ::google::protobuf::internal::TSanWrite(&_impl_);
2540 _impl_.objective_lower_limit_ = value;
2541}
2542
2543// optional double objective_upper_limit = 41 [default = inf];
2544inline bool GlopParameters::has_objective_upper_limit() const {
2545 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000080U);
2546 return value;
2547}
2548inline void GlopParameters::clear_objective_upper_limit() {
2549 ::google::protobuf::internal::TSanWrite(&_impl_);
2550 _impl_.objective_upper_limit_ = std::numeric_limits<double>::infinity();
2551 ClearHasBit(_impl_._has_bits_[1],
2552 0x00000080U);
2553}
2554inline double GlopParameters::objective_upper_limit() const {
2555 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.objective_upper_limit)
2556 return _internal_objective_upper_limit();
2557}
2558inline void GlopParameters::set_objective_upper_limit(double value) {
2559 _internal_set_objective_upper_limit(value);
2560 SetHasBit(_impl_._has_bits_[1], 0x00000080U);
2561 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.objective_upper_limit)
2562}
2563inline double GlopParameters::_internal_objective_upper_limit() const {
2564 ::google::protobuf::internal::TSanRead(&_impl_);
2565 return _impl_.objective_upper_limit_;
2566}
2567inline void GlopParameters::_internal_set_objective_upper_limit(double value) {
2568 ::google::protobuf::internal::TSanWrite(&_impl_);
2569 _impl_.objective_upper_limit_ = value;
2570}
2571
2572// optional double degenerate_ministep_factor = 42 [default = 0.01];
2573inline bool GlopParameters::has_degenerate_ministep_factor() const {
2574 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000100U);
2575 return value;
2576}
2577inline void GlopParameters::clear_degenerate_ministep_factor() {
2578 ::google::protobuf::internal::TSanWrite(&_impl_);
2579 _impl_.degenerate_ministep_factor_ = 0.01;
2580 ClearHasBit(_impl_._has_bits_[1],
2581 0x00000100U);
2582}
2583inline double GlopParameters::degenerate_ministep_factor() const {
2584 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.degenerate_ministep_factor)
2585 return _internal_degenerate_ministep_factor();
2586}
2587inline void GlopParameters::set_degenerate_ministep_factor(double value) {
2588 _internal_set_degenerate_ministep_factor(value);
2589 SetHasBit(_impl_._has_bits_[1], 0x00000100U);
2590 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.degenerate_ministep_factor)
2591}
2592inline double GlopParameters::_internal_degenerate_ministep_factor() const {
2593 ::google::protobuf::internal::TSanRead(&_impl_);
2594 return _impl_.degenerate_ministep_factor_;
2595}
2596inline void GlopParameters::_internal_set_degenerate_ministep_factor(double value) {
2597 ::google::protobuf::internal::TSanWrite(&_impl_);
2598 _impl_.degenerate_ministep_factor_ = value;
2599}
2600
2601// optional int32 random_seed = 43 [default = 1];
2602inline bool GlopParameters::has_random_seed() const {
2603 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000400U);
2604 return value;
2605}
2606inline void GlopParameters::clear_random_seed() {
2607 ::google::protobuf::internal::TSanWrite(&_impl_);
2608 _impl_.random_seed_ = 1;
2609 ClearHasBit(_impl_._has_bits_[1],
2610 0x00000400U);
2611}
2612inline ::int32_t GlopParameters::random_seed() const {
2613 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.random_seed)
2614 return _internal_random_seed();
2615}
2616inline void GlopParameters::set_random_seed(::int32_t value) {
2617 _internal_set_random_seed(value);
2618 SetHasBit(_impl_._has_bits_[1], 0x00000400U);
2619 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.random_seed)
2620}
2621inline ::int32_t GlopParameters::_internal_random_seed() const {
2622 ::google::protobuf::internal::TSanRead(&_impl_);
2623 return _impl_.random_seed_;
2624}
2625inline void GlopParameters::_internal_set_random_seed(::int32_t value) {
2626 ::google::protobuf::internal::TSanWrite(&_impl_);
2627 _impl_.random_seed_ = value;
2628}
2629
2630// optional bool use_absl_random = 72 [default = false];
2631inline bool GlopParameters::has_use_absl_random() const {
2632 bool value = CheckHasBit(_impl_._has_bits_[0], 0x80000000U);
2633 return value;
2634}
2635inline void GlopParameters::clear_use_absl_random() {
2636 ::google::protobuf::internal::TSanWrite(&_impl_);
2637 _impl_.use_absl_random_ = false;
2638 ClearHasBit(_impl_._has_bits_[0],
2639 0x80000000U);
2640}
2641inline bool GlopParameters::use_absl_random() const {
2642 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.use_absl_random)
2643 return _internal_use_absl_random();
2644}
2645inline void GlopParameters::set_use_absl_random(bool value) {
2646 _internal_set_use_absl_random(value);
2647 SetHasBit(_impl_._has_bits_[0], 0x80000000U);
2648 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.use_absl_random)
2649}
2650inline bool GlopParameters::_internal_use_absl_random() const {
2651 ::google::protobuf::internal::TSanRead(&_impl_);
2652 return _impl_.use_absl_random_;
2653}
2654inline void GlopParameters::_internal_set_use_absl_random(bool value) {
2655 ::google::protobuf::internal::TSanWrite(&_impl_);
2656 _impl_.use_absl_random_ = value;
2657}
2658
2659// optional int32 num_omp_threads = 44 [default = 1];
2660inline bool GlopParameters::has_num_omp_threads() const {
2661 bool value = CheckHasBit(_impl_._has_bits_[0], 0x02000000U);
2662 return value;
2663}
2664inline void GlopParameters::clear_num_omp_threads() {
2665 ::google::protobuf::internal::TSanWrite(&_impl_);
2666 _impl_.num_omp_threads_ = 1;
2667 ClearHasBit(_impl_._has_bits_[0],
2668 0x02000000U);
2669}
2670inline ::int32_t GlopParameters::num_omp_threads() const {
2671 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.num_omp_threads)
2672 return _internal_num_omp_threads();
2673}
2674inline void GlopParameters::set_num_omp_threads(::int32_t value) {
2675 _internal_set_num_omp_threads(value);
2676 SetHasBit(_impl_._has_bits_[0], 0x02000000U);
2677 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.num_omp_threads)
2678}
2679inline ::int32_t GlopParameters::_internal_num_omp_threads() const {
2680 ::google::protobuf::internal::TSanRead(&_impl_);
2681 return _impl_.num_omp_threads_;
2682}
2683inline void GlopParameters::_internal_set_num_omp_threads(::int32_t value) {
2684 ::google::protobuf::internal::TSanWrite(&_impl_);
2685 _impl_.num_omp_threads_ = value;
2686}
2687
2688// optional bool perturb_costs_in_dual_simplex = 53 [default = false];
2689inline bool GlopParameters::has_perturb_costs_in_dual_simplex() const {
2690 bool value = CheckHasBit(_impl_._has_bits_[0], 0x10000000U);
2691 return value;
2692}
2693inline void GlopParameters::clear_perturb_costs_in_dual_simplex() {
2694 ::google::protobuf::internal::TSanWrite(&_impl_);
2695 _impl_.perturb_costs_in_dual_simplex_ = false;
2696 ClearHasBit(_impl_._has_bits_[0],
2697 0x10000000U);
2698}
2699inline bool GlopParameters::perturb_costs_in_dual_simplex() const {
2700 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.perturb_costs_in_dual_simplex)
2701 return _internal_perturb_costs_in_dual_simplex();
2702}
2703inline void GlopParameters::set_perturb_costs_in_dual_simplex(bool value) {
2704 _internal_set_perturb_costs_in_dual_simplex(value);
2705 SetHasBit(_impl_._has_bits_[0], 0x10000000U);
2706 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.perturb_costs_in_dual_simplex)
2707}
2708inline bool GlopParameters::_internal_perturb_costs_in_dual_simplex() const {
2709 ::google::protobuf::internal::TSanRead(&_impl_);
2710 return _impl_.perturb_costs_in_dual_simplex_;
2711}
2712inline void GlopParameters::_internal_set_perturb_costs_in_dual_simplex(bool value) {
2713 ::google::protobuf::internal::TSanWrite(&_impl_);
2714 _impl_.perturb_costs_in_dual_simplex_ = value;
2715}
2716
2717// optional bool use_dedicated_dual_feasibility_algorithm = 62 [default = true];
2718inline bool GlopParameters::has_use_dedicated_dual_feasibility_algorithm() const {
2719 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00080000U);
2720 return value;
2721}
2722inline void GlopParameters::clear_use_dedicated_dual_feasibility_algorithm() {
2723 ::google::protobuf::internal::TSanWrite(&_impl_);
2724 _impl_.use_dedicated_dual_feasibility_algorithm_ = true;
2725 ClearHasBit(_impl_._has_bits_[1],
2726 0x00080000U);
2727}
2728inline bool GlopParameters::use_dedicated_dual_feasibility_algorithm() const {
2729 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.use_dedicated_dual_feasibility_algorithm)
2730 return _internal_use_dedicated_dual_feasibility_algorithm();
2731}
2732inline void GlopParameters::set_use_dedicated_dual_feasibility_algorithm(bool value) {
2733 _internal_set_use_dedicated_dual_feasibility_algorithm(value);
2734 SetHasBit(_impl_._has_bits_[1], 0x00080000U);
2735 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.use_dedicated_dual_feasibility_algorithm)
2736}
2737inline bool GlopParameters::_internal_use_dedicated_dual_feasibility_algorithm() const {
2738 ::google::protobuf::internal::TSanRead(&_impl_);
2739 return _impl_.use_dedicated_dual_feasibility_algorithm_;
2740}
2741inline void GlopParameters::_internal_set_use_dedicated_dual_feasibility_algorithm(bool value) {
2742 ::google::protobuf::internal::TSanWrite(&_impl_);
2743 _impl_.use_dedicated_dual_feasibility_algorithm_ = value;
2744}
2745
2746// optional double relative_cost_perturbation = 54 [default = 1e-05];
2747inline bool GlopParameters::has_relative_cost_perturbation() const {
2748 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00002000U);
2749 return value;
2750}
2751inline void GlopParameters::clear_relative_cost_perturbation() {
2752 ::google::protobuf::internal::TSanWrite(&_impl_);
2753 _impl_.relative_cost_perturbation_ = 1e-05;
2754 ClearHasBit(_impl_._has_bits_[1],
2755 0x00002000U);
2756}
2757inline double GlopParameters::relative_cost_perturbation() const {
2758 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.relative_cost_perturbation)
2759 return _internal_relative_cost_perturbation();
2760}
2761inline void GlopParameters::set_relative_cost_perturbation(double value) {
2762 _internal_set_relative_cost_perturbation(value);
2763 SetHasBit(_impl_._has_bits_[1], 0x00002000U);
2764 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.relative_cost_perturbation)
2765}
2766inline double GlopParameters::_internal_relative_cost_perturbation() const {
2767 ::google::protobuf::internal::TSanRead(&_impl_);
2768 return _impl_.relative_cost_perturbation_;
2769}
2770inline void GlopParameters::_internal_set_relative_cost_perturbation(double value) {
2771 ::google::protobuf::internal::TSanWrite(&_impl_);
2772 _impl_.relative_cost_perturbation_ = value;
2773}
2774
2775// optional double relative_max_cost_perturbation = 55 [default = 1e-07];
2776inline bool GlopParameters::has_relative_max_cost_perturbation() const {
2777 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00004000U);
2778 return value;
2779}
2780inline void GlopParameters::clear_relative_max_cost_perturbation() {
2781 ::google::protobuf::internal::TSanWrite(&_impl_);
2782 _impl_.relative_max_cost_perturbation_ = 1e-07;
2783 ClearHasBit(_impl_._has_bits_[1],
2784 0x00004000U);
2785}
2786inline double GlopParameters::relative_max_cost_perturbation() const {
2787 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.relative_max_cost_perturbation)
2788 return _internal_relative_max_cost_perturbation();
2789}
2790inline void GlopParameters::set_relative_max_cost_perturbation(double value) {
2791 _internal_set_relative_max_cost_perturbation(value);
2792 SetHasBit(_impl_._has_bits_[1], 0x00004000U);
2793 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.relative_max_cost_perturbation)
2794}
2795inline double GlopParameters::_internal_relative_max_cost_perturbation() const {
2796 ::google::protobuf::internal::TSanRead(&_impl_);
2797 return _impl_.relative_max_cost_perturbation_;
2798}
2799inline void GlopParameters::_internal_set_relative_max_cost_perturbation(double value) {
2800 ::google::protobuf::internal::TSanWrite(&_impl_);
2801 _impl_.relative_max_cost_perturbation_ = value;
2802}
2803
2804// optional double initial_condition_number_threshold = 59 [default = 1e+50];
2805inline bool GlopParameters::has_initial_condition_number_threshold() const {
2806 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00010000U);
2807 return value;
2808}
2809inline void GlopParameters::clear_initial_condition_number_threshold() {
2810 ::google::protobuf::internal::TSanWrite(&_impl_);
2811 _impl_.initial_condition_number_threshold_ = 1e+50;
2812 ClearHasBit(_impl_._has_bits_[1],
2813 0x00010000U);
2814}
2815inline double GlopParameters::initial_condition_number_threshold() const {
2816 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.initial_condition_number_threshold)
2817 return _internal_initial_condition_number_threshold();
2818}
2819inline void GlopParameters::set_initial_condition_number_threshold(double value) {
2820 _internal_set_initial_condition_number_threshold(value);
2821 SetHasBit(_impl_._has_bits_[1], 0x00010000U);
2822 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.initial_condition_number_threshold)
2823}
2824inline double GlopParameters::_internal_initial_condition_number_threshold() const {
2825 ::google::protobuf::internal::TSanRead(&_impl_);
2826 return _impl_.initial_condition_number_threshold_;
2827}
2828inline void GlopParameters::_internal_set_initial_condition_number_threshold(double value) {
2829 ::google::protobuf::internal::TSanWrite(&_impl_);
2830 _impl_.initial_condition_number_threshold_ = value;
2831}
2832
2833// optional bool log_search_progress = 61 [default = false];
2834inline bool GlopParameters::has_log_search_progress() const {
2835 bool value = CheckHasBit(_impl_._has_bits_[0], 0x20000000U);
2836 return value;
2837}
2838inline void GlopParameters::clear_log_search_progress() {
2839 ::google::protobuf::internal::TSanWrite(&_impl_);
2840 _impl_.log_search_progress_ = false;
2841 ClearHasBit(_impl_._has_bits_[0],
2842 0x20000000U);
2843}
2844inline bool GlopParameters::log_search_progress() const {
2845 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.log_search_progress)
2846 return _internal_log_search_progress();
2847}
2848inline void GlopParameters::set_log_search_progress(bool value) {
2849 _internal_set_log_search_progress(value);
2850 SetHasBit(_impl_._has_bits_[0], 0x20000000U);
2851 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.log_search_progress)
2852}
2853inline bool GlopParameters::_internal_log_search_progress() const {
2854 ::google::protobuf::internal::TSanRead(&_impl_);
2855 return _impl_.log_search_progress_;
2856}
2857inline void GlopParameters::_internal_set_log_search_progress(bool value) {
2858 ::google::protobuf::internal::TSanWrite(&_impl_);
2859 _impl_.log_search_progress_ = value;
2860}
2861
2862// optional bool log_to_stdout = 66 [default = true];
2863inline bool GlopParameters::has_log_to_stdout() const {
2864 bool value = CheckHasBit(_impl_._has_bits_[1], 0x02000000U);
2865 return value;
2866}
2867inline void GlopParameters::clear_log_to_stdout() {
2868 ::google::protobuf::internal::TSanWrite(&_impl_);
2869 _impl_.log_to_stdout_ = true;
2870 ClearHasBit(_impl_._has_bits_[1],
2871 0x02000000U);
2872}
2873inline bool GlopParameters::log_to_stdout() const {
2874 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.log_to_stdout)
2875 return _internal_log_to_stdout();
2876}
2877inline void GlopParameters::set_log_to_stdout(bool value) {
2878 _internal_set_log_to_stdout(value);
2879 SetHasBit(_impl_._has_bits_[1], 0x02000000U);
2880 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.log_to_stdout)
2881}
2882inline bool GlopParameters::_internal_log_to_stdout() const {
2883 ::google::protobuf::internal::TSanRead(&_impl_);
2884 return _impl_.log_to_stdout_;
2885}
2886inline void GlopParameters::_internal_set_log_to_stdout(bool value) {
2887 ::google::protobuf::internal::TSanWrite(&_impl_);
2888 _impl_.log_to_stdout_ = value;
2889}
2890
2891// optional double crossover_bound_snapping_distance = 64 [default = inf];
2892inline bool GlopParameters::has_crossover_bound_snapping_distance() const {
2893 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00400000U);
2894 return value;
2895}
2896inline void GlopParameters::clear_crossover_bound_snapping_distance() {
2897 ::google::protobuf::internal::TSanWrite(&_impl_);
2898 _impl_.crossover_bound_snapping_distance_ = std::numeric_limits<double>::infinity();
2899 ClearHasBit(_impl_._has_bits_[1],
2900 0x00400000U);
2901}
2902inline double GlopParameters::crossover_bound_snapping_distance() const {
2903 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.crossover_bound_snapping_distance)
2904 return _internal_crossover_bound_snapping_distance();
2905}
2906inline void GlopParameters::set_crossover_bound_snapping_distance(double value) {
2907 _internal_set_crossover_bound_snapping_distance(value);
2908 SetHasBit(_impl_._has_bits_[1], 0x00400000U);
2909 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.crossover_bound_snapping_distance)
2910}
2911inline double GlopParameters::_internal_crossover_bound_snapping_distance() const {
2912 ::google::protobuf::internal::TSanRead(&_impl_);
2913 return _impl_.crossover_bound_snapping_distance_;
2914}
2915inline void GlopParameters::_internal_set_crossover_bound_snapping_distance(double value) {
2916 ::google::protobuf::internal::TSanWrite(&_impl_);
2917 _impl_.crossover_bound_snapping_distance_ = value;
2918}
2919
2920// optional bool push_to_vertex = 65 [default = true];
2921inline bool GlopParameters::has_push_to_vertex() const {
2922 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00200000U);
2923 return value;
2924}
2925inline void GlopParameters::clear_push_to_vertex() {
2926 ::google::protobuf::internal::TSanWrite(&_impl_);
2927 _impl_.push_to_vertex_ = true;
2928 ClearHasBit(_impl_._has_bits_[1],
2929 0x00200000U);
2930}
2931inline bool GlopParameters::push_to_vertex() const {
2932 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.push_to_vertex)
2933 return _internal_push_to_vertex();
2934}
2935inline void GlopParameters::set_push_to_vertex(bool value) {
2936 _internal_set_push_to_vertex(value);
2937 SetHasBit(_impl_._has_bits_[1], 0x00200000U);
2938 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.push_to_vertex)
2939}
2940inline bool GlopParameters::_internal_push_to_vertex() const {
2941 ::google::protobuf::internal::TSanRead(&_impl_);
2942 return _impl_.push_to_vertex_;
2943}
2944inline void GlopParameters::_internal_set_push_to_vertex(bool value) {
2945 ::google::protobuf::internal::TSanWrite(&_impl_);
2946 _impl_.push_to_vertex_ = value;
2947}
2948
2949// optional bool use_implied_free_preprocessor = 67 [default = true];
2950inline bool GlopParameters::has_use_implied_free_preprocessor() const {
2951 bool value = CheckHasBit(_impl_._has_bits_[1], 0x04000000U);
2952 return value;
2953}
2954inline void GlopParameters::clear_use_implied_free_preprocessor() {
2955 ::google::protobuf::internal::TSanWrite(&_impl_);
2956 _impl_.use_implied_free_preprocessor_ = true;
2957 ClearHasBit(_impl_._has_bits_[1],
2958 0x04000000U);
2959}
2960inline bool GlopParameters::use_implied_free_preprocessor() const {
2961 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.use_implied_free_preprocessor)
2962 return _internal_use_implied_free_preprocessor();
2963}
2964inline void GlopParameters::set_use_implied_free_preprocessor(bool value) {
2965 _internal_set_use_implied_free_preprocessor(value);
2966 SetHasBit(_impl_._has_bits_[1], 0x04000000U);
2967 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.use_implied_free_preprocessor)
2968}
2969inline bool GlopParameters::_internal_use_implied_free_preprocessor() const {
2970 ::google::protobuf::internal::TSanRead(&_impl_);
2971 return _impl_.use_implied_free_preprocessor_;
2972}
2973inline void GlopParameters::_internal_set_use_implied_free_preprocessor(bool value) {
2974 ::google::protobuf::internal::TSanWrite(&_impl_);
2975 _impl_.use_implied_free_preprocessor_ = value;
2976}
2977
2978// optional double max_valid_magnitude = 70 [default = 1e+30];
2979inline bool GlopParameters::has_max_valid_magnitude() const {
2980 bool value = CheckHasBit(_impl_._has_bits_[1], 0x00800000U);
2981 return value;
2982}
2983inline void GlopParameters::clear_max_valid_magnitude() {
2984 ::google::protobuf::internal::TSanWrite(&_impl_);
2985 _impl_.max_valid_magnitude_ = 1e+30;
2986 ClearHasBit(_impl_._has_bits_[1],
2987 0x00800000U);
2988}
2989inline double GlopParameters::max_valid_magnitude() const {
2990 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.max_valid_magnitude)
2991 return _internal_max_valid_magnitude();
2992}
2993inline void GlopParameters::set_max_valid_magnitude(double value) {
2994 _internal_set_max_valid_magnitude(value);
2995 SetHasBit(_impl_._has_bits_[1], 0x00800000U);
2996 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.max_valid_magnitude)
2997}
2998inline double GlopParameters::_internal_max_valid_magnitude() const {
2999 ::google::protobuf::internal::TSanRead(&_impl_);
3000 return _impl_.max_valid_magnitude_;
3001}
3002inline void GlopParameters::_internal_set_max_valid_magnitude(double value) {
3003 ::google::protobuf::internal::TSanWrite(&_impl_);
3004 _impl_.max_valid_magnitude_ = value;
3005}
3006
3007// optional double drop_magnitude = 71 [default = 1e-30];
3008inline bool GlopParameters::has_drop_magnitude() const {
3009 bool value = CheckHasBit(_impl_._has_bits_[1], 0x01000000U);
3010 return value;
3011}
3012inline void GlopParameters::clear_drop_magnitude() {
3013 ::google::protobuf::internal::TSanWrite(&_impl_);
3014 _impl_.drop_magnitude_ = 1e-30;
3015 ClearHasBit(_impl_._has_bits_[1],
3016 0x01000000U);
3017}
3018inline double GlopParameters::drop_magnitude() const {
3019 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.drop_magnitude)
3020 return _internal_drop_magnitude();
3021}
3022inline void GlopParameters::set_drop_magnitude(double value) {
3023 _internal_set_drop_magnitude(value);
3024 SetHasBit(_impl_._has_bits_[1], 0x01000000U);
3025 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.drop_magnitude)
3026}
3027inline double GlopParameters::_internal_drop_magnitude() const {
3028 ::google::protobuf::internal::TSanRead(&_impl_);
3029 return _impl_.drop_magnitude_;
3030}
3031inline void GlopParameters::_internal_set_drop_magnitude(double value) {
3032 ::google::protobuf::internal::TSanWrite(&_impl_);
3033 _impl_.drop_magnitude_ = value;
3034}
3035
3036// optional bool dual_price_prioritize_norm = 69 [default = false];
3037inline bool GlopParameters::has_dual_price_prioritize_norm() const {
3038 bool value = CheckHasBit(_impl_._has_bits_[0], 0x40000000U);
3039 return value;
3040}
3041inline void GlopParameters::clear_dual_price_prioritize_norm() {
3042 ::google::protobuf::internal::TSanWrite(&_impl_);
3043 _impl_.dual_price_prioritize_norm_ = false;
3044 ClearHasBit(_impl_._has_bits_[0],
3045 0x40000000U);
3046}
3047inline bool GlopParameters::dual_price_prioritize_norm() const {
3048 // @@protoc_insertion_point(field_get:operations_research.glop.GlopParameters.dual_price_prioritize_norm)
3049 return _internal_dual_price_prioritize_norm();
3050}
3051inline void GlopParameters::set_dual_price_prioritize_norm(bool value) {
3052 _internal_set_dual_price_prioritize_norm(value);
3053 SetHasBit(_impl_._has_bits_[0], 0x40000000U);
3054 // @@protoc_insertion_point(field_set:operations_research.glop.GlopParameters.dual_price_prioritize_norm)
3055}
3056inline bool GlopParameters::_internal_dual_price_prioritize_norm() const {
3057 ::google::protobuf::internal::TSanRead(&_impl_);
3058 return _impl_.dual_price_prioritize_norm_;
3059}
3060inline void GlopParameters::_internal_set_dual_price_prioritize_norm(bool value) {
3061 ::google::protobuf::internal::TSanWrite(&_impl_);
3062 _impl_.dual_price_prioritize_norm_ = value;
3063}
3064
3065#ifdef __GNUC__
3066#pragma GCC diagnostic pop
3067#endif // __GNUC__
3068
3069// @@protoc_insertion_point(namespace_scope)
3070} // namespace glop
3071} // namespace operations_research
3072
3073
3074namespace google {
3075namespace protobuf {
3076
3077template <>
3078struct is_proto_enum<::operations_research::glop::GlopParameters_ScalingAlgorithm> : std::true_type {};
3079template <>
3080inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_ScalingAlgorithm>() {
3081 return ::operations_research::glop::GlopParameters_ScalingAlgorithm_descriptor();
3082}
3083template <>
3084struct is_proto_enum<::operations_research::glop::GlopParameters_SolverBehavior> : std::true_type {};
3085template <>
3086inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_SolverBehavior>() {
3087 return ::operations_research::glop::GlopParameters_SolverBehavior_descriptor();
3088}
3089template <>
3090struct is_proto_enum<::operations_research::glop::GlopParameters_PricingRule> : std::true_type {};
3091template <>
3092inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_PricingRule>() {
3093 return ::operations_research::glop::GlopParameters_PricingRule_descriptor();
3094}
3095template <>
3096struct is_proto_enum<::operations_research::glop::GlopParameters_InitialBasisHeuristic> : std::true_type {};
3097template <>
3098inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_InitialBasisHeuristic>() {
3099 return ::operations_research::glop::GlopParameters_InitialBasisHeuristic_descriptor();
3100}
3101template <>
3102struct is_proto_enum<::operations_research::glop::GlopParameters_CostScalingAlgorithm> : std::true_type {};
3103template <>
3104inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_CostScalingAlgorithm>() {
3105 return ::operations_research::glop::GlopParameters_CostScalingAlgorithm_descriptor();
3106}
3107
3108} // namespace protobuf
3109} // namespace google
3110
3111// @@protoc_insertion_point(global_scope)
3112
3113#include "google/protobuf/port_undef.inc"
3114
3115#endif // ortools_2fglop_2fparameters_2eproto_2epb_2eh
operations_research::bop::GlopParameters
Definition parameters.pb.h:272
operations_research::bop::GlopParameters::GlopParameters
GlopParameters()
Definition parameters.pb.h:274
operations_research::glop::GlopParameters::_Internal
Definition parameters.pb.cc:389
operations_research::glop::GlopParameters
Definition parameters.pb.h:272
operations_research::glop::GlopParameters::Swap
void Swap(GlopParameters *PROTOBUF_NONNULL other)
Definition parameters.pb.h:328
operations_research::glop::GlopParameters::operator=
GlopParameters & operator=(const GlopParameters &from)
Definition parameters.pb.h:290
operations_research::glop::GlopParameters::_impl_
Impl_ _impl_
Definition parameters.pb.h:1316
operations_research::glop::GlopParameters::use_middle_product_form_update
bool use_middle_product_form_update() const
Definition parameters.pb.h:2385
operations_research::glop::GlopParameters::clear_devex_weights_reset_period
void clear_devex_weights_reset_period()
Definition parameters.pb.h:2321
operations_research::glop::GlopParameters::has_random_seed
bool has_random_seed() const
Definition parameters.pb.h:2607
operations_research::glop::GlopParameters::PricingRule_IsValid
static bool PricingRule_IsValid(int value)
Definition parameters.pb.h:456
operations_research::glop::GlopParameters::refactorization_threshold
double refactorization_threshold() const
Definition parameters.pb.h:1448
operations_research::glop::GlopParameters::has_provide_strong_optimal_guarantee
bool has_provide_strong_optimal_guarantee() const
Definition parameters.pb.h:1998
operations_research::glop::GlopParameters::has_objective_lower_limit
bool has_objective_lower_limit() const
Definition parameters.pb.h:2520
operations_research::glop::GlopParameters::markowitz_singularity_threshold
double markowitz_singularity_threshold() const
Definition parameters.pb.h:2240
operations_research::glop::GlopParameters::set_solve_dual_problem
void set_solve_dual_problem(::operations_research::glop::GlopParameters_SolverBehavior value)
Definition parameters.pb.h:1922
operations_research::glop::GlopParameters::has_log_search_progress
bool has_log_search_progress() const
Definition parameters.pb.h:2839
operations_research::glop::GlopParameters::set_use_implied_free_preprocessor
void set_use_implied_free_preprocessor(bool value)
Definition parameters.pb.h:2969
operations_research::glop::GlopParameters::has_optimization_rule
bool has_optimization_rule() const
Definition parameters.pb.h:1406
operations_research::glop::GlopParameters::has_use_scaling
bool has_use_scaling() const
Definition parameters.pb.h:1728
operations_research::glop::GlopParameters::has_drop_tolerance
bool has_drop_tolerance() const
Definition parameters.pb.h:1699
operations_research::glop::GlopParameters::InitialBasisHeuristic_ARRAYSIZE
static constexpr int InitialBasisHeuristic_ARRAYSIZE
Definition parameters.pb.h:483
operations_research::glop::GlopParameters::MessageLite
friend class ::google::protobuf::MessageLite
Definition parameters.pb.h:1238
operations_research::glop::GlopParameters::EQUILIBRATION
static constexpr ScalingAlgorithm EQUILIBRATION
Definition parameters.pb.h:412
operations_research::glop::GlopParameters::clear_max_valid_magnitude
void clear_max_valid_magnitude()
Definition parameters.pb.h:2988
operations_research::glop::GlopParameters::has_solve_dual_problem
bool has_solve_dual_problem() const
Definition parameters.pb.h:1908
operations_research::glop::GlopParameters::has_use_transposed_matrix
bool has_use_transposed_matrix() const
Definition parameters.pb.h:1821
operations_research::glop::GlopParameters::initialize_devex_with_column_norms
bool initialize_devex_with_column_norms() const
Definition parameters.pb.h:2414
operations_research::glop::GlopParameters::relative_max_cost_perturbation
double relative_max_cost_perturbation() const
Definition parameters.pb.h:2791
operations_research::glop::GlopParameters::set_log_to_stdout
void set_log_to_stdout(bool value)
Definition parameters.pb.h:2882
operations_research::glop::GlopParameters::set_relative_cost_perturbation
void set_relative_cost_perturbation(double value)
Definition parameters.pb.h:2766
operations_research::glop::GlopParameters::CostScalingAlgorithm_ARRAYSIZE
static constexpr int CostScalingAlgorithm_ARRAYSIZE
Definition parameters.pb.h:505
operations_research::glop::GlopParameters::clear_small_pivot_threshold
void clear_small_pivot_threshold()
Definition parameters.pb.h:1645
operations_research::glop::GlopParameters::has_scaling_method
bool has_scaling_method() const
Definition parameters.pb.h:1342
operations_research::glop::GlopParameters::set_scaling_method
void set_scaling_method(::operations_research::glop::GlopParameters_ScalingAlgorithm value)
Definition parameters.pb.h:1356
operations_research::glop::GlopParameters::provide_strong_optimal_guarantee
bool provide_strong_optimal_guarantee() const
Definition parameters.pb.h:2008
operations_research::glop::GlopParameters::set_num_omp_threads
void set_num_omp_threads(::int32_t value)
Definition parameters.pb.h:2679
operations_research::glop::GlopParameters::clear_degenerate_ministep_factor
void clear_degenerate_ministep_factor()
Definition parameters.pb.h:2582
operations_research::glop::GlopParameters::LINEAR_PROGRAM
static constexpr ScalingAlgorithm LINEAR_PROGRAM
Definition parameters.pb.h:413
operations_research::glop::GlopParameters::ScalingAlgorithm
GlopParameters_ScalingAlgorithm ScalingAlgorithm
Definition parameters.pb.h:410
operations_research::glop::GlopParameters::use_preprocessing
bool use_preprocessing() const
Definition parameters.pb.h:2356
operations_research::glop::GlopParameters::set_max_deterministic_time
void set_max_deterministic_time(double value)
Definition parameters.pb.h:2157
operations_research::glop::GlopParameters::set_relative_max_cost_perturbation
void set_relative_max_cost_perturbation(double value)
Definition parameters.pb.h:2795
operations_research::glop::GlopParameters::clear_ratio_test_zero_threshold
void clear_ratio_test_zero_threshold()
Definition parameters.pb.h:1587
operations_research::glop::GlopParameters::max_time_in_seconds
double max_time_in_seconds() const
Definition parameters.pb.h:2124
operations_research::glop::GlopParameters::preprocessor_zero_tolerance
double preprocessor_zero_tolerance() const
Definition parameters.pb.h:2501
operations_research::glop::GlopParameters::SolverBehavior_IsValid
static bool SolverBehavior_IsValid(int value)
Definition parameters.pb.h:435
operations_research::glop::GlopParameters::use_scaling
bool use_scaling() const
Definition parameters.pb.h:1738
operations_research::glop::GlopParameters::ScalingAlgorithm_descriptor
static const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL ScalingAlgorithm_descriptor()
Definition parameters.pb.h:420
operations_research::glop::GlopParameters::harris_tolerance_ratio
double harris_tolerance_ratio() const
Definition parameters.pb.h:1622
operations_research::glop::GlopParameters::log_to_stdout
bool log_to_stdout() const
Definition parameters.pb.h:2878
operations_research::glop::GlopParameters::clear_initial_basis
void clear_initial_basis()
Definition parameters.pb.h:1793
operations_research::glop::GlopParameters::DEVEX
static constexpr PricingRule DEVEX
Definition parameters.pb.h:455
operations_research::glop::GlopParameters::set_solution_feasibility_tolerance
void set_solution_feasibility_tolerance(double value)
Definition parameters.pb.h:1983
operations_research::glop::GlopParameters::clear_recompute_edges_norm_threshold
void clear_recompute_edges_norm_threshold()
Definition parameters.pb.h:1500
operations_research::glop::GlopParameters::clear_recompute_reduced_costs_threshold
void clear_recompute_reduced_costs_threshold()
Definition parameters.pb.h:1471
operations_research::glop::GlopParameters::has_max_deterministic_time
bool has_max_deterministic_time() const
Definition parameters.pb.h:2143
operations_research::glop::GlopParameters::has_minimum_acceptable_pivot
bool has_minimum_acceptable_pivot() const
Definition parameters.pb.h:1670
operations_research::glop::GlopParameters::clear_dynamically_adjust_refactorization_period
void clear_dynamically_adjust_refactorization_period()
Definition parameters.pb.h:1883
operations_research::glop::GlopParameters::change_status_to_imprecise
bool change_status_to_imprecise() const
Definition parameters.pb.h:2037
operations_research::glop::GlopParameters::clear_num_omp_threads
void clear_num_omp_threads()
Definition parameters.pb.h:2669
operations_research::glop::GlopParameters::clear_crossover_bound_snapping_distance
void clear_crossover_bound_snapping_distance()
Definition parameters.pb.h:2901
operations_research::glop::GlopParameters::clear_use_preprocessing
void clear_use_preprocessing()
Definition parameters.pb.h:2350
operations_research::glop::GlopParameters::use_absl_random
bool use_absl_random() const
Definition parameters.pb.h:2646
operations_research::glop::GlopParameters::STEEPEST_EDGE
static constexpr PricingRule STEEPEST_EDGE
Definition parameters.pb.h:454
operations_research::glop::GlopParameters::has_initial_basis
bool has_initial_basis() const
Definition parameters.pb.h:1789
operations_research::glop::GlopParameters::feasibility_rule
::operations_research::glop::GlopParameters_PricingRule feasibility_rule() const
Definition parameters.pb.h:1384
operations_research::glop::GlopParameters::unknown_fields
const ::google::protobuf::UnknownFieldSet & unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND
Definition parameters.pb.h:304
operations_research::glop::GlopParameters::set_crossover_bound_snapping_distance
void set_crossover_bound_snapping_distance(double value)
Definition parameters.pb.h:2911
operations_research::glop::GlopParameters::set_allow_simplex_algorithm_change
void set_allow_simplex_algorithm_change(bool value)
Definition parameters.pb.h:2302
operations_research::glop::GlopParameters::has_exploit_singleton_column_in_initial_basis
bool has_exploit_singleton_column_in_initial_basis() const
Definition parameters.pb.h:2433
operations_research::glop::GlopParameters::set_feasibility_rule
void set_feasibility_rule(::operations_research::glop::GlopParameters_PricingRule value)
Definition parameters.pb.h:1388
operations_research::glop::GlopParameters::clear_dual_feasibility_tolerance
void clear_dual_feasibility_tolerance()
Definition parameters.pb.h:1558
operations_research::glop::GlopParameters::markowitz_zlatev_parameter
::int32_t markowitz_zlatev_parameter() const
Definition parameters.pb.h:2211
operations_research::glop::GlopParameters::clear_max_deterministic_time
void clear_max_deterministic_time()
Definition parameters.pb.h:2147
operations_research::glop::GlopParameters::clear_exploit_singleton_column_in_initial_basis
void clear_exploit_singleton_column_in_initial_basis()
Definition parameters.pb.h:2437
operations_research::glop::GlopParameters::clear_use_absl_random
void clear_use_absl_random()
Definition parameters.pb.h:2640
operations_research::glop::GlopParameters::has_recompute_reduced_costs_threshold
bool has_recompute_reduced_costs_threshold() const
Definition parameters.pb.h:1467
operations_research::glop::GlopParameters::has_preprocessor_zero_tolerance
bool has_preprocessor_zero_tolerance() const
Definition parameters.pb.h:2491
operations_research::glop::GlopParameters::devex_weights_reset_period
::int32_t devex_weights_reset_period() const
Definition parameters.pb.h:2327
operations_research::glop::GlopParameters::clear_feasibility_rule
void clear_feasibility_rule()
Definition parameters.pb.h:1378
operations_research::glop::GlopParameters::LET_SOLVER_DECIDE
static constexpr SolverBehavior LET_SOLVER_DECIDE
Definition parameters.pb.h:434
operations_research::glop::GlopParameters::NEVER_DO
static constexpr SolverBehavior NEVER_DO
Definition parameters.pb.h:433
operations_research::glop::GlopParameters::has_feasibility_rule
bool has_feasibility_rule() const
Definition parameters.pb.h:1374
operations_research::glop::GlopParameters::set_max_valid_magnitude
void set_max_valid_magnitude(double value)
Definition parameters.pb.h:2998
operations_research::glop::GlopParameters::clear_use_dedicated_dual_feasibility_algorithm
void clear_use_dedicated_dual_feasibility_algorithm()
Definition parameters.pb.h:2727
operations_research::glop::GlopParameters::set_drop_magnitude
void set_drop_magnitude(double value)
Definition parameters.pb.h:3027
operations_research::glop::GlopParameters::set_objective_lower_limit
void set_objective_lower_limit(double value)
Definition parameters.pb.h:2534
operations_research::glop::GlopParameters::num_omp_threads
::int32_t num_omp_threads() const
Definition parameters.pb.h:2675
operations_research::glop::GlopParameters::has_objective_upper_limit
bool has_objective_upper_limit() const
Definition parameters.pb.h:2549
operations_research::glop::GlopParameters::has_crossover_bound_snapping_distance
bool has_crossover_bound_snapping_distance() const
Definition parameters.pb.h:2897
operations_research::glop::GlopParameters::ratio_test_zero_threshold
double ratio_test_zero_threshold() const
Definition parameters.pb.h:1593
operations_research::glop::GlopParameters::clear_scaling_method
void clear_scaling_method()
Definition parameters.pb.h:1346
operations_research::glop::GlopParameters::set_initial_basis
void set_initial_basis(::operations_research::glop::GlopParameters_InitialBasisHeuristic value)
Definition parameters.pb.h:1803
operations_research::glop::GlopParameters::set_provide_strong_optimal_guarantee
void set_provide_strong_optimal_guarantee(bool value)
Definition parameters.pb.h:2012
operations_research::glop::GlopParameters::GlopParameters
PROTOBUF_CONSTEXPR GlopParameters(::google::protobuf::internal::ConstantInitialized)
operations_research::glop::GlopParameters::clear_lu_factorization_pivot_threshold
void clear_lu_factorization_pivot_threshold()
Definition parameters.pb.h:2089
operations_research::glop::GlopParameters::InitialBasisHeuristic_descriptor
static const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL InitialBasisHeuristic_descriptor()
Definition parameters.pb.h:484
operations_research::glop::GlopParameters::use_implied_free_preprocessor
bool use_implied_free_preprocessor() const
Definition parameters.pb.h:2965
operations_research::glop::GlopParameters::set_optimization_rule
void set_optimization_rule(::operations_research::glop::GlopParameters_PricingRule value)
Definition parameters.pb.h:1420
operations_research::glop::GlopParameters::has_num_omp_threads
bool has_num_omp_threads() const
Definition parameters.pb.h:2665
operations_research::glop::GlopParameters::clear_basis_refactorization_period
void clear_basis_refactorization_period()
Definition parameters.pb.h:1854
operations_research::glop::GlopParameters::degenerate_ministep_factor
double degenerate_ministep_factor() const
Definition parameters.pb.h:2588
operations_research::glop::GlopParameters::GlopParameters
GlopParameters(const GlopParameters &from)
Definition parameters.pb.h:287
operations_research::glop::GlopParameters::clear_random_seed
void clear_random_seed()
Definition parameters.pb.h:2611
operations_research::glop::GlopParameters::BIXBY
static constexpr InitialBasisHeuristic BIXBY
Definition parameters.pb.h:475
operations_research::glop::GlopParameters::clear_push_to_vertex
void clear_push_to_vertex()
Definition parameters.pb.h:2930
operations_research::glop::GlopParameters::clear_perturb_costs_in_dual_simplex
void clear_perturb_costs_in_dual_simplex()
Definition parameters.pb.h:2698
operations_research::glop::GlopParameters::random_seed
::int32_t random_seed() const
Definition parameters.pb.h:2617
operations_research::glop::GlopParameters::set_markowitz_zlatev_parameter
void set_markowitz_zlatev_parameter(::int32_t value)
Definition parameters.pb.h:2215
operations_research::glop::GlopParameters::has_markowitz_zlatev_parameter
bool has_markowitz_zlatev_parameter() const
Definition parameters.pb.h:2201
operations_research::glop::GlopParameters::clear_objective_lower_limit
void clear_objective_lower_limit()
Definition parameters.pb.h:2524
operations_research::glop::GlopParameters::SolverBehavior
GlopParameters_SolverBehavior SolverBehavior
Definition parameters.pb.h:431
operations_research::glop::GlopParameters::PricingRule_descriptor
static const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL PricingRule_descriptor()
Definition parameters.pb.h:462
operations_research::glop::GlopParameters::has_dynamically_adjust_refactorization_period
bool has_dynamically_adjust_refactorization_period() const
Definition parameters.pb.h:1879
operations_research::glop::GlopParameters::SolverBehavior_descriptor
static const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL SolverBehavior_descriptor()
Definition parameters.pb.h:441
operations_research::glop::GlopParameters::clear_dual_price_prioritize_norm
void clear_dual_price_prioritize_norm()
Definition parameters.pb.h:3046
operations_research::glop::GlopParameters::clear_relative_cost_perturbation
void clear_relative_cost_perturbation()
Definition parameters.pb.h:2756
operations_research::glop::GlopParameters::CostScalingAlgorithm_IsValid
static bool CostScalingAlgorithm_IsValid(int value)
Definition parameters.pb.h:500
operations_research::glop::GlopParameters::dual_feasibility_tolerance
double dual_feasibility_tolerance() const
Definition parameters.pb.h:1564
operations_research::glop::GlopParameters::crossover_bound_snapping_distance
double crossover_bound_snapping_distance() const
Definition parameters.pb.h:2907
operations_research::glop::GlopParameters::set_refactorization_threshold
void set_refactorization_threshold(double value)
Definition parameters.pb.h:1452
operations_research::glop::GlopParameters::set_cost_scaling
void set_cost_scaling(::operations_research::glop::GlopParameters_CostScalingAlgorithm value)
Definition parameters.pb.h:1771
operations_research::glop::GlopParameters::perturb_costs_in_dual_simplex
bool perturb_costs_in_dual_simplex() const
Definition parameters.pb.h:2704
operations_research::glop::GlopParameters::has_max_number_of_reoptimizations
bool has_max_number_of_reoptimizations() const
Definition parameters.pb.h:2056
operations_research::glop::GlopParameters::clear_drop_tolerance
void clear_drop_tolerance()
Definition parameters.pb.h:1703
operations_research::glop::GlopParameters::TRIANGULAR
static constexpr InitialBasisHeuristic TRIANGULAR
Definition parameters.pb.h:476
operations_research::glop::GlopParameters::set_dualizer_threshold
void set_dualizer_threshold(double value)
Definition parameters.pb.h:1954
operations_research::glop::GlopParameters::set_degenerate_ministep_factor
void set_degenerate_ministep_factor(double value)
Definition parameters.pb.h:2592
operations_research::glop::GlopParameters::clear_primal_feasibility_tolerance
void clear_primal_feasibility_tolerance()
Definition parameters.pb.h:1529
operations_research::glop::GlopParameters::set_random_seed
void set_random_seed(::int32_t value)
Definition parameters.pb.h:2621
operations_research::glop::GlopParameters::push_to_vertex
bool push_to_vertex() const
Definition parameters.pb.h:2936
operations_research::glop::GlopParameters::PricingRule
GlopParameters_PricingRule PricingRule
Definition parameters.pb.h:452
operations_research::glop::GlopParameters::IsInitialized
bool IsInitialized() const
Definition parameters.pb.h:357
operations_research::glop::GlopParameters::has_ratio_test_zero_threshold
bool has_ratio_test_zero_threshold() const
Definition parameters.pb.h:1583
operations_research::glop::GlopParameters::set_use_absl_random
void set_use_absl_random(bool value)
Definition parameters.pb.h:2650
operations_research::glop::GlopParameters::MEDIAN_COST_SCALING
static constexpr CostScalingAlgorithm MEDIAN_COST_SCALING
Definition parameters.pb.h:499
operations_research::glop::GlopParameters::dual_price_prioritize_norm
bool dual_price_prioritize_norm() const
Definition parameters.pb.h:3052
operations_research::glop::GlopParameters::has_small_pivot_threshold
bool has_small_pivot_threshold() const
Definition parameters.pb.h:1641
operations_research::glop::GlopParameters::has_initialize_devex_with_column_norms
bool has_initialize_devex_with_column_norms() const
Definition parameters.pb.h:2404
operations_research::glop::GlopParameters::dualizer_threshold
double dualizer_threshold() const
Definition parameters.pb.h:1950
operations_research::glop::GlopParameters::clear_log_to_stdout
void clear_log_to_stdout()
Definition parameters.pb.h:2872
operations_research::glop::GlopParameters::clear_cost_scaling
void clear_cost_scaling()
Definition parameters.pb.h:1761
operations_research::glop::GlopParameters::drop_magnitude
double drop_magnitude() const
Definition parameters.pb.h:3023
operations_research::glop::GlopParameters::InitialBasisHeuristic
GlopParameters_InitialBasisHeuristic InitialBasisHeuristic
Definition parameters.pb.h:473
operations_research::glop::GlopParameters::has_drop_magnitude
bool has_drop_magnitude() const
Definition parameters.pb.h:3013
operations_research::glop::GlopParameters::set_initialize_devex_with_column_norms
void set_initialize_devex_with_column_norms(bool value)
Definition parameters.pb.h:2418
operations_research::glop::GlopParameters::kUseImpliedFreePreprocessorFieldNumber
@ kUseImpliedFreePreprocessorFieldNumber
Definition parameters.pb.h:578
operations_research::glop::GlopParameters::kScalingMethodFieldNumber
@ kScalingMethodFieldNumber
Definition parameters.pb.h:563
operations_research::glop::GlopParameters::kHarrisToleranceRatioFieldNumber
@ kHarrisToleranceRatioFieldNumber
Definition parameters.pb.h:529
operations_research::glop::GlopParameters::kObjectiveLowerLimitFieldNumber
@ kObjectiveLowerLimitFieldNumber
Definition parameters.pb.h:558
operations_research::glop::GlopParameters::kMinimumAcceptablePivotFieldNumber
@ kMinimumAcceptablePivotFieldNumber
Definition parameters.pb.h:531
operations_research::glop::GlopParameters::kSolutionFeasibilityToleranceFieldNumber
@ kSolutionFeasibilityToleranceFieldNumber
Definition parameters.pb.h:539
operations_research::glop::GlopParameters::kMarkowitzSingularityThresholdFieldNumber
@ kMarkowitzSingularityThresholdFieldNumber
Definition parameters.pb.h:543
operations_research::glop::GlopParameters::kAllowSimplexAlgorithmChangeFieldNumber
@ kAllowSimplexAlgorithmChangeFieldNumber
Definition parameters.pb.h:547
operations_research::glop::GlopParameters::kObjectiveUpperLimitFieldNumber
@ kObjectiveUpperLimitFieldNumber
Definition parameters.pb.h:559
operations_research::glop::GlopParameters::kDualFeasibilityToleranceFieldNumber
@ kDualFeasibilityToleranceFieldNumber
Definition parameters.pb.h:527
operations_research::glop::GlopParameters::kPrimalFeasibilityToleranceFieldNumber
@ kPrimalFeasibilityToleranceFieldNumber
Definition parameters.pb.h:526
operations_research::glop::GlopParameters::kRandomSeedFieldNumber
@ kRandomSeedFieldNumber
Definition parameters.pb.h:562
operations_research::glop::GlopParameters::kLuFactorizationPivotThresholdFieldNumber
@ kLuFactorizationPivotThresholdFieldNumber
Definition parameters.pb.h:540
operations_research::glop::GlopParameters::kSmallPivotThresholdFieldNumber
@ kSmallPivotThresholdFieldNumber
Definition parameters.pb.h:530
operations_research::glop::GlopParameters::kLogToStdoutFieldNumber
@ kLogToStdoutFieldNumber
Definition parameters.pb.h:577
operations_research::glop::GlopParameters::kBasisRefactorizationPeriodFieldNumber
@ kBasisRefactorizationPeriodFieldNumber
Definition parameters.pb.h:533
operations_research::glop::GlopParameters::kInitializeDevexWithColumnNormsFieldNumber
@ kInitializeDevexWithColumnNormsFieldNumber
Definition parameters.pb.h:555
operations_research::glop::GlopParameters::kMaxNumberOfIterationsFieldNumber
@ kMaxNumberOfIterationsFieldNumber
Definition parameters.pb.h:542
operations_research::glop::GlopParameters::kMaxTimeInSecondsFieldNumber
@ kMaxTimeInSecondsFieldNumber
Definition parameters.pb.h:541
operations_research::glop::GlopParameters::kDynamicallyAdjustRefactorizationPeriodFieldNumber
@ kDynamicallyAdjustRefactorizationPeriodFieldNumber
Definition parameters.pb.h:572
operations_research::glop::GlopParameters::kDualSmallPivotThresholdFieldNumber
@ kDualSmallPivotThresholdFieldNumber
Definition parameters.pb.h:557
operations_research::glop::GlopParameters::kUsePreprocessingFieldNumber
@ kUsePreprocessingFieldNumber
Definition parameters.pb.h:553
operations_research::glop::GlopParameters::kInitialBasisFieldNumber
@ kInitialBasisFieldNumber
Definition parameters.pb.h:532
operations_research::glop::GlopParameters::kDualPricePrioritizeNormFieldNumber
@ kDualPricePrioritizeNormFieldNumber
Definition parameters.pb.h:550
operations_research::glop::GlopParameters::kCrossoverBoundSnappingDistanceFieldNumber
@ kCrossoverBoundSnappingDistanceFieldNumber
Definition parameters.pb.h:574
operations_research::glop::GlopParameters::kRelativeCostPerturbationFieldNumber
@ kRelativeCostPerturbationFieldNumber
Definition parameters.pb.h:565
operations_research::glop::GlopParameters::kPushToVertexFieldNumber
@ kPushToVertexFieldNumber
Definition parameters.pb.h:573
operations_research::glop::GlopParameters::kProvideStrongOptimalGuaranteeFieldNumber
@ kProvideStrongOptimalGuaranteeFieldNumber
Definition parameters.pb.h:536
operations_research::glop::GlopParameters::kLogSearchProgressFieldNumber
@ kLogSearchProgressFieldNumber
Definition parameters.pb.h:549
operations_research::glop::GlopParameters::kPerturbCostsInDualSimplexFieldNumber
@ kPerturbCostsInDualSimplexFieldNumber
Definition parameters.pb.h:548
operations_research::glop::GlopParameters::kDropMagnitudeFieldNumber
@ kDropMagnitudeFieldNumber
Definition parameters.pb.h:576
operations_research::glop::GlopParameters::kChangeStatusToImpreciseFieldNumber
@ kChangeStatusToImpreciseFieldNumber
Definition parameters.pb.h:570
operations_research::glop::GlopParameters::kDegenerateMinistepFactorFieldNumber
@ kDegenerateMinistepFactorFieldNumber
Definition parameters.pb.h:560
operations_research::glop::GlopParameters::kMaxValidMagnitudeFieldNumber
@ kMaxValidMagnitudeFieldNumber
Definition parameters.pb.h:575
operations_research::glop::GlopParameters::kExploitSingletonColumnInInitialBasisFieldNumber
@ kExploitSingletonColumnInInitialBasisFieldNumber
Definition parameters.pb.h:556
operations_research::glop::GlopParameters::kMaxNumberOfReoptimizationsFieldNumber
@ kMaxNumberOfReoptimizationsFieldNumber
Definition parameters.pb.h:567
operations_research::glop::GlopParameters::kMarkowitzZlatevParameterFieldNumber
@ kMarkowitzZlatevParameterFieldNumber
Definition parameters.pb.h:544
operations_research::glop::GlopParameters::kDropToleranceFieldNumber
@ kDropToleranceFieldNumber
Definition parameters.pb.h:564
operations_research::glop::GlopParameters::kMaxDeterministicTimeFieldNumber
@ kMaxDeterministicTimeFieldNumber
Definition parameters.pb.h:561
operations_research::glop::GlopParameters::kPreprocessorZeroToleranceFieldNumber
@ kPreprocessorZeroToleranceFieldNumber
Definition parameters.pb.h:546
operations_research::glop::GlopParameters::kRefactorizationThresholdFieldNumber
@ kRefactorizationThresholdFieldNumber
Definition parameters.pb.h:523
operations_research::glop::GlopParameters::kSolveDualProblemFieldNumber
@ kSolveDualProblemFieldNumber
Definition parameters.pb.h:537
operations_research::glop::GlopParameters::kUseScalingFieldNumber
@ kUseScalingFieldNumber
Definition parameters.pb.h:534
operations_research::glop::GlopParameters::kInitialConditionNumberThresholdFieldNumber
@ kInitialConditionNumberThresholdFieldNumber
Definition parameters.pb.h:568
operations_research::glop::GlopParameters::kUseMiddleProductFormUpdateFieldNumber
@ kUseMiddleProductFormUpdateFieldNumber
Definition parameters.pb.h:554
operations_research::glop::GlopParameters::kOptimizationRuleFieldNumber
@ kOptimizationRuleFieldNumber
Definition parameters.pb.h:522
operations_research::glop::GlopParameters::kDualizerThresholdFieldNumber
@ kDualizerThresholdFieldNumber
Definition parameters.pb.h:538
operations_research::glop::GlopParameters::kUseDedicatedDualFeasibilityAlgorithmFieldNumber
@ kUseDedicatedDualFeasibilityAlgorithmFieldNumber
Definition parameters.pb.h:571
operations_research::glop::GlopParameters::kRecomputeEdgesNormThresholdFieldNumber
@ kRecomputeEdgesNormThresholdFieldNumber
Definition parameters.pb.h:525
operations_research::glop::GlopParameters::kUseAbslRandomFieldNumber
@ kUseAbslRandomFieldNumber
Definition parameters.pb.h:551
operations_research::glop::GlopParameters::kCostScalingFieldNumber
@ kCostScalingFieldNumber
Definition parameters.pb.h:569
operations_research::glop::GlopParameters::kDevexWeightsResetPeriodFieldNumber
@ kDevexWeightsResetPeriodFieldNumber
Definition parameters.pb.h:552
operations_research::glop::GlopParameters::kRecomputeReducedCostsThresholdFieldNumber
@ kRecomputeReducedCostsThresholdFieldNumber
Definition parameters.pb.h:524
operations_research::glop::GlopParameters::kRatioTestZeroThresholdFieldNumber
@ kRatioTestZeroThresholdFieldNumber
Definition parameters.pb.h:528
operations_research::glop::GlopParameters::kNumOmpThreadsFieldNumber
@ kNumOmpThreadsFieldNumber
Definition parameters.pb.h:545
operations_research::glop::GlopParameters::kRelativeMaxCostPerturbationFieldNumber
@ kRelativeMaxCostPerturbationFieldNumber
Definition parameters.pb.h:566
operations_research::glop::GlopParameters::kUseTransposedMatrixFieldNumber
@ kUseTransposedMatrixFieldNumber
Definition parameters.pb.h:535
operations_research::glop::GlopParameters::set_use_dedicated_dual_feasibility_algorithm
void set_use_dedicated_dual_feasibility_algorithm(bool value)
Definition parameters.pb.h:2737
operations_research::glop::GlopParameters::small_pivot_threshold
double small_pivot_threshold() const
Definition parameters.pb.h:1651
operations_research::glop::GlopParameters::clear_markowitz_zlatev_parameter
void clear_markowitz_zlatev_parameter()
Definition parameters.pb.h:2205
operations_research::glop::GlopParameters::set_drop_tolerance
void set_drop_tolerance(double value)
Definition parameters.pb.h:1713
operations_research::glop::GlopParameters::set_markowitz_singularity_threshold
void set_markowitz_singularity_threshold(double value)
Definition parameters.pb.h:2244
operations_research::glop::GlopParameters::has_primal_feasibility_tolerance
bool has_primal_feasibility_tolerance() const
Definition parameters.pb.h:1525
operations_research::glop::GlopParameters::initial_condition_number_threshold
double initial_condition_number_threshold() const
Definition parameters.pb.h:2820
operations_research::glop::GlopParameters::MAROS
static constexpr InitialBasisHeuristic MAROS
Definition parameters.pb.h:477
operations_research::glop::GlopParameters::clear_provide_strong_optimal_guarantee
void clear_provide_strong_optimal_guarantee()
Definition parameters.pb.h:2002
operations_research::glop::GlopParameters::solve_dual_problem
::operations_research::glop::GlopParameters_SolverBehavior solve_dual_problem() const
Definition parameters.pb.h:1918
operations_research::glop::GlopParameters::recompute_reduced_costs_threshold
double recompute_reduced_costs_threshold() const
Definition parameters.pb.h:1477
operations_research::glop::GlopParameters::clear_log_search_progress
void clear_log_search_progress()
Definition parameters.pb.h:2843
operations_research::glop::GlopParameters::has_dualizer_threshold
bool has_dualizer_threshold() const
Definition parameters.pb.h:1940
operations_research::glop::GlopParameters::max_deterministic_time
double max_deterministic_time() const
Definition parameters.pb.h:2153
operations_research::glop::GlopParameters::has_relative_max_cost_perturbation
bool has_relative_max_cost_perturbation() const
Definition parameters.pb.h:2781
operations_research::glop::GlopParameters::CostScalingAlgorithm_descriptor
static const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL CostScalingAlgorithm_descriptor()
Definition parameters.pb.h:506
operations_research::glop::GlopParameters::clear_initial_condition_number_threshold
void clear_initial_condition_number_threshold()
Definition parameters.pb.h:2814
operations_research::glop::GlopParameters::has_refactorization_threshold
bool has_refactorization_threshold() const
Definition parameters.pb.h:1438
operations_research::glop::GlopParameters::set_minimum_acceptable_pivot
void set_minimum_acceptable_pivot(double value)
Definition parameters.pb.h:1684
operations_research::glop::GlopParameters::clear_use_dual_simplex
void clear_use_dual_simplex()
Definition parameters.pb.h:2263
operations_research::glop::GlopParameters::solution_feasibility_tolerance
double solution_feasibility_tolerance() const
Definition parameters.pb.h:1979
operations_research::glop::GlopParameters::set_harris_tolerance_ratio
void set_harris_tolerance_ratio(double value)
Definition parameters.pb.h:1626
operations_research::glop::GlopParameters::recompute_edges_norm_threshold
double recompute_edges_norm_threshold() const
Definition parameters.pb.h:1506
operations_research::glop::GlopParameters::dual_small_pivot_threshold
double dual_small_pivot_threshold() const
Definition parameters.pb.h:2472
operations_research::glop::GlopParameters::set_use_transposed_matrix
void set_use_transposed_matrix(bool value)
Definition parameters.pb.h:1835
operations_research::glop::GlopParameters::clear_solve_dual_problem
void clear_solve_dual_problem()
Definition parameters.pb.h:1912
operations_research::glop::GlopParameters::set_max_number_of_reoptimizations
void set_max_number_of_reoptimizations(double value)
Definition parameters.pb.h:2070
operations_research::glop::GlopParameters::set_use_dual_simplex
void set_use_dual_simplex(bool value)
Definition parameters.pb.h:2273
operations_research::glop::GlopParameters::has_max_time_in_seconds
bool has_max_time_in_seconds() const
Definition parameters.pb.h:2114
operations_research::glop::GlopParameters::optimization_rule
::operations_research::glop::GlopParameters_PricingRule optimization_rule() const
Definition parameters.pb.h:1416
operations_research::glop::GlopParameters::minimum_acceptable_pivot
double minimum_acceptable_pivot() const
Definition parameters.pb.h:1680
operations_research::glop::GlopParameters::basis_refactorization_period
::int32_t basis_refactorization_period() const
Definition parameters.pb.h:1860
operations_research::glop::GlopParameters::GlopParameters
GlopParameters()
Definition parameters.pb.h:274
operations_research::glop::GlopParameters::ScalingAlgorithm_IsValid
static bool ScalingAlgorithm_IsValid(int value)
Definition parameters.pb.h:414
operations_research::glop::GlopParameters::set_lu_factorization_pivot_threshold
void set_lu_factorization_pivot_threshold(double value)
Definition parameters.pb.h:2099
operations_research::glop::GlopParameters::set_preprocessor_zero_tolerance
void set_preprocessor_zero_tolerance(double value)
Definition parameters.pb.h:2505
operations_research::glop::GlopParameters::set_ratio_test_zero_threshold
void set_ratio_test_zero_threshold(double value)
Definition parameters.pb.h:1597
operations_research::glop::GlopParameters::has_basis_refactorization_period
bool has_basis_refactorization_period() const
Definition parameters.pb.h:1850
operations_research::glop::GlopParameters::use_dual_simplex
bool use_dual_simplex() const
Definition parameters.pb.h:2269
operations_research::glop::GlopParameters::set_dual_price_prioritize_norm
void set_dual_price_prioritize_norm(bool value)
Definition parameters.pb.h:3056
operations_research::glop::GlopParameters::CostScalingAlgorithm
GlopParameters_CostScalingAlgorithm CostScalingAlgorithm
Definition parameters.pb.h:495
operations_research::glop::GlopParameters::use_transposed_matrix
bool use_transposed_matrix() const
Definition parameters.pb.h:1831
operations_research::glop::GlopParameters::has_perturb_costs_in_dual_simplex
bool has_perturb_costs_in_dual_simplex() const
Definition parameters.pb.h:2694
operations_research::glop::GlopParameters::clear_optimization_rule
void clear_optimization_rule()
Definition parameters.pb.h:1410
operations_research::glop::GlopParameters::clear_preprocessor_zero_tolerance
void clear_preprocessor_zero_tolerance()
Definition parameters.pb.h:2495
operations_research::glop::GlopParameters::max_number_of_reoptimizations
double max_number_of_reoptimizations() const
Definition parameters.pb.h:2066
operations_research::glop::GlopParameters::clear_use_transposed_matrix
void clear_use_transposed_matrix()
Definition parameters.pb.h:1825
operations_research::glop::GlopParameters::max_valid_magnitude
double max_valid_magnitude() const
Definition parameters.pb.h:2994
operations_research::glop::GlopParameters::relative_cost_perturbation
double relative_cost_perturbation() const
Definition parameters.pb.h:2762
operations_research::glop::GlopParameters::has_lu_factorization_pivot_threshold
bool has_lu_factorization_pivot_threshold() const
Definition parameters.pb.h:2085
operations_research::glop::GlopParameters::set_initial_condition_number_threshold
void set_initial_condition_number_threshold(double value)
Definition parameters.pb.h:2824
operations_research::glop::GlopParameters::clear_markowitz_singularity_threshold
void clear_markowitz_singularity_threshold()
Definition parameters.pb.h:2234
operations_research::glop::GlopParameters::objective_lower_limit
double objective_lower_limit() const
Definition parameters.pb.h:2530
operations_research::glop::GlopParameters::InitialBasisHeuristic_IsValid
static bool InitialBasisHeuristic_IsValid(int value)
Definition parameters.pb.h:478
operations_research::glop::GlopParameters::has_dual_price_prioritize_norm
bool has_dual_price_prioritize_norm() const
Definition parameters.pb.h:3042
operations_research::glop::GlopParameters::objective_upper_limit
double objective_upper_limit() const
Definition parameters.pb.h:2559
operations_research::glop::GlopParameters::has_max_number_of_iterations
bool has_max_number_of_iterations() const
Definition parameters.pb.h:2172
operations_research::glop::GlopParameters::has_use_implied_free_preprocessor
bool has_use_implied_free_preprocessor() const
Definition parameters.pb.h:2955
operations_research::glop::GlopParameters::drop_tolerance
double drop_tolerance() const
Definition parameters.pb.h:1709
operations_research::glop::GlopParameters::primal_feasibility_tolerance
double primal_feasibility_tolerance() const
Definition parameters.pb.h:1535
operations_research::glop::GlopParameters::set_exploit_singleton_column_in_initial_basis
void set_exploit_singleton_column_in_initial_basis(bool value)
Definition parameters.pb.h:2447
operations_research::glop::GlopParameters::has_use_absl_random
bool has_use_absl_random() const
Definition parameters.pb.h:2636
operations_research::glop::GlopParameters::initial_basis
::operations_research::glop::GlopParameters_InitialBasisHeuristic initial_basis() const
Definition parameters.pb.h:1799
operations_research::glop::GlopParameters::set_max_time_in_seconds
void set_max_time_in_seconds(double value)
Definition parameters.pb.h:2128
operations_research::glop::GlopParameters::set_change_status_to_imprecise
void set_change_status_to_imprecise(bool value)
Definition parameters.pb.h:2041
operations_research::glop::GlopParameters::clear_refactorization_threshold
void clear_refactorization_threshold()
Definition parameters.pb.h:1442
operations_research::glop::GlopParameters::clear_max_number_of_iterations
void clear_max_number_of_iterations()
Definition parameters.pb.h:2176
operations_research::glop::GlopParameters::clear_solution_feasibility_tolerance
void clear_solution_feasibility_tolerance()
Definition parameters.pb.h:1973
operations_research::glop::GlopParameters::has_dual_small_pivot_threshold
bool has_dual_small_pivot_threshold() const
Definition parameters.pb.h:2462
operations_research::glop::GlopParameters::has_dual_feasibility_tolerance
bool has_dual_feasibility_tolerance() const
Definition parameters.pb.h:1554
operations_research::glop::GlopParameters::has_push_to_vertex
bool has_push_to_vertex() const
Definition parameters.pb.h:2926
operations_research::glop::GlopParameters::clear_dualizer_threshold
void clear_dualizer_threshold()
Definition parameters.pb.h:1944
operations_research::glop::GlopParameters::clear_use_scaling
void clear_use_scaling()
Definition parameters.pb.h:1732
operations_research::glop::GlopParameters::cost_scaling
::operations_research::glop::GlopParameters_CostScalingAlgorithm cost_scaling() const
Definition parameters.pb.h:1767
operations_research::glop::GlopParameters::CONTAIN_ONE_COST_SCALING
static constexpr CostScalingAlgorithm CONTAIN_ONE_COST_SCALING
Definition parameters.pb.h:497
operations_research::glop::GlopParameters::set_recompute_reduced_costs_threshold
void set_recompute_reduced_costs_threshold(double value)
Definition parameters.pb.h:1481
operations_research::glop::GlopParameters::clear_max_time_in_seconds
void clear_max_time_in_seconds()
Definition parameters.pb.h:2118
operations_research::glop::GlopParameters::has_use_dedicated_dual_feasibility_algorithm
bool has_use_dedicated_dual_feasibility_algorithm() const
Definition parameters.pb.h:2723
operations_research::glop::GlopParameters::set_devex_weights_reset_period
void set_devex_weights_reset_period(::int32_t value)
Definition parameters.pb.h:2331
operations_research::glop::GlopParameters::clear_dual_small_pivot_threshold
void clear_dual_small_pivot_threshold()
Definition parameters.pb.h:2466
operations_research::glop::GlopParameters::clear_max_number_of_reoptimizations
void clear_max_number_of_reoptimizations()
Definition parameters.pb.h:2060
operations_research::glop::GlopParameters::set_recompute_edges_norm_threshold
void set_recompute_edges_norm_threshold(double value)
Definition parameters.pb.h:1510
operations_research::glop::GlopParameters::has_allow_simplex_algorithm_change
bool has_allow_simplex_algorithm_change() const
Definition parameters.pb.h:2288
operations_research::glop::GlopParameters::has_devex_weights_reset_period
bool has_devex_weights_reset_period() const
Definition parameters.pb.h:2317
operations_research::glop::GlopParameters::clear_allow_simplex_algorithm_change
void clear_allow_simplex_algorithm_change()
Definition parameters.pb.h:2292
operations_research::glop::GlopParameters::dynamically_adjust_refactorization_period
bool dynamically_adjust_refactorization_period() const
Definition parameters.pb.h:1889
operations_research::glop::GlopParameters::MEAN_COST_SCALING
static constexpr CostScalingAlgorithm MEAN_COST_SCALING
Definition parameters.pb.h:498
operations_research::glop::GlopParameters::CopyFrom
void CopyFrom(const GlopParameters &from)
Definition parameters.pb.cc:1665
operations_research::glop::GlopParameters::scaling_method
::operations_research::glop::GlopParameters_ScalingAlgorithm scaling_method() const
Definition parameters.pb.h:1352
operations_research::glop::GlopParameters::max_number_of_iterations
::int64_t max_number_of_iterations() const
Definition parameters.pb.h:2182
operations_research::glop::GlopParameters::lu_factorization_pivot_threshold
double lu_factorization_pivot_threshold() const
Definition parameters.pb.h:2095
operations_research::glop::GlopParameters::SolverBehavior_ARRAYSIZE
static constexpr int SolverBehavior_ARRAYSIZE
Definition parameters.pb.h:440
operations_research::glop::GlopParameters::has_recompute_edges_norm_threshold
bool has_recompute_edges_norm_threshold() const
Definition parameters.pb.h:1496
operations_research::glop::GlopParameters::has_use_dual_simplex
bool has_use_dual_simplex() const
Definition parameters.pb.h:2259
operations_research::glop::GlopParameters::clear_initialize_devex_with_column_norms
void clear_initialize_devex_with_column_norms()
Definition parameters.pb.h:2408
operations_research::glop::GlopParameters::set_dynamically_adjust_refactorization_period
void set_dynamically_adjust_refactorization_period(bool value)
Definition parameters.pb.h:1893
operations_research::glop::GlopParameters::has_cost_scaling
bool has_cost_scaling() const
Definition parameters.pb.h:1757
operations_research::glop::GlopParameters::has_markowitz_singularity_threshold
bool has_markowitz_singularity_threshold() const
Definition parameters.pb.h:2230
operations_research::glop::GlopParameters::has_log_to_stdout
bool has_log_to_stdout() const
Definition parameters.pb.h:2868
operations_research::glop::GlopParameters::set_max_number_of_iterations
void set_max_number_of_iterations(::int64_t value)
Definition parameters.pb.h:2186
operations_research::glop::GlopParameters::exploit_singleton_column_in_initial_basis
bool exploit_singleton_column_in_initial_basis() const
Definition parameters.pb.h:2443
operations_research::glop::GlopParameters::set_primal_feasibility_tolerance
void set_primal_feasibility_tolerance(double value)
Definition parameters.pb.h:1539
operations_research::glop::GlopParameters::has_max_valid_magnitude
bool has_max_valid_magnitude() const
Definition parameters.pb.h:2984
operations_research::glop::GlopParameters::has_initial_condition_number_threshold
bool has_initial_condition_number_threshold() const
Definition parameters.pb.h:2810
operations_research::glop::GlopParameters::set_use_middle_product_form_update
void set_use_middle_product_form_update(bool value)
Definition parameters.pb.h:2389
operations_research::glop::GlopParameters::clear_change_status_to_imprecise
void clear_change_status_to_imprecise()
Definition parameters.pb.h:2031
operations_research::glop::GlopParameters::set_push_to_vertex
void set_push_to_vertex(bool value)
Definition parameters.pb.h:2940
operations_research::glop::GlopParameters::has_degenerate_ministep_factor
bool has_degenerate_ministep_factor() const
Definition parameters.pb.h:2578
operations_research::glop::GlopParameters::clear_objective_upper_limit
void clear_objective_upper_limit()
Definition parameters.pb.h:2553
operations_research::glop::GlopParameters::set_small_pivot_threshold
void set_small_pivot_threshold(double value)
Definition parameters.pb.h:1655
operations_research::glop::GlopParameters::set_basis_refactorization_period
void set_basis_refactorization_period(::int32_t value)
Definition parameters.pb.h:1864
operations_research::glop::GlopParameters::log_search_progress
bool log_search_progress() const
Definition parameters.pb.h:2849
operations_research::glop::GlopParameters::PricingRule_ARRAYSIZE
static constexpr int PricingRule_ARRAYSIZE
Definition parameters.pb.h:461
operations_research::glop::GlopParameters::use_dedicated_dual_feasibility_algorithm
bool use_dedicated_dual_feasibility_algorithm() const
Definition parameters.pb.h:2733
operations_research::glop::GlopParameters::has_use_preprocessing
bool has_use_preprocessing() const
Definition parameters.pb.h:2346
operations_research::glop::GlopParameters::set_objective_upper_limit
void set_objective_upper_limit(double value)
Definition parameters.pb.h:2563
operations_research::glop::GlopParameters::ScalingAlgorithm_ARRAYSIZE
static constexpr int ScalingAlgorithm_ARRAYSIZE
Definition parameters.pb.h:419
operations_research::glop::GlopParameters::set_perturb_costs_in_dual_simplex
void set_perturb_costs_in_dual_simplex(bool value)
Definition parameters.pb.h:2708
operations_research::glop::GlopParameters::has_solution_feasibility_tolerance
bool has_solution_feasibility_tolerance() const
Definition parameters.pb.h:1969
operations_research::glop::GlopParameters::set_log_search_progress
void set_log_search_progress(bool value)
Definition parameters.pb.h:2853
operations_research::glop::GlopParameters::has_use_middle_product_form_update
bool has_use_middle_product_form_update() const
Definition parameters.pb.h:2375
operations_research::glop::GlopParameters::clear_harris_tolerance_ratio
void clear_harris_tolerance_ratio()
Definition parameters.pb.h:1616
operations_research::glop::GlopParameters::clear_drop_magnitude
void clear_drop_magnitude()
Definition parameters.pb.h:3017
operations_research::glop::GlopParameters::clear_use_middle_product_form_update
void clear_use_middle_product_form_update()
Definition parameters.pb.h:2379
operations_research::glop::GlopParameters::clear_use_implied_free_preprocessor
void clear_use_implied_free_preprocessor()
Definition parameters.pb.h:2959
operations_research::glop::GlopParameters::allow_simplex_algorithm_change
bool allow_simplex_algorithm_change() const
Definition parameters.pb.h:2298
operations_research::glop::GlopParameters::set_use_scaling
void set_use_scaling(bool value)
Definition parameters.pb.h:1742
operations_research::glop::GlopParameters::has_change_status_to_imprecise
bool has_change_status_to_imprecise() const
Definition parameters.pb.h:2027
operations_research::glop::GlopParameters::set_use_preprocessing
void set_use_preprocessing(bool value)
Definition parameters.pb.h:2360
operations_research::glop::GlopParameters::set_dual_feasibility_tolerance
void set_dual_feasibility_tolerance(double value)
Definition parameters.pb.h:1568
operations_research::glop::GlopParameters::set_dual_small_pivot_threshold
void set_dual_small_pivot_threshold(double value)
Definition parameters.pb.h:2476
operations_research::glop::GlopParameters::has_harris_tolerance_ratio
bool has_harris_tolerance_ratio() const
Definition parameters.pb.h:1612
operations_research::glop::GlopParameters::clear_relative_max_cost_perturbation
void clear_relative_max_cost_perturbation()
Definition parameters.pb.h:2785
operations_research::glop::GlopParameters::has_relative_cost_perturbation
bool has_relative_cost_perturbation() const
Definition parameters.pb.h:2752
operations_research::glop::GlopParameters::clear_minimum_acceptable_pivot
void clear_minimum_acceptable_pivot()
Definition parameters.pb.h:1674
descriptor_table_ortools_2fglop_2fparameters_2eproto
PROTOBUF_CONSTINITconst ::_pbi::DescriptorTable descriptor_table_ortools_2fglop_2fparameters_2eproto
Definition parameters.pb.cc:338
google::protobuf::internal::GetAnyMessageName
::absl::string_view GetAnyMessageName()
google::protobuf::GetEnumDescriptor<::operations_research::glop::GlopParameters_SolverBehavior >
const EnumDescriptor *PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_SolverBehavior >()
Definition parameters.pb.h:3091
google::protobuf::GetEnumDescriptor<::operations_research::glop::GlopParameters_ScalingAlgorithm >
const EnumDescriptor *PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_ScalingAlgorithm >()
Definition parameters.pb.h:3085
google::protobuf::GetEnumDescriptor<::operations_research::glop::GlopParameters_PricingRule >
const EnumDescriptor *PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_PricingRule >()
Definition parameters.pb.h:3097
google::protobuf::GetEnumDescriptor<::operations_research::glop::GlopParameters_InitialBasisHeuristic >
const EnumDescriptor *PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_InitialBasisHeuristic >()
Definition parameters.pb.h:3103
google::protobuf::GetEnumDescriptor<::operations_research::glop::GlopParameters_CostScalingAlgorithm >
const EnumDescriptor *PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_CostScalingAlgorithm >()
Definition parameters.pb.h:3109
operations_research::glop
Definition basis_representation.cc:25
operations_research::glop::GlopParameters_CostScalingAlgorithm
GlopParameters_CostScalingAlgorithm
Definition parameters.pb.h:229
operations_research::glop::GlopParameters_CostScalingAlgorithm_NO_COST_SCALING
@ GlopParameters_CostScalingAlgorithm_NO_COST_SCALING
Definition parameters.pb.h:230
operations_research::glop::GlopParameters_CostScalingAlgorithm_CONTAIN_ONE_COST_SCALING
@ GlopParameters_CostScalingAlgorithm_CONTAIN_ONE_COST_SCALING
Definition parameters.pb.h:231
operations_research::glop::GlopParameters_CostScalingAlgorithm_MEAN_COST_SCALING
@ GlopParameters_CostScalingAlgorithm_MEAN_COST_SCALING
Definition parameters.pb.h:232
operations_research::glop::GlopParameters_CostScalingAlgorithm_MEDIAN_COST_SCALING
@ GlopParameters_CostScalingAlgorithm_MEDIAN_COST_SCALING
Definition parameters.pb.h:233
operations_research::glop::GlopParameters_ScalingAlgorithm_ScalingAlgorithm_ARRAYSIZE
constexpr int GlopParameters_ScalingAlgorithm_ScalingAlgorithm_ARRAYSIZE
Definition parameters.pb.h:110
operations_research::glop::GlopParameters_ScalingAlgorithm_internal_data_
PROTOBUF_CONSTINIT const uint32_t GlopParameters_ScalingAlgorithm_internal_data_[]
Definition parameters.pb.cc:360
operations_research::glop::GlopParameters_InitialBasisHeuristic_Name
const ::std::string & GlopParameters_InitialBasisHeuristic_Name(T value)
Definition parameters.pb.h:213
operations_research::glop::GlopParameters_SolverBehavior_Parse
bool GlopParameters_SolverBehavior_Parse(::absl::string_view name, GlopParameters_SolverBehavior *PROTOBUF_NONNULL value)
Definition parameters.pb.h:157
operations_research::glop::GlopParameters_PricingRule_internal_data_
PROTOBUF_CONSTINIT const uint32_t GlopParameters_PricingRule_internal_data_[]
Definition parameters.pb.cc:372
operations_research::glop::GlopParameters_PricingRule
GlopParameters_PricingRule
Definition parameters.pb.h:162
operations_research::glop::GlopParameters_PricingRule_DANTZIG
@ GlopParameters_PricingRule_DANTZIG
Definition parameters.pb.h:163
operations_research::glop::GlopParameters_PricingRule_STEEPEST_EDGE
@ GlopParameters_PricingRule_STEEPEST_EDGE
Definition parameters.pb.h:164
operations_research::glop::GlopParameters_PricingRule_DEVEX
@ GlopParameters_PricingRule_DEVEX
Definition parameters.pb.h:165
operations_research::glop::GlopParameters_ScalingAlgorithm_Name
const ::std::string & GlopParameters_ScalingAlgorithm_Name(T value)
Definition parameters.pb.h:113
operations_research::glop::GlopParameters_SolverBehavior_SolverBehavior_MAX
constexpr GlopParameters_SolverBehavior GlopParameters_SolverBehavior_SolverBehavior_MAX
Definition parameters.pb.h:138
operations_research::glop::GlopParameters_PricingRule_Parse
bool GlopParameters_PricingRule_Parse(::absl::string_view name, GlopParameters_PricingRule *PROTOBUF_NONNULL value)
Definition parameters.pb.h:190
operations_research::glop::GlopParameters_InitialBasisHeuristic
GlopParameters_InitialBasisHeuristic
Definition parameters.pb.h:195
operations_research::glop::GlopParameters_InitialBasisHeuristic_MAROS
@ GlopParameters_InitialBasisHeuristic_MAROS
Definition parameters.pb.h:199
operations_research::glop::GlopParameters_InitialBasisHeuristic_TRIANGULAR
@ GlopParameters_InitialBasisHeuristic_TRIANGULAR
Definition parameters.pb.h:198
operations_research::glop::GlopParameters_InitialBasisHeuristic_BIXBY
@ GlopParameters_InitialBasisHeuristic_BIXBY
Definition parameters.pb.h:197
operations_research::glop::GlopParameters_InitialBasisHeuristic_NONE
@ GlopParameters_InitialBasisHeuristic_NONE
Definition parameters.pb.h:196
operations_research::glop::GlopParameters_InitialBasisHeuristic_descriptor
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL GlopParameters_InitialBasisHeuristic_descriptor()
Definition parameters.pb.cc:374
operations_research::glop::GlopParameters_SolverBehavior_SolverBehavior_MIN
constexpr GlopParameters_SolverBehavior GlopParameters_SolverBehavior_SolverBehavior_MIN
Definition parameters.pb.h:136
operations_research::glop::GlopParameters_CostScalingAlgorithm_IsValid
bool GlopParameters_CostScalingAlgorithm_IsValid(int value)
Definition parameters.pb.h:241
operations_research::glop::GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_ARRAYSIZE
constexpr int GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_ARRAYSIZE
Definition parameters.pb.h:210
operations_research::glop::GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_MAX
constexpr GlopParameters_InitialBasisHeuristic GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_MAX
Definition parameters.pb.h:205
operations_research::glop::GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_MIN
constexpr GlopParameters_CostScalingAlgorithm GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_MIN
Definition parameters.pb.h:237
operations_research::glop::GlopParameters_SolverBehavior_SolverBehavior_ARRAYSIZE
constexpr int GlopParameters_SolverBehavior_SolverBehavior_ARRAYSIZE
Definition parameters.pb.h:143
operations_research::glop::GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_MIN
constexpr GlopParameters_InitialBasisHeuristic GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_MIN
Definition parameters.pb.h:203
operations_research::glop::GlopParameters_PricingRule_descriptor
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL GlopParameters_PricingRule_descriptor()
Definition parameters.pb.cc:368
operations_research::glop::GlopParameters_ScalingAlgorithm
GlopParameters_ScalingAlgorithm
Definition parameters.pb.h:96
operations_research::glop::GlopParameters_ScalingAlgorithm_EQUILIBRATION
@ GlopParameters_ScalingAlgorithm_EQUILIBRATION
Definition parameters.pb.h:98
operations_research::glop::GlopParameters_ScalingAlgorithm_LINEAR_PROGRAM
@ GlopParameters_ScalingAlgorithm_LINEAR_PROGRAM
Definition parameters.pb.h:99
operations_research::glop::GlopParameters_ScalingAlgorithm_DEFAULT
@ GlopParameters_ScalingAlgorithm_DEFAULT
Definition parameters.pb.h:97
operations_research::glop::GlopParameters_ScalingAlgorithm_ScalingAlgorithm_MIN
constexpr GlopParameters_ScalingAlgorithm GlopParameters_ScalingAlgorithm_ScalingAlgorithm_MIN
Definition parameters.pb.h:103
operations_research::glop::GlopParameters_CostScalingAlgorithm_internal_data_
PROTOBUF_CONSTINIT const uint32_t GlopParameters_CostScalingAlgorithm_internal_data_[]
Definition parameters.pb.cc:384
operations_research::glop::GlopParameters_SolverBehavior
GlopParameters_SolverBehavior
Definition parameters.pb.h:129
operations_research::glop::GlopParameters_SolverBehavior_ALWAYS_DO
@ GlopParameters_SolverBehavior_ALWAYS_DO
Definition parameters.pb.h:130
operations_research::glop::GlopParameters_SolverBehavior_LET_SOLVER_DECIDE
@ GlopParameters_SolverBehavior_LET_SOLVER_DECIDE
Definition parameters.pb.h:132
operations_research::glop::GlopParameters_SolverBehavior_NEVER_DO
@ GlopParameters_SolverBehavior_NEVER_DO
Definition parameters.pb.h:131
operations_research::glop::GlopParameters_PricingRule_Name
const ::std::string & GlopParameters_PricingRule_Name(T value)
Definition parameters.pb.h:179
operations_research::glop::GlopParameters_ScalingAlgorithm_ScalingAlgorithm_MAX
constexpr GlopParameters_ScalingAlgorithm GlopParameters_ScalingAlgorithm_ScalingAlgorithm_MAX
Definition parameters.pb.h:105
operations_research::glop::GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_ARRAYSIZE
constexpr int GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_ARRAYSIZE
Definition parameters.pb.h:244
operations_research::glop::GlopParameters_PricingRule_PricingRule_MAX
constexpr GlopParameters_PricingRule GlopParameters_PricingRule_PricingRule_MAX
Definition parameters.pb.h:171
operations_research::glop::GlopParameters_InitialBasisHeuristic_IsValid
bool GlopParameters_InitialBasisHeuristic_IsValid(int value)
Definition parameters.pb.h:207
operations_research::glop::GlopParameters_ScalingAlgorithm_Parse
bool GlopParameters_ScalingAlgorithm_Parse(::absl::string_view name, GlopParameters_ScalingAlgorithm *PROTOBUF_NONNULL value)
Definition parameters.pb.h:124
operations_research::glop::GlopParameters_SolverBehavior_internal_data_
PROTOBUF_CONSTINIT const uint32_t GlopParameters_SolverBehavior_internal_data_[]
Definition parameters.pb.cc:366
operations_research::glop::GlopParameters_CostScalingAlgorithm_Name
const ::std::string & GlopParameters_CostScalingAlgorithm_Name(T value)
Definition parameters.pb.h:247
operations_research::glop::GlopParameters_CostScalingAlgorithm_Parse
bool GlopParameters_CostScalingAlgorithm_Parse(::absl::string_view name, GlopParameters_CostScalingAlgorithm *PROTOBUF_NONNULL value)
Definition parameters.pb.h:258
operations_research::glop::GlopParameters_InitialBasisHeuristic_Parse
bool GlopParameters_InitialBasisHeuristic_Parse(::absl::string_view name, GlopParameters_InitialBasisHeuristic *PROTOBUF_NONNULL value)
Definition parameters.pb.h:224
operations_research::glop::_GlopParameters_default_instance_
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GlopParametersDefaultTypeInternal _GlopParameters_default_instance_
Definition parameters.pb.cc:111
operations_research::glop::GlopParameters_SolverBehavior_IsValid
bool GlopParameters_SolverBehavior_IsValid(int value)
Definition parameters.pb.h:140
operations_research::glop::GlopParameters_ScalingAlgorithm_descriptor
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL GlopParameters_ScalingAlgorithm_descriptor()
Definition parameters.pb.cc:356
operations_research::glop::GlopParameters_CostScalingAlgorithm_descriptor
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL GlopParameters_CostScalingAlgorithm_descriptor()
Definition parameters.pb.cc:380
operations_research::glop::GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_MAX
constexpr GlopParameters_CostScalingAlgorithm GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_MAX
Definition parameters.pb.h:239
operations_research::glop::GlopParameters_PricingRule_IsValid
bool GlopParameters_PricingRule_IsValid(int value)
Definition parameters.pb.h:173
operations_research::glop::GlopParameters_ScalingAlgorithm_IsValid
bool GlopParameters_ScalingAlgorithm_IsValid(int value)
Definition parameters.pb.h:107
operations_research::glop::GlopParameters_PricingRule_PricingRule_MIN
constexpr GlopParameters_PricingRule GlopParameters_PricingRule_PricingRule_MIN
Definition parameters.pb.h:169
operations_research::glop::GlopParameters_PricingRule_PricingRule_ARRAYSIZE
constexpr int GlopParameters_PricingRule_PricingRule_ARRAYSIZE
Definition parameters.pb.h:176
operations_research::glop::GlopParameters_SolverBehavior_descriptor
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL GlopParameters_SolverBehavior_descriptor()
Definition parameters.pb.cc:362
operations_research::glop::GlopParameters_class_data_
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const::google::protobuf::internal::ClassDataFull GlopParameters_class_data_
Definition parameters.pb.cc:532
operations_research::glop::GlopParameters_InitialBasisHeuristic_internal_data_
PROTOBUF_CONSTINIT const uint32_t GlopParameters_InitialBasisHeuristic_internal_data_[]
Definition parameters.pb.cc:378
operations_research::glop::GlopParameters_SolverBehavior_Name
const ::std::string & GlopParameters_SolverBehavior_Name(T value)
Definition parameters.pb.h:146
operations_research
OR-Tools root namespace.
Definition binary_indexed_tree.h:21
TableStruct_ortools_2fglop_2fparameters_2eproto
Definition parameters.pb.h:50
TableStruct_ortools_2fglop_2fparameters_2eproto::offsets
static const ::uint32_t offsets[]
Definition parameters.pb.h:51
operations_research::glop::GlopParametersDefaultTypeInternal
Definition parameters.pb.cc:102