6#ifndef ortools_2fglop_2fparameters_2eproto_2epb_2eh
7#define ortools_2fglop_2fparameters_2eproto_2epb_2eh
14#include "google/protobuf/runtime_version.h"
15#if PROTOBUF_VERSION != 6031001
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"
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"
30#include "google/protobuf/extension_set.h"
31#include "google/protobuf/generated_enum_reflection.h"
32#include "google/protobuf/unknown_field_set.h"
36#include "google/protobuf/port_def.inc"
38#define PROTOBUF_INTERNAL_EXPORT_ortools_2fglop_2fparameters_2eproto OR_PROTO_DLL
77internal::EnumTraitsT<::operations_research::glop::GlopParameters_CostScalingAlgorithm_internal_data_>
78 internal::EnumTraitsImpl::value<::operations_research::glop::GlopParameters_CostScalingAlgorithm>;
80internal::EnumTraitsT<::operations_research::glop::GlopParameters_InitialBasisHeuristic_internal_data_>
81 internal::EnumTraitsImpl::value<::operations_research::glop::GlopParameters_InitialBasisHeuristic>;
83internal::EnumTraitsT<::operations_research::glop::GlopParameters_PricingRule_internal_data_>
84 internal::EnumTraitsImpl::value<::operations_research::glop::GlopParameters_PricingRule>;
86internal::EnumTraitsT<::operations_research::glop::GlopParameters_ScalingAlgorithm_internal_data_>
87 internal::EnumTraitsImpl::value<::operations_research::glop::GlopParameters_ScalingAlgorithm>;
89internal::EnumTraitsT<::operations_research::glop::GlopParameters_SolverBehavior_internal_data_>
90 internal::EnumTraitsImpl::value<::operations_research::glop::GlopParameters_SolverBehavior>;
108 return 0 <= value && value <= 2;
114 static_assert(::std::is_same<T, GlopParameters_ScalingAlgorithm>::value ||
115 ::std::is_integral<T>::value,
116 "Incorrect type passed to ScalingAlgorithm_Name().");
121 return ::google::protobuf::internal::NameOfDenseEnum<GlopParameters_ScalingAlgorithm_descriptor, 0, 2>(
122 static_cast<int>(value));
141 return 0 <= value && value <= 2;
147 static_assert(::std::is_same<T, GlopParameters_SolverBehavior>::value ||
148 ::std::is_integral<T>::value,
149 "Incorrect type passed to SolverBehavior_Name().");
154 return ::google::protobuf::internal::NameOfDenseEnum<GlopParameters_SolverBehavior_descriptor, 0, 2>(
155 static_cast<int>(value));
174 return 0 <= value && value <= 2;
180 static_assert(::std::is_same<T, GlopParameters_PricingRule>::value ||
181 ::std::is_integral<T>::value,
182 "Incorrect type passed to PricingRule_Name().");
187 return ::google::protobuf::internal::NameOfDenseEnum<GlopParameters_PricingRule_descriptor, 0, 2>(
188 static_cast<int>(value));
208 return 0 <= value && value <= 3;
214 static_assert(::std::is_same<T, GlopParameters_InitialBasisHeuristic>::value ||
215 ::std::is_integral<T>::value,
216 "Incorrect type passed to InitialBasisHeuristic_Name().");
221 return ::google::protobuf::internal::NameOfDenseEnum<GlopParameters_InitialBasisHeuristic_descriptor, 0, 3>(
222 static_cast<int>(value));
242 return 0 <= value && value <= 3;
248 static_assert(::std::is_same<T, GlopParameters_CostScalingAlgorithm>::value ||
249 ::std::is_integral<T>::value,
250 "Incorrect type passed to CostScalingAlgorithm_Name().");
255 return ::google::protobuf::internal::NameOfDenseEnum<GlopParameters_CostScalingAlgorithm_descriptor, 0, 3>(
256 static_cast<int>(value));
269class OR_PROTO_DLL GlopParameters final :
public ::google::protobuf::Message
275#if defined(PROTOBUF_CUSTOM_VTABLE)
276 void operator delete(
GlopParameters* PROTOBUF_NONNULL msg, std::destroying_delete_t) {
278 ::google::protobuf::internal::SizedDelete(msg,
sizeof(
GlopParameters));
282 template <
typename =
void>
283 explicit PROTOBUF_CONSTEXPR
GlopParameters(::google::protobuf::internal::ConstantInitialized);
293 if (
this == &from)
return *
this;
294 if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
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);
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>();
311 static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
312 return GetDescriptor();
314 static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
315 return default_instance().GetMetadata().descriptor;
317 static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
318 return default_instance().GetMetadata().reflection;
324 static constexpr int kIndexInFileMessages = 0;
327 if (other ==
this)
return;
328 if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
331 ::google::protobuf::internal::GenericSwap(
this, other);
334 void UnsafeArenaSwap(GlopParameters* PROTOBUF_NONNULL other) {
335 if (other ==
this)
return;
336 ABSL_DCHECK(GetArena() == other->GetArena());
342 GlopParameters* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena =
nullptr)
const {
343 return ::google::protobuf::Message::DefaultConstruct<GlopParameters>(arena);
345 using ::google::protobuf::Message::CopyFrom;
347 using ::google::protobuf::Message::MergeFrom;
348 void MergeFrom(
const GlopParameters& from) { GlopParameters::MergeImpl(*
this, from); }
351 static void MergeImpl(::google::protobuf::MessageLite& to_msg,
352 const ::google::protobuf::MessageLite& from_msg);
358 ABSL_ATTRIBUTE_REINITIALIZES
void Clear() PROTOBUF_FINAL;
359 #if defined(PROTOBUF_CUSTOM_VTABLE)
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);
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);
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;
379 int GetCachedSize()
const {
return _impl_._cached_size_.Get(); }
382 void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
386 template <
typename T>
388 static ::absl::string_view FullMessageName() {
return "operations_research.glop.GlopParameters"; }
391 explicit GlopParameters(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
394 ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
GlopParameters&& from) noexcept
396 *
this = ::std::move(from);
398 const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
399 static
void* PROTOBUF_NONNULL PlacementNew_(
400 const
void* PROTOBUF_NONNULL,
void* PROTOBUF_NONNULL mem,
401 ::
google::protobuf::Arena* PROTOBUF_NULLABLE arena);
402 static constexpr auto InternalNewImpl_();
405 static constexpr auto InternalGenerateClassData_();
407 ::
google::protobuf::Metadata GetMetadata() const;
422 template <
typename T>
423 static inline const ::std::string& ScalingAlgorithm_Name(T value) {
426 static inline bool ScalingAlgorithm_Parse(
427 ::absl::string_view name, ScalingAlgorithm* PROTOBUF_NONNULL value) {
443 template <
typename T>
444 static inline const ::std::string& SolverBehavior_Name(T value) {
447 static inline bool SolverBehavior_Parse(
448 ::absl::string_view name, SolverBehavior* PROTOBUF_NONNULL value) {
464 template <
typename T>
465 static inline const ::std::string& PricingRule_Name(T value) {
468 static inline bool PricingRule_Parse(
469 ::absl::string_view name, PricingRule* PROTOBUF_NONNULL value) {
486 template <
typename T>
487 static inline const ::std::string& InitialBasisHeuristic_Name(T value) {
490 static inline bool InitialBasisHeuristic_Parse(
491 ::absl::string_view name, InitialBasisHeuristic* PROTOBUF_NONNULL value) {
508 template <
typename T>
509 static inline const ::std::string& CostScalingAlgorithm_Name(T value) {
512 static inline bool CostScalingAlgorithm_Parse(
513 ::absl::string_view name, CostScalingAlgorithm* PROTOBUF_NONNULL value) {
519 kUseDualSimplexFieldNumber = 31,
520 kAllowSimplexAlgorithmChangeFieldNumber = 32,
586 bool _internal_use_dual_simplex()
const;
587 void _internal_set_use_dual_simplex(
bool value);
597 bool _internal_allow_simplex_algorithm_change()
const;
598 void _internal_set_allow_simplex_algorithm_change(
bool value);
608 bool _internal_perturb_costs_in_dual_simplex()
const;
609 void _internal_set_perturb_costs_in_dual_simplex(
bool value);
619 bool _internal_log_search_progress()
const;
620 void _internal_set_log_search_progress(
bool value);
630 bool _internal_dual_price_prioritize_norm()
const;
631 void _internal_set_dual_price_prioritize_norm(
bool value);
641 bool _internal_use_absl_random()
const;
642 void _internal_set_use_absl_random(
bool value);
674 double _internal_refactorization_threshold()
const;
675 void _internal_set_refactorization_threshold(
double value);
685 double _internal_recompute_reduced_costs_threshold()
const;
686 void _internal_set_recompute_reduced_costs_threshold(
double value);
696 double _internal_recompute_edges_norm_threshold()
const;
697 void _internal_set_recompute_edges_norm_threshold(
double value);
707 double _internal_primal_feasibility_tolerance()
const;
708 void _internal_set_primal_feasibility_tolerance(
double value);
718 double _internal_dual_feasibility_tolerance()
const;
719 void _internal_set_dual_feasibility_tolerance(
double value);
729 double _internal_ratio_test_zero_threshold()
const;
730 void _internal_set_ratio_test_zero_threshold(
double value);
740 double _internal_harris_tolerance_ratio()
const;
741 void _internal_set_harris_tolerance_ratio(
double value);
751 double _internal_small_pivot_threshold()
const;
752 void _internal_set_small_pivot_threshold(
double value);
762 double _internal_minimum_acceptable_pivot()
const;
763 void _internal_set_minimum_acceptable_pivot(
double value);
784 ::int32_t _internal_basis_refactorization_period()
const;
785 void _internal_set_basis_refactorization_period(::int32_t value);
795 double _internal_dualizer_threshold()
const;
796 void _internal_set_dualizer_threshold(
double value);
806 double _internal_solution_feasibility_tolerance()
const;
807 void _internal_set_solution_feasibility_tolerance(
double value);
828 bool _internal_use_scaling()
const;
829 void _internal_set_use_scaling(
bool value);
839 bool _internal_use_transposed_matrix()
const;
840 void _internal_set_use_transposed_matrix(
bool value);
850 bool _internal_provide_strong_optimal_guarantee()
const;
851 void _internal_set_provide_strong_optimal_guarantee(
bool value);
861 bool _internal_use_preprocessing()
const;
862 void _internal_set_use_preprocessing(
bool value);
872 double _internal_lu_factorization_pivot_threshold()
const;
873 void _internal_set_lu_factorization_pivot_threshold(
double value);
883 double _internal_max_time_in_seconds()
const;
884 void _internal_set_max_time_in_seconds(
double value);
894 ::int64_t _internal_max_number_of_iterations()
const;
895 void _internal_set_max_number_of_iterations(::int64_t value);
905 double _internal_markowitz_singularity_threshold()
const;
906 void _internal_set_markowitz_singularity_threshold(
double value);
916 ::int32_t _internal_markowitz_zlatev_parameter()
const;
917 void _internal_set_markowitz_zlatev_parameter(::int32_t value);
927 ::int32_t _internal_devex_weights_reset_period()
const;
928 void _internal_set_devex_weights_reset_period(::int32_t value);
938 double _internal_dual_small_pivot_threshold()
const;
939 void _internal_set_dual_small_pivot_threshold(
double value);
949 double _internal_preprocessor_zero_tolerance()
const;
950 void _internal_set_preprocessor_zero_tolerance(
double value);
960 double _internal_objective_lower_limit()
const;
961 void _internal_set_objective_lower_limit(
double value);
971 double _internal_objective_upper_limit()
const;
972 void _internal_set_objective_upper_limit(
double value);
982 bool _internal_use_middle_product_form_update()
const;
983 void _internal_set_use_middle_product_form_update(
bool value);
993 bool _internal_initialize_devex_with_column_norms()
const;
994 void _internal_set_initialize_devex_with_column_norms(
bool value);
1004 bool _internal_exploit_singleton_column_in_initial_basis()
const;
1005 void _internal_set_exploit_singleton_column_in_initial_basis(
bool value);
1015 bool _internal_change_status_to_imprecise()
const;
1016 void _internal_set_change_status_to_imprecise(
bool value);
1026 ::int32_t _internal_random_seed()
const;
1027 void _internal_set_random_seed(::int32_t value);
1037 double _internal_degenerate_ministep_factor()
const;
1038 void _internal_set_degenerate_ministep_factor(
double value);
1048 double _internal_max_deterministic_time()
const;
1049 void _internal_set_max_deterministic_time(
double value);
1059 ::int32_t _internal_num_omp_threads()
const;
1060 void _internal_set_num_omp_threads(::int32_t value);
1081 double _internal_drop_tolerance()
const;
1082 void _internal_set_drop_tolerance(
double value);
1092 double _internal_relative_cost_perturbation()
const;
1093 void _internal_set_relative_cost_perturbation(
double value);
1103 double _internal_relative_max_cost_perturbation()
const;
1104 void _internal_set_relative_max_cost_perturbation(
double value);
1114 double _internal_max_number_of_reoptimizations()
const;
1115 void _internal_set_max_number_of_reoptimizations(
double value);
1125 double _internal_initial_condition_number_threshold()
const;
1126 void _internal_set_initial_condition_number_threshold(
double value);
1147 bool _internal_use_dedicated_dual_feasibility_algorithm()
const;
1148 void _internal_set_use_dedicated_dual_feasibility_algorithm(
bool value);
1158 bool _internal_dynamically_adjust_refactorization_period()
const;
1159 void _internal_set_dynamically_adjust_refactorization_period(
bool value);
1169 bool _internal_push_to_vertex()
const;
1170 void _internal_set_push_to_vertex(
bool value);
1180 bool _internal_log_to_stdout()
const;
1181 void _internal_set_log_to_stdout(
bool value);
1191 double _internal_crossover_bound_snapping_distance()
const;
1192 void _internal_set_crossover_bound_snapping_distance(
double value);
1202 double _internal_max_valid_magnitude()
const;
1203 void _internal_set_max_valid_magnitude(
double value);
1213 double _internal_drop_magnitude()
const;
1214 void _internal_set_drop_magnitude(
double value);
1224 bool _internal_use_implied_free_preprocessor()
const;
1225 void _internal_set_use_implied_free_preprocessor(
bool value);
1231 friend class ::google::protobuf::internal::TcParser;
1232 static const ::google::protobuf::internal::TcParseTable<5, 59,
1237 friend class ::google::protobuf::MessageLite;
1238 friend class ::google::protobuf::Arena;
1239 template <
typename T>
1240 friend class ::google::protobuf::Arena::InternalHelper;
1241 using InternalArenaConstructable_ = void;
1242 using DestructorSkippable_ = void;
1244 inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized)
noexcept;
1245 inline explicit Impl_(
1246 ::google::protobuf::internal::InternalVisibility visibility,
1247 ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
1248 inline explicit Impl_(
1249 ::google::protobuf::internal::InternalVisibility visibility,
1250 ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
const Impl_& from,
1252 ::google::protobuf::internal::HasBits<2> _has_bits_;
1253 ::google::protobuf::internal::CachedSize _cached_size_;
1254 bool use_dual_simplex_;
1255 bool allow_simplex_algorithm_change_;
1256 bool perturb_costs_in_dual_simplex_;
1257 bool log_search_progress_;
1258 bool dual_price_prioritize_norm_;
1259 bool use_absl_random_;
1260 int feasibility_rule_;
1261 int optimization_rule_;
1262 double refactorization_threshold_;
1263 double recompute_reduced_costs_threshold_;
1264 double recompute_edges_norm_threshold_;
1265 double primal_feasibility_tolerance_;
1266 double dual_feasibility_tolerance_;
1267 double ratio_test_zero_threshold_;
1268 double harris_tolerance_ratio_;
1269 double small_pivot_threshold_;
1270 double minimum_acceptable_pivot_;
1272 ::int32_t basis_refactorization_period_;
1273 double dualizer_threshold_;
1274 double solution_feasibility_tolerance_;
1275 int solve_dual_problem_;
1277 bool use_transposed_matrix_;
1278 bool provide_strong_optimal_guarantee_;
1279 bool use_preprocessing_;
1280 double lu_factorization_pivot_threshold_;
1281 double max_time_in_seconds_;
1282 ::int64_t max_number_of_iterations_;
1283 double markowitz_singularity_threshold_;
1284 ::int32_t markowitz_zlatev_parameter_;
1285 ::int32_t devex_weights_reset_period_;
1286 double dual_small_pivot_threshold_;
1287 double preprocessor_zero_tolerance_;
1288 double objective_lower_limit_;
1289 double objective_upper_limit_;
1290 bool use_middle_product_form_update_;
1291 bool initialize_devex_with_column_norms_;
1292 bool exploit_singleton_column_in_initial_basis_;
1293 bool change_status_to_imprecise_;
1294 ::int32_t random_seed_;
1295 double degenerate_ministep_factor_;
1296 double max_deterministic_time_;
1297 ::int32_t num_omp_threads_;
1298 int scaling_method_;
1299 double drop_tolerance_;
1300 double relative_cost_perturbation_;
1301 double relative_max_cost_perturbation_;
1302 double max_number_of_reoptimizations_;
1303 double initial_condition_number_threshold_;
1305 bool use_dedicated_dual_feasibility_algorithm_;
1306 bool dynamically_adjust_refactorization_period_;
1307 bool push_to_vertex_;
1308 bool log_to_stdout_;
1309 double crossover_bound_snapping_distance_;
1310 double max_valid_magnitude_;
1311 double drop_magnitude_;
1312 bool use_implied_free_preprocessor_;
1313 PROTOBUF_TSAN_DECLARE_MEMBER
1315 union { Impl_ _impl_; };
1316 friend struct ::TableStruct_ortools_2fglop_2fparameters_2eproto;
1330#pragma GCC diagnostic push
1331#pragma GCC diagnostic ignored "-Wstrict-aliasing"
1339 bool value = (
_impl_._has_bits_[1] & 0x00001000u) != 0;
1343 ::google::protobuf::internal::TSanWrite(&
_impl_);
1344 _impl_.scaling_method_ = 1;
1345 _impl_._has_bits_[1] &= ~0x00001000u;
1349 return _internal_scaling_method();
1352 _internal_set_scaling_method(value);
1353 _impl_._has_bits_[1] |= 0x00001000u;
1356inline ::operations_research::glop::GlopParameters_ScalingAlgorithm GlopParameters::_internal_scaling_method()
const {
1357 ::google::protobuf::internal::TSanRead(&
_impl_);
1361 ::google::protobuf::internal::TSanWrite(&
_impl_);
1363 assert(::google::protobuf::internal::ValidateEnum(
1365 _impl_.scaling_method_ = value;
1370 bool value = (
_impl_._has_bits_[0] & 0x00000040u) != 0;
1374 ::google::protobuf::internal::TSanWrite(&
_impl_);
1375 _impl_.feasibility_rule_ = 1;
1376 _impl_._has_bits_[0] &= ~0x00000040u;
1380 return _internal_feasibility_rule();
1383 _internal_set_feasibility_rule(value);
1384 _impl_._has_bits_[0] |= 0x00000040u;
1387inline ::operations_research::glop::GlopParameters_PricingRule GlopParameters::_internal_feasibility_rule()
const {
1388 ::google::protobuf::internal::TSanRead(&
_impl_);
1392 ::google::protobuf::internal::TSanWrite(&
_impl_);
1394 assert(::google::protobuf::internal::ValidateEnum(
1396 _impl_.feasibility_rule_ = value;
1401 bool value = (
_impl_._has_bits_[0] & 0x00000080u) != 0;
1405 ::google::protobuf::internal::TSanWrite(&
_impl_);
1406 _impl_.optimization_rule_ = 1;
1407 _impl_._has_bits_[0] &= ~0x00000080u;
1411 return _internal_optimization_rule();
1414 _internal_set_optimization_rule(value);
1415 _impl_._has_bits_[0] |= 0x00000080u;
1418inline ::operations_research::glop::GlopParameters_PricingRule GlopParameters::_internal_optimization_rule()
const {
1419 ::google::protobuf::internal::TSanRead(&
_impl_);
1423 ::google::protobuf::internal::TSanWrite(&
_impl_);
1425 assert(::google::protobuf::internal::ValidateEnum(
1427 _impl_.optimization_rule_ = value;
1432 bool value = (
_impl_._has_bits_[0] & 0x00000100u) != 0;
1436 ::google::protobuf::internal::TSanWrite(&
_impl_);
1437 _impl_.refactorization_threshold_ = 1e-09;
1438 _impl_._has_bits_[0] &= ~0x00000100u;
1442 return _internal_refactorization_threshold();
1445 _internal_set_refactorization_threshold(value);
1446 _impl_._has_bits_[0] |= 0x00000100u;
1449inline double GlopParameters::_internal_refactorization_threshold()
const {
1450 ::google::protobuf::internal::TSanRead(&
_impl_);
1451 return _impl_.refactorization_threshold_;
1453inline void GlopParameters::_internal_set_refactorization_threshold(
double value) {
1454 ::google::protobuf::internal::TSanWrite(&
_impl_);
1455 _impl_.refactorization_threshold_ = value;
1460 bool value = (
_impl_._has_bits_[0] & 0x00000200u) != 0;
1464 ::google::protobuf::internal::TSanWrite(&
_impl_);
1465 _impl_.recompute_reduced_costs_threshold_ = 1e-08;
1466 _impl_._has_bits_[0] &= ~0x00000200u;
1470 return _internal_recompute_reduced_costs_threshold();
1473 _internal_set_recompute_reduced_costs_threshold(value);
1474 _impl_._has_bits_[0] |= 0x00000200u;
1477inline double GlopParameters::_internal_recompute_reduced_costs_threshold()
const {
1478 ::google::protobuf::internal::TSanRead(&
_impl_);
1479 return _impl_.recompute_reduced_costs_threshold_;
1481inline void GlopParameters::_internal_set_recompute_reduced_costs_threshold(
double value) {
1482 ::google::protobuf::internal::TSanWrite(&
_impl_);
1483 _impl_.recompute_reduced_costs_threshold_ = value;
1488 bool value = (
_impl_._has_bits_[0] & 0x00000400u) != 0;
1492 ::google::protobuf::internal::TSanWrite(&
_impl_);
1493 _impl_.recompute_edges_norm_threshold_ = 100;
1494 _impl_._has_bits_[0] &= ~0x00000400u;
1498 return _internal_recompute_edges_norm_threshold();
1501 _internal_set_recompute_edges_norm_threshold(value);
1502 _impl_._has_bits_[0] |= 0x00000400u;
1505inline double GlopParameters::_internal_recompute_edges_norm_threshold()
const {
1506 ::google::protobuf::internal::TSanRead(&
_impl_);
1507 return _impl_.recompute_edges_norm_threshold_;
1509inline void GlopParameters::_internal_set_recompute_edges_norm_threshold(
double value) {
1510 ::google::protobuf::internal::TSanWrite(&
_impl_);
1511 _impl_.recompute_edges_norm_threshold_ = value;
1516 bool value = (
_impl_._has_bits_[0] & 0x00000800u) != 0;
1520 ::google::protobuf::internal::TSanWrite(&
_impl_);
1521 _impl_.primal_feasibility_tolerance_ = 1e-08;
1522 _impl_._has_bits_[0] &= ~0x00000800u;
1526 return _internal_primal_feasibility_tolerance();
1529 _internal_set_primal_feasibility_tolerance(value);
1530 _impl_._has_bits_[0] |= 0x00000800u;
1533inline double GlopParameters::_internal_primal_feasibility_tolerance()
const {
1534 ::google::protobuf::internal::TSanRead(&
_impl_);
1535 return _impl_.primal_feasibility_tolerance_;
1537inline void GlopParameters::_internal_set_primal_feasibility_tolerance(
double value) {
1538 ::google::protobuf::internal::TSanWrite(&
_impl_);
1539 _impl_.primal_feasibility_tolerance_ = value;
1544 bool value = (
_impl_._has_bits_[0] & 0x00001000u) != 0;
1548 ::google::protobuf::internal::TSanWrite(&
_impl_);
1549 _impl_.dual_feasibility_tolerance_ = 1e-08;
1550 _impl_._has_bits_[0] &= ~0x00001000u;
1554 return _internal_dual_feasibility_tolerance();
1557 _internal_set_dual_feasibility_tolerance(value);
1558 _impl_._has_bits_[0] |= 0x00001000u;
1561inline double GlopParameters::_internal_dual_feasibility_tolerance()
const {
1562 ::google::protobuf::internal::TSanRead(&
_impl_);
1563 return _impl_.dual_feasibility_tolerance_;
1565inline void GlopParameters::_internal_set_dual_feasibility_tolerance(
double value) {
1566 ::google::protobuf::internal::TSanWrite(&
_impl_);
1567 _impl_.dual_feasibility_tolerance_ = value;
1572 bool value = (
_impl_._has_bits_[0] & 0x00002000u) != 0;
1576 ::google::protobuf::internal::TSanWrite(&
_impl_);
1577 _impl_.ratio_test_zero_threshold_ = 1e-09;
1578 _impl_._has_bits_[0] &= ~0x00002000u;
1582 return _internal_ratio_test_zero_threshold();
1585 _internal_set_ratio_test_zero_threshold(value);
1586 _impl_._has_bits_[0] |= 0x00002000u;
1589inline double GlopParameters::_internal_ratio_test_zero_threshold()
const {
1590 ::google::protobuf::internal::TSanRead(&
_impl_);
1591 return _impl_.ratio_test_zero_threshold_;
1593inline void GlopParameters::_internal_set_ratio_test_zero_threshold(
double value) {
1594 ::google::protobuf::internal::TSanWrite(&
_impl_);
1595 _impl_.ratio_test_zero_threshold_ = value;
1600 bool value = (
_impl_._has_bits_[0] & 0x00004000u) != 0;
1604 ::google::protobuf::internal::TSanWrite(&
_impl_);
1605 _impl_.harris_tolerance_ratio_ = 0.5;
1606 _impl_._has_bits_[0] &= ~0x00004000u;
1610 return _internal_harris_tolerance_ratio();
1613 _internal_set_harris_tolerance_ratio(value);
1614 _impl_._has_bits_[0] |= 0x00004000u;
1617inline double GlopParameters::_internal_harris_tolerance_ratio()
const {
1618 ::google::protobuf::internal::TSanRead(&
_impl_);
1619 return _impl_.harris_tolerance_ratio_;
1621inline void GlopParameters::_internal_set_harris_tolerance_ratio(
double value) {
1622 ::google::protobuf::internal::TSanWrite(&
_impl_);
1623 _impl_.harris_tolerance_ratio_ = value;
1628 bool value = (
_impl_._has_bits_[0] & 0x00008000u) != 0;
1632 ::google::protobuf::internal::TSanWrite(&
_impl_);
1633 _impl_.small_pivot_threshold_ = 1e-06;
1634 _impl_._has_bits_[0] &= ~0x00008000u;
1638 return _internal_small_pivot_threshold();
1641 _internal_set_small_pivot_threshold(value);
1642 _impl_._has_bits_[0] |= 0x00008000u;
1645inline double GlopParameters::_internal_small_pivot_threshold()
const {
1646 ::google::protobuf::internal::TSanRead(&
_impl_);
1647 return _impl_.small_pivot_threshold_;
1649inline void GlopParameters::_internal_set_small_pivot_threshold(
double value) {
1650 ::google::protobuf::internal::TSanWrite(&
_impl_);
1651 _impl_.small_pivot_threshold_ = value;
1656 bool value = (
_impl_._has_bits_[0] & 0x00010000u) != 0;
1660 ::google::protobuf::internal::TSanWrite(&
_impl_);
1661 _impl_.minimum_acceptable_pivot_ = 1e-06;
1662 _impl_._has_bits_[0] &= ~0x00010000u;
1666 return _internal_minimum_acceptable_pivot();
1669 _internal_set_minimum_acceptable_pivot(value);
1670 _impl_._has_bits_[0] |= 0x00010000u;
1673inline double GlopParameters::_internal_minimum_acceptable_pivot()
const {
1674 ::google::protobuf::internal::TSanRead(&
_impl_);
1675 return _impl_.minimum_acceptable_pivot_;
1677inline void GlopParameters::_internal_set_minimum_acceptable_pivot(
double value) {
1678 ::google::protobuf::internal::TSanWrite(&
_impl_);
1679 _impl_.minimum_acceptable_pivot_ = value;
1684 bool value = (
_impl_._has_bits_[1] & 0x00002000u) != 0;
1688 ::google::protobuf::internal::TSanWrite(&
_impl_);
1689 _impl_.drop_tolerance_ = 1e-14;
1690 _impl_._has_bits_[1] &= ~0x00002000u;
1694 return _internal_drop_tolerance();
1697 _internal_set_drop_tolerance(value);
1698 _impl_._has_bits_[1] |= 0x00002000u;
1701inline double GlopParameters::_internal_drop_tolerance()
const {
1702 ::google::protobuf::internal::TSanRead(&
_impl_);
1703 return _impl_.drop_tolerance_;
1705inline void GlopParameters::_internal_set_drop_tolerance(
double value) {
1706 ::google::protobuf::internal::TSanWrite(&
_impl_);
1707 _impl_.drop_tolerance_ = value;
1712 bool value = (
_impl_._has_bits_[0] & 0x00400000u) != 0;
1716 ::google::protobuf::internal::TSanWrite(&
_impl_);
1717 _impl_.use_scaling_ =
true;
1718 _impl_._has_bits_[0] &= ~0x00400000u;
1722 return _internal_use_scaling();
1725 _internal_set_use_scaling(value);
1726 _impl_._has_bits_[0] |= 0x00400000u;
1729inline bool GlopParameters::_internal_use_scaling()
const {
1730 ::google::protobuf::internal::TSanRead(&
_impl_);
1731 return _impl_.use_scaling_;
1733inline void GlopParameters::_internal_set_use_scaling(
bool value) {
1734 ::google::protobuf::internal::TSanWrite(&
_impl_);
1735 _impl_.use_scaling_ = value;
1740 bool value = (
_impl_._has_bits_[1] & 0x00040000u) != 0;
1744 ::google::protobuf::internal::TSanWrite(&
_impl_);
1745 _impl_.cost_scaling_ = 1;
1746 _impl_._has_bits_[1] &= ~0x00040000u;
1750 return _internal_cost_scaling();
1753 _internal_set_cost_scaling(value);
1754 _impl_._has_bits_[1] |= 0x00040000u;
1757inline ::operations_research::glop::GlopParameters_CostScalingAlgorithm GlopParameters::_internal_cost_scaling()
const {
1758 ::google::protobuf::internal::TSanRead(&
_impl_);
1762 ::google::protobuf::internal::TSanWrite(&
_impl_);
1764 assert(::google::protobuf::internal::ValidateEnum(
1766 _impl_.cost_scaling_ = value;
1771 bool value = (
_impl_._has_bits_[0] & 0x00020000u) != 0;
1775 ::google::protobuf::internal::TSanWrite(&
_impl_);
1776 _impl_.initial_basis_ = 2;
1777 _impl_._has_bits_[0] &= ~0x00020000u;
1781 return _internal_initial_basis();
1784 _internal_set_initial_basis(value);
1785 _impl_._has_bits_[0] |= 0x00020000u;
1788inline ::operations_research::glop::GlopParameters_InitialBasisHeuristic GlopParameters::_internal_initial_basis()
const {
1789 ::google::protobuf::internal::TSanRead(&
_impl_);
1793 ::google::protobuf::internal::TSanWrite(&
_impl_);
1795 assert(::google::protobuf::internal::ValidateEnum(
1797 _impl_.initial_basis_ = value;
1802 bool value = (
_impl_._has_bits_[0] & 0x00800000u) != 0;
1806 ::google::protobuf::internal::TSanWrite(&
_impl_);
1807 _impl_.use_transposed_matrix_ =
true;
1808 _impl_._has_bits_[0] &= ~0x00800000u;
1812 return _internal_use_transposed_matrix();
1815 _internal_set_use_transposed_matrix(value);
1816 _impl_._has_bits_[0] |= 0x00800000u;
1819inline bool GlopParameters::_internal_use_transposed_matrix()
const {
1820 ::google::protobuf::internal::TSanRead(&
_impl_);
1821 return _impl_.use_transposed_matrix_;
1823inline void GlopParameters::_internal_set_use_transposed_matrix(
bool value) {
1824 ::google::protobuf::internal::TSanWrite(&
_impl_);
1825 _impl_.use_transposed_matrix_ = value;
1830 bool value = (
_impl_._has_bits_[0] & 0x00040000u) != 0;
1834 ::google::protobuf::internal::TSanWrite(&
_impl_);
1835 _impl_.basis_refactorization_period_ = 64;
1836 _impl_._has_bits_[0] &= ~0x00040000u;
1840 return _internal_basis_refactorization_period();
1843 _internal_set_basis_refactorization_period(value);
1844 _impl_._has_bits_[0] |= 0x00040000u;
1847inline ::int32_t GlopParameters::_internal_basis_refactorization_period()
const {
1848 ::google::protobuf::internal::TSanRead(&
_impl_);
1849 return _impl_.basis_refactorization_period_;
1851inline void GlopParameters::_internal_set_basis_refactorization_period(::int32_t value) {
1852 ::google::protobuf::internal::TSanWrite(&
_impl_);
1853 _impl_.basis_refactorization_period_ = value;
1858 bool value = (
_impl_._has_bits_[1] & 0x00100000u) != 0;
1862 ::google::protobuf::internal::TSanWrite(&
_impl_);
1863 _impl_.dynamically_adjust_refactorization_period_ =
true;
1864 _impl_._has_bits_[1] &= ~0x00100000u;
1868 return _internal_dynamically_adjust_refactorization_period();
1871 _internal_set_dynamically_adjust_refactorization_period(value);
1872 _impl_._has_bits_[1] |= 0x00100000u;
1875inline bool GlopParameters::_internal_dynamically_adjust_refactorization_period()
const {
1876 ::google::protobuf::internal::TSanRead(&
_impl_);
1877 return _impl_.dynamically_adjust_refactorization_period_;
1879inline void GlopParameters::_internal_set_dynamically_adjust_refactorization_period(
bool value) {
1880 ::google::protobuf::internal::TSanWrite(&
_impl_);
1881 _impl_.dynamically_adjust_refactorization_period_ = value;
1886 bool value = (
_impl_._has_bits_[0] & 0x00200000u) != 0;
1890 ::google::protobuf::internal::TSanWrite(&
_impl_);
1891 _impl_.solve_dual_problem_ = 2;
1892 _impl_._has_bits_[0] &= ~0x00200000u;
1896 return _internal_solve_dual_problem();
1899 _internal_set_solve_dual_problem(value);
1900 _impl_._has_bits_[0] |= 0x00200000u;
1903inline ::operations_research::glop::GlopParameters_SolverBehavior GlopParameters::_internal_solve_dual_problem()
const {
1904 ::google::protobuf::internal::TSanRead(&
_impl_);
1908 ::google::protobuf::internal::TSanWrite(&
_impl_);
1910 assert(::google::protobuf::internal::ValidateEnum(
1912 _impl_.solve_dual_problem_ = value;
1917 bool value = (
_impl_._has_bits_[0] & 0x00080000u) != 0;
1921 ::google::protobuf::internal::TSanWrite(&
_impl_);
1922 _impl_.dualizer_threshold_ = 1.5;
1923 _impl_._has_bits_[0] &= ~0x00080000u;
1927 return _internal_dualizer_threshold();
1930 _internal_set_dualizer_threshold(value);
1931 _impl_._has_bits_[0] |= 0x00080000u;
1934inline double GlopParameters::_internal_dualizer_threshold()
const {
1935 ::google::protobuf::internal::TSanRead(&
_impl_);
1936 return _impl_.dualizer_threshold_;
1938inline void GlopParameters::_internal_set_dualizer_threshold(
double value) {
1939 ::google::protobuf::internal::TSanWrite(&
_impl_);
1940 _impl_.dualizer_threshold_ = value;
1945 bool value = (
_impl_._has_bits_[0] & 0x00100000u) != 0;
1949 ::google::protobuf::internal::TSanWrite(&
_impl_);
1950 _impl_.solution_feasibility_tolerance_ = 1e-06;
1951 _impl_._has_bits_[0] &= ~0x00100000u;
1955 return _internal_solution_feasibility_tolerance();
1958 _internal_set_solution_feasibility_tolerance(value);
1959 _impl_._has_bits_[0] |= 0x00100000u;
1962inline double GlopParameters::_internal_solution_feasibility_tolerance()
const {
1963 ::google::protobuf::internal::TSanRead(&
_impl_);
1964 return _impl_.solution_feasibility_tolerance_;
1966inline void GlopParameters::_internal_set_solution_feasibility_tolerance(
double value) {
1967 ::google::protobuf::internal::TSanWrite(&
_impl_);
1968 _impl_.solution_feasibility_tolerance_ = value;
1973 bool value = (
_impl_._has_bits_[0] & 0x01000000u) != 0;
1977 ::google::protobuf::internal::TSanWrite(&
_impl_);
1978 _impl_.provide_strong_optimal_guarantee_ =
true;
1979 _impl_._has_bits_[0] &= ~0x01000000u;
1983 return _internal_provide_strong_optimal_guarantee();
1986 _internal_set_provide_strong_optimal_guarantee(value);
1987 _impl_._has_bits_[0] |= 0x01000000u;
1990inline bool GlopParameters::_internal_provide_strong_optimal_guarantee()
const {
1991 ::google::protobuf::internal::TSanRead(&
_impl_);
1992 return _impl_.provide_strong_optimal_guarantee_;
1994inline void GlopParameters::_internal_set_provide_strong_optimal_guarantee(
bool value) {
1995 ::google::protobuf::internal::TSanWrite(&
_impl_);
1996 _impl_.provide_strong_optimal_guarantee_ = value;
2001 bool value = (
_impl_._has_bits_[1] & 0x00000080u) != 0;
2005 ::google::protobuf::internal::TSanWrite(&
_impl_);
2006 _impl_.change_status_to_imprecise_ =
true;
2007 _impl_._has_bits_[1] &= ~0x00000080u;
2011 return _internal_change_status_to_imprecise();
2014 _internal_set_change_status_to_imprecise(value);
2015 _impl_._has_bits_[1] |= 0x00000080u;
2018inline bool GlopParameters::_internal_change_status_to_imprecise()
const {
2019 ::google::protobuf::internal::TSanRead(&
_impl_);
2020 return _impl_.change_status_to_imprecise_;
2022inline void GlopParameters::_internal_set_change_status_to_imprecise(
bool value) {
2023 ::google::protobuf::internal::TSanWrite(&
_impl_);
2024 _impl_.change_status_to_imprecise_ = value;
2029 bool value = (
_impl_._has_bits_[1] & 0x00010000u) != 0;
2033 ::google::protobuf::internal::TSanWrite(&
_impl_);
2034 _impl_.max_number_of_reoptimizations_ = 40;
2035 _impl_._has_bits_[1] &= ~0x00010000u;
2039 return _internal_max_number_of_reoptimizations();
2042 _internal_set_max_number_of_reoptimizations(value);
2043 _impl_._has_bits_[1] |= 0x00010000u;
2046inline double GlopParameters::_internal_max_number_of_reoptimizations()
const {
2047 ::google::protobuf::internal::TSanRead(&
_impl_);
2048 return _impl_.max_number_of_reoptimizations_;
2050inline void GlopParameters::_internal_set_max_number_of_reoptimizations(
double value) {
2051 ::google::protobuf::internal::TSanWrite(&
_impl_);
2052 _impl_.max_number_of_reoptimizations_ = value;
2057 bool value = (
_impl_._has_bits_[0] & 0x04000000u) != 0;
2061 ::google::protobuf::internal::TSanWrite(&
_impl_);
2062 _impl_.lu_factorization_pivot_threshold_ = 0.01;
2063 _impl_._has_bits_[0] &= ~0x04000000u;
2067 return _internal_lu_factorization_pivot_threshold();
2070 _internal_set_lu_factorization_pivot_threshold(value);
2071 _impl_._has_bits_[0] |= 0x04000000u;
2074inline double GlopParameters::_internal_lu_factorization_pivot_threshold()
const {
2075 ::google::protobuf::internal::TSanRead(&
_impl_);
2076 return _impl_.lu_factorization_pivot_threshold_;
2078inline void GlopParameters::_internal_set_lu_factorization_pivot_threshold(
double value) {
2079 ::google::protobuf::internal::TSanWrite(&
_impl_);
2080 _impl_.lu_factorization_pivot_threshold_ = value;
2085 bool value = (
_impl_._has_bits_[0] & 0x08000000u) != 0;
2089 ::google::protobuf::internal::TSanWrite(&
_impl_);
2090 _impl_.max_time_in_seconds_ = std::numeric_limits<double>::infinity();
2091 _impl_._has_bits_[0] &= ~0x08000000u;
2095 return _internal_max_time_in_seconds();
2098 _internal_set_max_time_in_seconds(value);
2099 _impl_._has_bits_[0] |= 0x08000000u;
2102inline double GlopParameters::_internal_max_time_in_seconds()
const {
2103 ::google::protobuf::internal::TSanRead(&
_impl_);
2104 return _impl_.max_time_in_seconds_;
2106inline void GlopParameters::_internal_set_max_time_in_seconds(
double value) {
2107 ::google::protobuf::internal::TSanWrite(&
_impl_);
2108 _impl_.max_time_in_seconds_ = value;
2113 bool value = (
_impl_._has_bits_[1] & 0x00000400u) != 0;
2117 ::google::protobuf::internal::TSanWrite(&
_impl_);
2118 _impl_.max_deterministic_time_ = std::numeric_limits<double>::infinity();
2119 _impl_._has_bits_[1] &= ~0x00000400u;
2123 return _internal_max_deterministic_time();
2126 _internal_set_max_deterministic_time(value);
2127 _impl_._has_bits_[1] |= 0x00000400u;
2130inline double GlopParameters::_internal_max_deterministic_time()
const {
2131 ::google::protobuf::internal::TSanRead(&
_impl_);
2132 return _impl_.max_deterministic_time_;
2134inline void GlopParameters::_internal_set_max_deterministic_time(
double value) {
2135 ::google::protobuf::internal::TSanWrite(&
_impl_);
2136 _impl_.max_deterministic_time_ = value;
2141 bool value = (
_impl_._has_bits_[0] & 0x10000000u) != 0;
2145 ::google::protobuf::internal::TSanWrite(&
_impl_);
2146 _impl_.max_number_of_iterations_ = ::int64_t{-1};
2147 _impl_._has_bits_[0] &= ~0x10000000u;
2151 return _internal_max_number_of_iterations();
2154 _internal_set_max_number_of_iterations(value);
2155 _impl_._has_bits_[0] |= 0x10000000u;
2158inline ::int64_t GlopParameters::_internal_max_number_of_iterations()
const {
2159 ::google::protobuf::internal::TSanRead(&
_impl_);
2160 return _impl_.max_number_of_iterations_;
2162inline void GlopParameters::_internal_set_max_number_of_iterations(::int64_t value) {
2163 ::google::protobuf::internal::TSanWrite(&
_impl_);
2164 _impl_.max_number_of_iterations_ = value;
2169 bool value = (
_impl_._has_bits_[0] & 0x40000000u) != 0;
2173 ::google::protobuf::internal::TSanWrite(&
_impl_);
2174 _impl_.markowitz_zlatev_parameter_ = 3;
2175 _impl_._has_bits_[0] &= ~0x40000000u;
2179 return _internal_markowitz_zlatev_parameter();
2182 _internal_set_markowitz_zlatev_parameter(value);
2183 _impl_._has_bits_[0] |= 0x40000000u;
2186inline ::int32_t GlopParameters::_internal_markowitz_zlatev_parameter()
const {
2187 ::google::protobuf::internal::TSanRead(&
_impl_);
2188 return _impl_.markowitz_zlatev_parameter_;
2190inline void GlopParameters::_internal_set_markowitz_zlatev_parameter(::int32_t value) {
2191 ::google::protobuf::internal::TSanWrite(&
_impl_);
2192 _impl_.markowitz_zlatev_parameter_ = value;
2197 bool value = (
_impl_._has_bits_[0] & 0x20000000u) != 0;
2201 ::google::protobuf::internal::TSanWrite(&
_impl_);
2202 _impl_.markowitz_singularity_threshold_ = 1e-15;
2203 _impl_._has_bits_[0] &= ~0x20000000u;
2207 return _internal_markowitz_singularity_threshold();
2210 _internal_set_markowitz_singularity_threshold(value);
2211 _impl_._has_bits_[0] |= 0x20000000u;
2214inline double GlopParameters::_internal_markowitz_singularity_threshold()
const {
2215 ::google::protobuf::internal::TSanRead(&
_impl_);
2216 return _impl_.markowitz_singularity_threshold_;
2218inline void GlopParameters::_internal_set_markowitz_singularity_threshold(
double value) {
2219 ::google::protobuf::internal::TSanWrite(&
_impl_);
2220 _impl_.markowitz_singularity_threshold_ = value;
2225 bool value = (
_impl_._has_bits_[0] & 0x00000001u) != 0;
2229 ::google::protobuf::internal::TSanWrite(&
_impl_);
2230 _impl_.use_dual_simplex_ =
false;
2231 _impl_._has_bits_[0] &= ~0x00000001u;
2235 return _internal_use_dual_simplex();
2238 _internal_set_use_dual_simplex(value);
2239 _impl_._has_bits_[0] |= 0x00000001u;
2242inline bool GlopParameters::_internal_use_dual_simplex()
const {
2243 ::google::protobuf::internal::TSanRead(&
_impl_);
2244 return _impl_.use_dual_simplex_;
2246inline void GlopParameters::_internal_set_use_dual_simplex(
bool value) {
2247 ::google::protobuf::internal::TSanWrite(&
_impl_);
2248 _impl_.use_dual_simplex_ = value;
2253 bool value = (
_impl_._has_bits_[0] & 0x00000002u) != 0;
2257 ::google::protobuf::internal::TSanWrite(&
_impl_);
2258 _impl_.allow_simplex_algorithm_change_ =
false;
2259 _impl_._has_bits_[0] &= ~0x00000002u;
2263 return _internal_allow_simplex_algorithm_change();
2266 _internal_set_allow_simplex_algorithm_change(value);
2267 _impl_._has_bits_[0] |= 0x00000002u;
2270inline bool GlopParameters::_internal_allow_simplex_algorithm_change()
const {
2271 ::google::protobuf::internal::TSanRead(&
_impl_);
2272 return _impl_.allow_simplex_algorithm_change_;
2274inline void GlopParameters::_internal_set_allow_simplex_algorithm_change(
bool value) {
2275 ::google::protobuf::internal::TSanWrite(&
_impl_);
2276 _impl_.allow_simplex_algorithm_change_ = value;
2281 bool value = (
_impl_._has_bits_[0] & 0x80000000u) != 0;
2285 ::google::protobuf::internal::TSanWrite(&
_impl_);
2286 _impl_.devex_weights_reset_period_ = 150;
2287 _impl_._has_bits_[0] &= ~0x80000000u;
2291 return _internal_devex_weights_reset_period();
2294 _internal_set_devex_weights_reset_period(value);
2295 _impl_._has_bits_[0] |= 0x80000000u;
2298inline ::int32_t GlopParameters::_internal_devex_weights_reset_period()
const {
2299 ::google::protobuf::internal::TSanRead(&
_impl_);
2300 return _impl_.devex_weights_reset_period_;
2302inline void GlopParameters::_internal_set_devex_weights_reset_period(::int32_t value) {
2303 ::google::protobuf::internal::TSanWrite(&
_impl_);
2304 _impl_.devex_weights_reset_period_ = value;
2309 bool value = (
_impl_._has_bits_[0] & 0x02000000u) != 0;
2313 ::google::protobuf::internal::TSanWrite(&
_impl_);
2314 _impl_.use_preprocessing_ =
true;
2315 _impl_._has_bits_[0] &= ~0x02000000u;
2319 return _internal_use_preprocessing();
2322 _internal_set_use_preprocessing(value);
2323 _impl_._has_bits_[0] |= 0x02000000u;
2326inline bool GlopParameters::_internal_use_preprocessing()
const {
2327 ::google::protobuf::internal::TSanRead(&
_impl_);
2328 return _impl_.use_preprocessing_;
2330inline void GlopParameters::_internal_set_use_preprocessing(
bool value) {
2331 ::google::protobuf::internal::TSanWrite(&
_impl_);
2332 _impl_.use_preprocessing_ = value;
2337 bool value = (
_impl_._has_bits_[1] & 0x00000010u) != 0;
2341 ::google::protobuf::internal::TSanWrite(&
_impl_);
2342 _impl_.use_middle_product_form_update_ =
true;
2343 _impl_._has_bits_[1] &= ~0x00000010u;
2347 return _internal_use_middle_product_form_update();
2350 _internal_set_use_middle_product_form_update(value);
2351 _impl_._has_bits_[1] |= 0x00000010u;
2354inline bool GlopParameters::_internal_use_middle_product_form_update()
const {
2355 ::google::protobuf::internal::TSanRead(&
_impl_);
2356 return _impl_.use_middle_product_form_update_;
2358inline void GlopParameters::_internal_set_use_middle_product_form_update(
bool value) {
2359 ::google::protobuf::internal::TSanWrite(&
_impl_);
2360 _impl_.use_middle_product_form_update_ = value;
2365 bool value = (
_impl_._has_bits_[1] & 0x00000020u) != 0;
2369 ::google::protobuf::internal::TSanWrite(&
_impl_);
2370 _impl_.initialize_devex_with_column_norms_ =
true;
2371 _impl_._has_bits_[1] &= ~0x00000020u;
2375 return _internal_initialize_devex_with_column_norms();
2378 _internal_set_initialize_devex_with_column_norms(value);
2379 _impl_._has_bits_[1] |= 0x00000020u;
2382inline bool GlopParameters::_internal_initialize_devex_with_column_norms()
const {
2383 ::google::protobuf::internal::TSanRead(&
_impl_);
2384 return _impl_.initialize_devex_with_column_norms_;
2386inline void GlopParameters::_internal_set_initialize_devex_with_column_norms(
bool value) {
2387 ::google::protobuf::internal::TSanWrite(&
_impl_);
2388 _impl_.initialize_devex_with_column_norms_ = value;
2393 bool value = (
_impl_._has_bits_[1] & 0x00000040u) != 0;
2397 ::google::protobuf::internal::TSanWrite(&
_impl_);
2398 _impl_.exploit_singleton_column_in_initial_basis_ =
true;
2399 _impl_._has_bits_[1] &= ~0x00000040u;
2403 return _internal_exploit_singleton_column_in_initial_basis();
2406 _internal_set_exploit_singleton_column_in_initial_basis(value);
2407 _impl_._has_bits_[1] |= 0x00000040u;
2410inline bool GlopParameters::_internal_exploit_singleton_column_in_initial_basis()
const {
2411 ::google::protobuf::internal::TSanRead(&
_impl_);
2412 return _impl_.exploit_singleton_column_in_initial_basis_;
2414inline void GlopParameters::_internal_set_exploit_singleton_column_in_initial_basis(
bool value) {
2415 ::google::protobuf::internal::TSanWrite(&
_impl_);
2416 _impl_.exploit_singleton_column_in_initial_basis_ = value;
2421 bool value = (
_impl_._has_bits_[1] & 0x00000001u) != 0;
2425 ::google::protobuf::internal::TSanWrite(&
_impl_);
2426 _impl_.dual_small_pivot_threshold_ = 0.0001;
2427 _impl_._has_bits_[1] &= ~0x00000001u;
2431 return _internal_dual_small_pivot_threshold();
2434 _internal_set_dual_small_pivot_threshold(value);
2435 _impl_._has_bits_[1] |= 0x00000001u;
2438inline double GlopParameters::_internal_dual_small_pivot_threshold()
const {
2439 ::google::protobuf::internal::TSanRead(&
_impl_);
2440 return _impl_.dual_small_pivot_threshold_;
2442inline void GlopParameters::_internal_set_dual_small_pivot_threshold(
double value) {
2443 ::google::protobuf::internal::TSanWrite(&
_impl_);
2444 _impl_.dual_small_pivot_threshold_ = value;
2449 bool value = (
_impl_._has_bits_[1] & 0x00000002u) != 0;
2453 ::google::protobuf::internal::TSanWrite(&
_impl_);
2454 _impl_.preprocessor_zero_tolerance_ = 1e-09;
2455 _impl_._has_bits_[1] &= ~0x00000002u;
2459 return _internal_preprocessor_zero_tolerance();
2462 _internal_set_preprocessor_zero_tolerance(value);
2463 _impl_._has_bits_[1] |= 0x00000002u;
2466inline double GlopParameters::_internal_preprocessor_zero_tolerance()
const {
2467 ::google::protobuf::internal::TSanRead(&
_impl_);
2468 return _impl_.preprocessor_zero_tolerance_;
2470inline void GlopParameters::_internal_set_preprocessor_zero_tolerance(
double value) {
2471 ::google::protobuf::internal::TSanWrite(&
_impl_);
2472 _impl_.preprocessor_zero_tolerance_ = value;
2477 bool value = (
_impl_._has_bits_[1] & 0x00000004u) != 0;
2481 ::google::protobuf::internal::TSanWrite(&
_impl_);
2482 _impl_.objective_lower_limit_ = -std::numeric_limits<double>::infinity();
2483 _impl_._has_bits_[1] &= ~0x00000004u;
2487 return _internal_objective_lower_limit();
2490 _internal_set_objective_lower_limit(value);
2491 _impl_._has_bits_[1] |= 0x00000004u;
2494inline double GlopParameters::_internal_objective_lower_limit()
const {
2495 ::google::protobuf::internal::TSanRead(&
_impl_);
2496 return _impl_.objective_lower_limit_;
2498inline void GlopParameters::_internal_set_objective_lower_limit(
double value) {
2499 ::google::protobuf::internal::TSanWrite(&
_impl_);
2500 _impl_.objective_lower_limit_ = value;
2505 bool value = (
_impl_._has_bits_[1] & 0x00000008u) != 0;
2509 ::google::protobuf::internal::TSanWrite(&
_impl_);
2510 _impl_.objective_upper_limit_ = std::numeric_limits<double>::infinity();
2511 _impl_._has_bits_[1] &= ~0x00000008u;
2515 return _internal_objective_upper_limit();
2518 _internal_set_objective_upper_limit(value);
2519 _impl_._has_bits_[1] |= 0x00000008u;
2522inline double GlopParameters::_internal_objective_upper_limit()
const {
2523 ::google::protobuf::internal::TSanRead(&
_impl_);
2524 return _impl_.objective_upper_limit_;
2526inline void GlopParameters::_internal_set_objective_upper_limit(
double value) {
2527 ::google::protobuf::internal::TSanWrite(&
_impl_);
2528 _impl_.objective_upper_limit_ = value;
2533 bool value = (
_impl_._has_bits_[1] & 0x00000200u) != 0;
2537 ::google::protobuf::internal::TSanWrite(&
_impl_);
2538 _impl_.degenerate_ministep_factor_ = 0.01;
2539 _impl_._has_bits_[1] &= ~0x00000200u;
2543 return _internal_degenerate_ministep_factor();
2546 _internal_set_degenerate_ministep_factor(value);
2547 _impl_._has_bits_[1] |= 0x00000200u;
2550inline double GlopParameters::_internal_degenerate_ministep_factor()
const {
2551 ::google::protobuf::internal::TSanRead(&
_impl_);
2552 return _impl_.degenerate_ministep_factor_;
2554inline void GlopParameters::_internal_set_degenerate_ministep_factor(
double value) {
2555 ::google::protobuf::internal::TSanWrite(&
_impl_);
2556 _impl_.degenerate_ministep_factor_ = value;
2561 bool value = (
_impl_._has_bits_[1] & 0x00000100u) != 0;
2565 ::google::protobuf::internal::TSanWrite(&
_impl_);
2567 _impl_._has_bits_[1] &= ~0x00000100u;
2571 return _internal_random_seed();
2574 _internal_set_random_seed(value);
2575 _impl_._has_bits_[1] |= 0x00000100u;
2578inline ::int32_t GlopParameters::_internal_random_seed()
const {
2579 ::google::protobuf::internal::TSanRead(&
_impl_);
2580 return _impl_.random_seed_;
2582inline void GlopParameters::_internal_set_random_seed(::int32_t value) {
2583 ::google::protobuf::internal::TSanWrite(&
_impl_);
2584 _impl_.random_seed_ = value;
2589 bool value = (
_impl_._has_bits_[0] & 0x00000020u) != 0;
2593 ::google::protobuf::internal::TSanWrite(&
_impl_);
2594 _impl_.use_absl_random_ =
false;
2595 _impl_._has_bits_[0] &= ~0x00000020u;
2599 return _internal_use_absl_random();
2602 _internal_set_use_absl_random(value);
2603 _impl_._has_bits_[0] |= 0x00000020u;
2606inline bool GlopParameters::_internal_use_absl_random()
const {
2607 ::google::protobuf::internal::TSanRead(&
_impl_);
2608 return _impl_.use_absl_random_;
2610inline void GlopParameters::_internal_set_use_absl_random(
bool value) {
2611 ::google::protobuf::internal::TSanWrite(&
_impl_);
2612 _impl_.use_absl_random_ = value;
2617 bool value = (
_impl_._has_bits_[1] & 0x00000800u) != 0;
2621 ::google::protobuf::internal::TSanWrite(&
_impl_);
2622 _impl_.num_omp_threads_ = 1;
2623 _impl_._has_bits_[1] &= ~0x00000800u;
2627 return _internal_num_omp_threads();
2630 _internal_set_num_omp_threads(value);
2631 _impl_._has_bits_[1] |= 0x00000800u;
2634inline ::int32_t GlopParameters::_internal_num_omp_threads()
const {
2635 ::google::protobuf::internal::TSanRead(&
_impl_);
2636 return _impl_.num_omp_threads_;
2638inline void GlopParameters::_internal_set_num_omp_threads(::int32_t value) {
2639 ::google::protobuf::internal::TSanWrite(&
_impl_);
2640 _impl_.num_omp_threads_ = value;
2645 bool value = (
_impl_._has_bits_[0] & 0x00000004u) != 0;
2649 ::google::protobuf::internal::TSanWrite(&
_impl_);
2650 _impl_.perturb_costs_in_dual_simplex_ =
false;
2651 _impl_._has_bits_[0] &= ~0x00000004u;
2655 return _internal_perturb_costs_in_dual_simplex();
2658 _internal_set_perturb_costs_in_dual_simplex(value);
2659 _impl_._has_bits_[0] |= 0x00000004u;
2662inline bool GlopParameters::_internal_perturb_costs_in_dual_simplex()
const {
2663 ::google::protobuf::internal::TSanRead(&
_impl_);
2664 return _impl_.perturb_costs_in_dual_simplex_;
2666inline void GlopParameters::_internal_set_perturb_costs_in_dual_simplex(
bool value) {
2667 ::google::protobuf::internal::TSanWrite(&
_impl_);
2668 _impl_.perturb_costs_in_dual_simplex_ = value;
2673 bool value = (
_impl_._has_bits_[1] & 0x00080000u) != 0;
2677 ::google::protobuf::internal::TSanWrite(&
_impl_);
2678 _impl_.use_dedicated_dual_feasibility_algorithm_ =
true;
2679 _impl_._has_bits_[1] &= ~0x00080000u;
2683 return _internal_use_dedicated_dual_feasibility_algorithm();
2686 _internal_set_use_dedicated_dual_feasibility_algorithm(value);
2687 _impl_._has_bits_[1] |= 0x00080000u;
2690inline bool GlopParameters::_internal_use_dedicated_dual_feasibility_algorithm()
const {
2691 ::google::protobuf::internal::TSanRead(&
_impl_);
2692 return _impl_.use_dedicated_dual_feasibility_algorithm_;
2694inline void GlopParameters::_internal_set_use_dedicated_dual_feasibility_algorithm(
bool value) {
2695 ::google::protobuf::internal::TSanWrite(&
_impl_);
2696 _impl_.use_dedicated_dual_feasibility_algorithm_ = value;
2701 bool value = (
_impl_._has_bits_[1] & 0x00004000u) != 0;
2705 ::google::protobuf::internal::TSanWrite(&
_impl_);
2706 _impl_.relative_cost_perturbation_ = 1e-05;
2707 _impl_._has_bits_[1] &= ~0x00004000u;
2711 return _internal_relative_cost_perturbation();
2714 _internal_set_relative_cost_perturbation(value);
2715 _impl_._has_bits_[1] |= 0x00004000u;
2718inline double GlopParameters::_internal_relative_cost_perturbation()
const {
2719 ::google::protobuf::internal::TSanRead(&
_impl_);
2720 return _impl_.relative_cost_perturbation_;
2722inline void GlopParameters::_internal_set_relative_cost_perturbation(
double value) {
2723 ::google::protobuf::internal::TSanWrite(&
_impl_);
2724 _impl_.relative_cost_perturbation_ = value;
2729 bool value = (
_impl_._has_bits_[1] & 0x00008000u) != 0;
2733 ::google::protobuf::internal::TSanWrite(&
_impl_);
2734 _impl_.relative_max_cost_perturbation_ = 1e-07;
2735 _impl_._has_bits_[1] &= ~0x00008000u;
2739 return _internal_relative_max_cost_perturbation();
2742 _internal_set_relative_max_cost_perturbation(value);
2743 _impl_._has_bits_[1] |= 0x00008000u;
2746inline double GlopParameters::_internal_relative_max_cost_perturbation()
const {
2747 ::google::protobuf::internal::TSanRead(&
_impl_);
2748 return _impl_.relative_max_cost_perturbation_;
2750inline void GlopParameters::_internal_set_relative_max_cost_perturbation(
double value) {
2751 ::google::protobuf::internal::TSanWrite(&
_impl_);
2752 _impl_.relative_max_cost_perturbation_ = value;
2757 bool value = (
_impl_._has_bits_[1] & 0x00020000u) != 0;
2761 ::google::protobuf::internal::TSanWrite(&
_impl_);
2762 _impl_.initial_condition_number_threshold_ = 1e+50;
2763 _impl_._has_bits_[1] &= ~0x00020000u;
2767 return _internal_initial_condition_number_threshold();
2770 _internal_set_initial_condition_number_threshold(value);
2771 _impl_._has_bits_[1] |= 0x00020000u;
2774inline double GlopParameters::_internal_initial_condition_number_threshold()
const {
2775 ::google::protobuf::internal::TSanRead(&
_impl_);
2776 return _impl_.initial_condition_number_threshold_;
2778inline void GlopParameters::_internal_set_initial_condition_number_threshold(
double value) {
2779 ::google::protobuf::internal::TSanWrite(&
_impl_);
2780 _impl_.initial_condition_number_threshold_ = value;
2785 bool value = (
_impl_._has_bits_[0] & 0x00000008u) != 0;
2789 ::google::protobuf::internal::TSanWrite(&
_impl_);
2790 _impl_.log_search_progress_ =
false;
2791 _impl_._has_bits_[0] &= ~0x00000008u;
2795 return _internal_log_search_progress();
2798 _internal_set_log_search_progress(value);
2799 _impl_._has_bits_[0] |= 0x00000008u;
2802inline bool GlopParameters::_internal_log_search_progress()
const {
2803 ::google::protobuf::internal::TSanRead(&
_impl_);
2804 return _impl_.log_search_progress_;
2806inline void GlopParameters::_internal_set_log_search_progress(
bool value) {
2807 ::google::protobuf::internal::TSanWrite(&
_impl_);
2808 _impl_.log_search_progress_ = value;
2813 bool value = (
_impl_._has_bits_[1] & 0x00400000u) != 0;
2817 ::google::protobuf::internal::TSanWrite(&
_impl_);
2818 _impl_.log_to_stdout_ =
true;
2819 _impl_._has_bits_[1] &= ~0x00400000u;
2823 return _internal_log_to_stdout();
2826 _internal_set_log_to_stdout(value);
2827 _impl_._has_bits_[1] |= 0x00400000u;
2830inline bool GlopParameters::_internal_log_to_stdout()
const {
2831 ::google::protobuf::internal::TSanRead(&
_impl_);
2832 return _impl_.log_to_stdout_;
2834inline void GlopParameters::_internal_set_log_to_stdout(
bool value) {
2835 ::google::protobuf::internal::TSanWrite(&
_impl_);
2836 _impl_.log_to_stdout_ = value;
2841 bool value = (
_impl_._has_bits_[1] & 0x00800000u) != 0;
2845 ::google::protobuf::internal::TSanWrite(&
_impl_);
2846 _impl_.crossover_bound_snapping_distance_ = std::numeric_limits<double>::infinity();
2847 _impl_._has_bits_[1] &= ~0x00800000u;
2851 return _internal_crossover_bound_snapping_distance();
2854 _internal_set_crossover_bound_snapping_distance(value);
2855 _impl_._has_bits_[1] |= 0x00800000u;
2858inline double GlopParameters::_internal_crossover_bound_snapping_distance()
const {
2859 ::google::protobuf::internal::TSanRead(&
_impl_);
2860 return _impl_.crossover_bound_snapping_distance_;
2862inline void GlopParameters::_internal_set_crossover_bound_snapping_distance(
double value) {
2863 ::google::protobuf::internal::TSanWrite(&
_impl_);
2864 _impl_.crossover_bound_snapping_distance_ = value;
2869 bool value = (
_impl_._has_bits_[1] & 0x00200000u) != 0;
2873 ::google::protobuf::internal::TSanWrite(&
_impl_);
2874 _impl_.push_to_vertex_ =
true;
2875 _impl_._has_bits_[1] &= ~0x00200000u;
2879 return _internal_push_to_vertex();
2882 _internal_set_push_to_vertex(value);
2883 _impl_._has_bits_[1] |= 0x00200000u;
2886inline bool GlopParameters::_internal_push_to_vertex()
const {
2887 ::google::protobuf::internal::TSanRead(&
_impl_);
2888 return _impl_.push_to_vertex_;
2890inline void GlopParameters::_internal_set_push_to_vertex(
bool value) {
2891 ::google::protobuf::internal::TSanWrite(&
_impl_);
2892 _impl_.push_to_vertex_ = value;
2897 bool value = (
_impl_._has_bits_[1] & 0x04000000u) != 0;
2901 ::google::protobuf::internal::TSanWrite(&
_impl_);
2902 _impl_.use_implied_free_preprocessor_ =
true;
2903 _impl_._has_bits_[1] &= ~0x04000000u;
2907 return _internal_use_implied_free_preprocessor();
2910 _internal_set_use_implied_free_preprocessor(value);
2911 _impl_._has_bits_[1] |= 0x04000000u;
2914inline bool GlopParameters::_internal_use_implied_free_preprocessor()
const {
2915 ::google::protobuf::internal::TSanRead(&
_impl_);
2916 return _impl_.use_implied_free_preprocessor_;
2918inline void GlopParameters::_internal_set_use_implied_free_preprocessor(
bool value) {
2919 ::google::protobuf::internal::TSanWrite(&
_impl_);
2920 _impl_.use_implied_free_preprocessor_ = value;
2925 bool value = (
_impl_._has_bits_[1] & 0x01000000u) != 0;
2929 ::google::protobuf::internal::TSanWrite(&
_impl_);
2930 _impl_.max_valid_magnitude_ = 1e+30;
2931 _impl_._has_bits_[1] &= ~0x01000000u;
2935 return _internal_max_valid_magnitude();
2938 _internal_set_max_valid_magnitude(value);
2939 _impl_._has_bits_[1] |= 0x01000000u;
2942inline double GlopParameters::_internal_max_valid_magnitude()
const {
2943 ::google::protobuf::internal::TSanRead(&
_impl_);
2944 return _impl_.max_valid_magnitude_;
2946inline void GlopParameters::_internal_set_max_valid_magnitude(
double value) {
2947 ::google::protobuf::internal::TSanWrite(&
_impl_);
2948 _impl_.max_valid_magnitude_ = value;
2953 bool value = (
_impl_._has_bits_[1] & 0x02000000u) != 0;
2957 ::google::protobuf::internal::TSanWrite(&
_impl_);
2958 _impl_.drop_magnitude_ = 1e-30;
2959 _impl_._has_bits_[1] &= ~0x02000000u;
2963 return _internal_drop_magnitude();
2966 _internal_set_drop_magnitude(value);
2967 _impl_._has_bits_[1] |= 0x02000000u;
2970inline double GlopParameters::_internal_drop_magnitude()
const {
2971 ::google::protobuf::internal::TSanRead(&
_impl_);
2972 return _impl_.drop_magnitude_;
2974inline void GlopParameters::_internal_set_drop_magnitude(
double value) {
2975 ::google::protobuf::internal::TSanWrite(&
_impl_);
2976 _impl_.drop_magnitude_ = value;
2981 bool value = (
_impl_._has_bits_[0] & 0x00000010u) != 0;
2985 ::google::protobuf::internal::TSanWrite(&
_impl_);
2986 _impl_.dual_price_prioritize_norm_ =
false;
2987 _impl_._has_bits_[0] &= ~0x00000010u;
2991 return _internal_dual_price_prioritize_norm();
2994 _internal_set_dual_price_prioritize_norm(value);
2995 _impl_._has_bits_[0] |= 0x00000010u;
2998inline bool GlopParameters::_internal_dual_price_prioritize_norm()
const {
2999 ::google::protobuf::internal::TSanRead(&
_impl_);
3000 return _impl_.dual_price_prioritize_norm_;
3002inline void GlopParameters::_internal_set_dual_price_prioritize_norm(
bool value) {
3003 ::google::protobuf::internal::TSanWrite(&
_impl_);
3004 _impl_.dual_price_prioritize_norm_ = value;
3008#pragma GCC diagnostic pop
3023 return ::operations_research::glop::GlopParameters_ScalingAlgorithm_descriptor();
3029 return ::operations_research::glop::GlopParameters_SolverBehavior_descriptor();
3035 return ::operations_research::glop::GlopParameters_PricingRule_descriptor();
3041 return ::operations_research::glop::GlopParameters_InitialBasisHeuristic_descriptor();
3047 return ::operations_research::glop::GlopParameters_CostScalingAlgorithm_descriptor();
3055#include "google/protobuf/port_undef.inc"
void Swap(GlopParameters *PROTOBUF_NONNULL other)
GlopParameters & operator=(const GlopParameters &from)
bool use_middle_product_form_update() const
void clear_devex_weights_reset_period()
bool has_random_seed() const
optional int32 random_seed = 43 [default = 1];
static bool PricingRule_IsValid(int value)
double refactorization_threshold() const
bool has_provide_strong_optimal_guarantee() const
optional bool provide_strong_optimal_guarantee = 24 [default = true];
bool has_objective_lower_limit() const
optional double objective_lower_limit = 40 [default = -inf];
double markowitz_singularity_threshold() const
void set_solve_dual_problem(::operations_research::glop::GlopParameters_SolverBehavior value)
bool has_log_search_progress() const
optional bool log_search_progress = 61 [default = false];
void set_use_implied_free_preprocessor(bool value)
bool has_optimization_rule() const
optional .operations_research.glop.GlopParameters.PricingRule optimization_rule = 2 [default = STEEPE...
bool has_use_scaling() const
optional bool use_scaling = 16 [default = true];
bool has_drop_tolerance() const
optional double drop_tolerance = 52 [default = 1e-14];
static constexpr int InitialBasisHeuristic_ARRAYSIZE
friend class ::google::protobuf::MessageLite
static constexpr ScalingAlgorithm EQUILIBRATION
void clear_max_valid_magnitude()
bool has_solve_dual_problem() const
optional .operations_research.glop.GlopParameters.SolverBehavior solve_dual_problem = 20 [default = L...
bool has_use_transposed_matrix() const
optional bool use_transposed_matrix = 18 [default = true];
bool initialize_devex_with_column_norms() const
double relative_max_cost_perturbation() const
void set_log_to_stdout(bool value)
void set_relative_cost_perturbation(double value)
static constexpr int CostScalingAlgorithm_ARRAYSIZE
void clear_small_pivot_threshold()
bool has_scaling_method() const
optional .operations_research.glop.GlopParameters.ScalingAlgorithm scaling_method = 57 [default = EQU...
void set_scaling_method(::operations_research::glop::GlopParameters_ScalingAlgorithm value)
bool provide_strong_optimal_guarantee() const
void set_num_omp_threads(::int32_t value)
void clear_degenerate_ministep_factor()
static constexpr ScalingAlgorithm LINEAR_PROGRAM
GlopParameters_ScalingAlgorithm ScalingAlgorithm
nested types -------------------------------------------------—
bool use_preprocessing() const
void set_max_deterministic_time(double value)
void set_relative_max_cost_perturbation(double value)
void clear_ratio_test_zero_threshold()
double max_time_in_seconds() const
double preprocessor_zero_tolerance() const
static bool SolverBehavior_IsValid(int value)
static const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL ScalingAlgorithm_descriptor()
double harris_tolerance_ratio() const
bool log_to_stdout() const
void clear_initial_basis()
static constexpr PricingRule DEVEX
void set_solution_feasibility_tolerance(double value)
void clear_recompute_edges_norm_threshold()
void clear_recompute_reduced_costs_threshold()
bool has_max_deterministic_time() const
optional double max_deterministic_time = 45 [default = inf];
bool has_minimum_acceptable_pivot() const
optional double minimum_acceptable_pivot = 15 [default = 1e-06];
void clear_dynamically_adjust_refactorization_period()
bool change_status_to_imprecise() const
void clear_num_omp_threads()
void clear_crossover_bound_snapping_distance()
void clear_use_preprocessing()
bool use_absl_random() const
static constexpr PricingRule STEEPEST_EDGE
bool has_initial_basis() const
optional .operations_research.glop.GlopParameters.InitialBasisHeuristic initial_basis = 17 [default =...
::operations_research::glop::GlopParameters_PricingRule feasibility_rule() const
const ::google::protobuf::UnknownFieldSet & unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND
void set_crossover_bound_snapping_distance(double value)
void set_allow_simplex_algorithm_change(bool value)
bool has_exploit_singleton_column_in_initial_basis() const
optional bool exploit_singleton_column_in_initial_basis = 37 [default = true];
void set_feasibility_rule(::operations_research::glop::GlopParameters_PricingRule value)
void clear_dual_feasibility_tolerance()
::int32_t markowitz_zlatev_parameter() const
void clear_max_deterministic_time()
void clear_exploit_singleton_column_in_initial_basis()
void clear_use_absl_random()
bool has_recompute_reduced_costs_threshold() const
optional double recompute_reduced_costs_threshold = 8 [default = 1e-08];
bool has_preprocessor_zero_tolerance() const
optional double preprocessor_zero_tolerance = 39 [default = 1e-09];
::int32_t devex_weights_reset_period() const
void clear_feasibility_rule()
static constexpr SolverBehavior LET_SOLVER_DECIDE
static constexpr SolverBehavior NEVER_DO
bool has_feasibility_rule() const
optional .operations_research.glop.GlopParameters.PricingRule feasibility_rule = 1 [default = STEEPES...
void set_max_valid_magnitude(double value)
void clear_use_dedicated_dual_feasibility_algorithm()
void set_drop_magnitude(double value)
void set_objective_lower_limit(double value)
::int32_t num_omp_threads() const
bool has_objective_upper_limit() const
optional double objective_upper_limit = 41 [default = inf];
bool has_crossover_bound_snapping_distance() const
optional double crossover_bound_snapping_distance = 64 [default = inf];
double ratio_test_zero_threshold() const
void clear_scaling_method()
void set_initial_basis(::operations_research::glop::GlopParameters_InitialBasisHeuristic value)
void set_provide_strong_optimal_guarantee(bool value)
PROTOBUF_CONSTEXPR GlopParameters(::google::protobuf::internal::ConstantInitialized)
void clear_lu_factorization_pivot_threshold()
static const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL InitialBasisHeuristic_descriptor()
bool use_implied_free_preprocessor() const
void set_optimization_rule(::operations_research::glop::GlopParameters_PricingRule value)
bool has_num_omp_threads() const
optional int32 num_omp_threads = 44 [default = 1];
void clear_basis_refactorization_period()
double degenerate_ministep_factor() const
GlopParameters(const GlopParameters &from)
static constexpr InitialBasisHeuristic BIXBY
void clear_push_to_vertex()
void clear_perturb_costs_in_dual_simplex()
::int32_t random_seed() const
void set_markowitz_zlatev_parameter(::int32_t value)
bool has_markowitz_zlatev_parameter() const
optional int32 markowitz_zlatev_parameter = 29 [default = 3];
void clear_objective_lower_limit()
GlopParameters_SolverBehavior SolverBehavior
static const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL PricingRule_descriptor()
bool has_dynamically_adjust_refactorization_period() const
optional bool dynamically_adjust_refactorization_period = 63 [default = true];
static const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL SolverBehavior_descriptor()
void clear_dual_price_prioritize_norm()
void clear_relative_cost_perturbation()
static bool CostScalingAlgorithm_IsValid(int value)
double dual_feasibility_tolerance() const
double crossover_bound_snapping_distance() const
void set_refactorization_threshold(double value)
void set_cost_scaling(::operations_research::glop::GlopParameters_CostScalingAlgorithm value)
bool perturb_costs_in_dual_simplex() const
bool has_max_number_of_reoptimizations() const
optional double max_number_of_reoptimizations = 56 [default = 40];
void clear_drop_tolerance()
static constexpr InitialBasisHeuristic TRIANGULAR
void set_dualizer_threshold(double value)
void set_degenerate_ministep_factor(double value)
void clear_primal_feasibility_tolerance()
void set_random_seed(::int32_t value)
bool push_to_vertex() const
GlopParameters_PricingRule PricingRule
bool IsInitialized() const
bool has_ratio_test_zero_threshold() const
optional double ratio_test_zero_threshold = 12 [default = 1e-09];
void set_use_absl_random(bool value)
static constexpr CostScalingAlgorithm MEDIAN_COST_SCALING
bool dual_price_prioritize_norm() const
bool has_small_pivot_threshold() const
optional double small_pivot_threshold = 14 [default = 1e-06];
bool has_initialize_devex_with_column_norms() const
optional bool initialize_devex_with_column_norms = 36 [default = true];
double dualizer_threshold() const
void clear_log_to_stdout()
void clear_cost_scaling()
double drop_magnitude() const
GlopParameters_InitialBasisHeuristic InitialBasisHeuristic
bool has_drop_magnitude() const
optional double drop_magnitude = 71 [default = 1e-30];
void set_initialize_devex_with_column_norms(bool value)
@ kUseImpliedFreePreprocessorFieldNumber
@ kScalingMethodFieldNumber
@ kHarrisToleranceRatioFieldNumber
@ kObjectiveLowerLimitFieldNumber
@ kMinimumAcceptablePivotFieldNumber
@ kSolutionFeasibilityToleranceFieldNumber
@ kMarkowitzSingularityThresholdFieldNumber
@ kObjectiveUpperLimitFieldNumber
@ kDualFeasibilityToleranceFieldNumber
@ kPrimalFeasibilityToleranceFieldNumber
@ kLuFactorizationPivotThresholdFieldNumber
@ kSmallPivotThresholdFieldNumber
@ kLogToStdoutFieldNumber
@ kBasisRefactorizationPeriodFieldNumber
@ kInitializeDevexWithColumnNormsFieldNumber
@ kMaxNumberOfIterationsFieldNumber
@ kMaxTimeInSecondsFieldNumber
@ kDynamicallyAdjustRefactorizationPeriodFieldNumber
@ kDualSmallPivotThresholdFieldNumber
@ kUsePreprocessingFieldNumber
@ kInitialBasisFieldNumber
@ kDualPricePrioritizeNormFieldNumber
@ kCrossoverBoundSnappingDistanceFieldNumber
@ kRelativeCostPerturbationFieldNumber
@ kPushToVertexFieldNumber
@ kProvideStrongOptimalGuaranteeFieldNumber
@ kLogSearchProgressFieldNumber
@ kPerturbCostsInDualSimplexFieldNumber
@ kDropMagnitudeFieldNumber
@ kChangeStatusToImpreciseFieldNumber
@ kDegenerateMinistepFactorFieldNumber
@ kMaxValidMagnitudeFieldNumber
@ kExploitSingletonColumnInInitialBasisFieldNumber
@ kMaxNumberOfReoptimizationsFieldNumber
@ kMarkowitzZlatevParameterFieldNumber
@ kDropToleranceFieldNumber
@ kMaxDeterministicTimeFieldNumber
@ kPreprocessorZeroToleranceFieldNumber
@ kRefactorizationThresholdFieldNumber
@ kSolveDualProblemFieldNumber
@ kInitialConditionNumberThresholdFieldNumber
@ kUseMiddleProductFormUpdateFieldNumber
@ kOptimizationRuleFieldNumber
@ kDualizerThresholdFieldNumber
@ kUseDedicatedDualFeasibilityAlgorithmFieldNumber
@ kRecomputeEdgesNormThresholdFieldNumber
@ kUseAbslRandomFieldNumber
@ kFeasibilityRuleFieldNumber
@ kCostScalingFieldNumber
@ kDevexWeightsResetPeriodFieldNumber
@ kRecomputeReducedCostsThresholdFieldNumber
@ kRatioTestZeroThresholdFieldNumber
@ kNumOmpThreadsFieldNumber
@ kRelativeMaxCostPerturbationFieldNumber
@ kUseTransposedMatrixFieldNumber
void set_use_dedicated_dual_feasibility_algorithm(bool value)
double small_pivot_threshold() const
void clear_markowitz_zlatev_parameter()
void set_drop_tolerance(double value)
void set_markowitz_singularity_threshold(double value)
bool has_primal_feasibility_tolerance() const
optional double primal_feasibility_tolerance = 10 [default = 1e-08];
double initial_condition_number_threshold() const
static constexpr InitialBasisHeuristic MAROS
void clear_provide_strong_optimal_guarantee()
::operations_research::glop::GlopParameters_SolverBehavior solve_dual_problem() const
double recompute_reduced_costs_threshold() const
void clear_log_search_progress()
bool has_dualizer_threshold() const
optional double dualizer_threshold = 21 [default = 1.5];
double max_deterministic_time() const
bool has_relative_max_cost_perturbation() const
optional double relative_max_cost_perturbation = 55 [default = 1e-07];
static const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL CostScalingAlgorithm_descriptor()
void clear_initial_condition_number_threshold()
bool has_refactorization_threshold() const
optional double refactorization_threshold = 6 [default = 1e-09];
void set_minimum_acceptable_pivot(double value)
void clear_use_dual_simplex()
double solution_feasibility_tolerance() const
void set_harris_tolerance_ratio(double value)
double recompute_edges_norm_threshold() const
double dual_small_pivot_threshold() const
void set_use_transposed_matrix(bool value)
void clear_solve_dual_problem()
void set_max_number_of_reoptimizations(double value)
void set_use_dual_simplex(bool value)
bool has_max_time_in_seconds() const
optional double max_time_in_seconds = 26 [default = inf];
::operations_research::glop::GlopParameters_PricingRule optimization_rule() const
double minimum_acceptable_pivot() const
::int32_t basis_refactorization_period() const
static bool ScalingAlgorithm_IsValid(int value)
void set_lu_factorization_pivot_threshold(double value)
void set_preprocessor_zero_tolerance(double value)
void set_ratio_test_zero_threshold(double value)
bool has_basis_refactorization_period() const
optional int32 basis_refactorization_period = 19 [default = 64];
bool use_dual_simplex() const
void set_dual_price_prioritize_norm(bool value)
GlopParameters_CostScalingAlgorithm CostScalingAlgorithm
bool use_transposed_matrix() const
bool has_perturb_costs_in_dual_simplex() const
optional bool perturb_costs_in_dual_simplex = 53 [default = false];
void clear_optimization_rule()
void clear_preprocessor_zero_tolerance()
double max_number_of_reoptimizations() const
void clear_use_transposed_matrix()
double max_valid_magnitude() const
double relative_cost_perturbation() const
bool has_lu_factorization_pivot_threshold() const
optional double lu_factorization_pivot_threshold = 25 [default = 0.01];
void set_initial_condition_number_threshold(double value)
void clear_markowitz_singularity_threshold()
double objective_lower_limit() const
static bool InitialBasisHeuristic_IsValid(int value)
bool has_dual_price_prioritize_norm() const
optional bool dual_price_prioritize_norm = 69 [default = false];
double objective_upper_limit() const
bool has_max_number_of_iterations() const
optional int64 max_number_of_iterations = 27 [default = -1];
bool has_use_implied_free_preprocessor() const
optional bool use_implied_free_preprocessor = 67 [default = true];
double drop_tolerance() const
double primal_feasibility_tolerance() const
void set_exploit_singleton_column_in_initial_basis(bool value)
bool has_use_absl_random() const
optional bool use_absl_random = 72 [default = false];
::operations_research::glop::GlopParameters_InitialBasisHeuristic initial_basis() const
void set_max_time_in_seconds(double value)
void set_change_status_to_imprecise(bool value)
void clear_refactorization_threshold()
void clear_max_number_of_iterations()
void clear_solution_feasibility_tolerance()
bool has_dual_small_pivot_threshold() const
optional double dual_small_pivot_threshold = 38 [default = 0.0001];
bool has_dual_feasibility_tolerance() const
optional double dual_feasibility_tolerance = 11 [default = 1e-08];
bool has_push_to_vertex() const
optional bool push_to_vertex = 65 [default = true];
void clear_dualizer_threshold()
::operations_research::glop::GlopParameters_CostScalingAlgorithm cost_scaling() const
static constexpr CostScalingAlgorithm CONTAIN_ONE_COST_SCALING
void set_recompute_reduced_costs_threshold(double value)
void clear_max_time_in_seconds()
bool has_use_dedicated_dual_feasibility_algorithm() const
optional bool use_dedicated_dual_feasibility_algorithm = 62 [default = true];
void set_devex_weights_reset_period(::int32_t value)
void clear_dual_small_pivot_threshold()
void clear_max_number_of_reoptimizations()
void set_recompute_edges_norm_threshold(double value)
bool has_allow_simplex_algorithm_change() const
optional bool allow_simplex_algorithm_change = 32 [default = false];
bool has_devex_weights_reset_period() const
optional int32 devex_weights_reset_period = 33 [default = 150];
void clear_allow_simplex_algorithm_change()
bool dynamically_adjust_refactorization_period() const
static constexpr CostScalingAlgorithm MEAN_COST_SCALING
void CopyFrom(const GlopParameters &from)
::operations_research::glop::GlopParameters_ScalingAlgorithm scaling_method() const
::int64_t max_number_of_iterations() const
double lu_factorization_pivot_threshold() const
static constexpr int SolverBehavior_ARRAYSIZE
bool has_recompute_edges_norm_threshold() const
optional double recompute_edges_norm_threshold = 9 [default = 100];
bool has_use_dual_simplex() const
optional bool use_dual_simplex = 31 [default = false];
void clear_initialize_devex_with_column_norms()
void set_dynamically_adjust_refactorization_period(bool value)
bool has_cost_scaling() const
optional .operations_research.glop.GlopParameters.CostScalingAlgorithm cost_scaling = 60 [default = C...
bool has_markowitz_singularity_threshold() const
optional double markowitz_singularity_threshold = 30 [default = 1e-15];
bool has_log_to_stdout() const
optional bool log_to_stdout = 66 [default = true];
void set_max_number_of_iterations(::int64_t value)
bool exploit_singleton_column_in_initial_basis() const
void set_primal_feasibility_tolerance(double value)
bool has_max_valid_magnitude() const
optional double max_valid_magnitude = 70 [default = 1e+30];
bool has_initial_condition_number_threshold() const
optional double initial_condition_number_threshold = 59 [default = 1e+50];
void set_use_middle_product_form_update(bool value)
void clear_change_status_to_imprecise()
void set_push_to_vertex(bool value)
bool has_degenerate_ministep_factor() const
optional double degenerate_ministep_factor = 42 [default = 0.01];
void clear_objective_upper_limit()
GlopParameters(::google::protobuf::Arena *PROTOBUF_NULLABLE arena, GlopParameters &&from) noexcept
void set_small_pivot_threshold(double value)
void set_basis_refactorization_period(::int32_t value)
bool log_search_progress() const
static constexpr int PricingRule_ARRAYSIZE
bool use_dedicated_dual_feasibility_algorithm() const
bool has_use_preprocessing() const
optional bool use_preprocessing = 34 [default = true];
void set_objective_upper_limit(double value)
static constexpr int ScalingAlgorithm_ARRAYSIZE
void set_perturb_costs_in_dual_simplex(bool value)
bool has_solution_feasibility_tolerance() const
optional double solution_feasibility_tolerance = 22 [default = 1e-06];
void set_log_search_progress(bool value)
bool has_use_middle_product_form_update() const
optional bool use_middle_product_form_update = 35 [default = true];
void clear_harris_tolerance_ratio()
void clear_drop_magnitude()
void clear_use_middle_product_form_update()
void clear_use_implied_free_preprocessor()
bool allow_simplex_algorithm_change() const
void set_use_scaling(bool value)
bool has_change_status_to_imprecise() const
optional bool change_status_to_imprecise = 58 [default = true];
void set_use_preprocessing(bool value)
void set_dual_feasibility_tolerance(double value)
void set_dual_small_pivot_threshold(double value)
bool has_harris_tolerance_ratio() const
optional double harris_tolerance_ratio = 13 [default = 0.5];
void clear_relative_max_cost_perturbation()
bool has_relative_cost_perturbation() const
optional double relative_cost_perturbation = 54 [default = 1e-05];
void clear_minimum_acceptable_pivot()
PROTOBUF_CONSTINITconst ::_pbi::DescriptorTable descriptor_table_ortools_2fglop_2fparameters_2eproto
::absl::string_view GetAnyMessageName()
const EnumDescriptor *PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_SolverBehavior >()
const EnumDescriptor *PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_ScalingAlgorithm >()
const EnumDescriptor *PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_PricingRule >()
const EnumDescriptor *PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_InitialBasisHeuristic >()
const EnumDescriptor *PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::glop::GlopParameters_CostScalingAlgorithm >()
GlopParameters_CostScalingAlgorithm
@ GlopParameters_CostScalingAlgorithm_NO_COST_SCALING
@ GlopParameters_CostScalingAlgorithm_CONTAIN_ONE_COST_SCALING
@ GlopParameters_CostScalingAlgorithm_MEAN_COST_SCALING
@ GlopParameters_CostScalingAlgorithm_MEDIAN_COST_SCALING
constexpr int GlopParameters_ScalingAlgorithm_ScalingAlgorithm_ARRAYSIZE
PROTOBUF_CONSTINIT const uint32_t GlopParameters_ScalingAlgorithm_internal_data_[]
const ::std::string & GlopParameters_InitialBasisHeuristic_Name(T value)
bool GlopParameters_SolverBehavior_Parse(::absl::string_view name, GlopParameters_SolverBehavior *PROTOBUF_NONNULL value)
PROTOBUF_CONSTINIT const uint32_t GlopParameters_PricingRule_internal_data_[]
GlopParameters_PricingRule
@ GlopParameters_PricingRule_DANTZIG
@ GlopParameters_PricingRule_STEEPEST_EDGE
@ GlopParameters_PricingRule_DEVEX
const ::std::string & GlopParameters_ScalingAlgorithm_Name(T value)
constexpr GlopParameters_SolverBehavior GlopParameters_SolverBehavior_SolverBehavior_MAX
bool GlopParameters_PricingRule_Parse(::absl::string_view name, GlopParameters_PricingRule *PROTOBUF_NONNULL value)
GlopParameters_InitialBasisHeuristic
@ GlopParameters_InitialBasisHeuristic_MAROS
@ GlopParameters_InitialBasisHeuristic_TRIANGULAR
@ GlopParameters_InitialBasisHeuristic_BIXBY
@ GlopParameters_InitialBasisHeuristic_NONE
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL GlopParameters_InitialBasisHeuristic_descriptor()
constexpr GlopParameters_SolverBehavior GlopParameters_SolverBehavior_SolverBehavior_MIN
bool GlopParameters_CostScalingAlgorithm_IsValid(int value)
constexpr int GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_ARRAYSIZE
constexpr GlopParameters_InitialBasisHeuristic GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_MAX
constexpr GlopParameters_CostScalingAlgorithm GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_MIN
constexpr int GlopParameters_SolverBehavior_SolverBehavior_ARRAYSIZE
constexpr GlopParameters_InitialBasisHeuristic GlopParameters_InitialBasisHeuristic_InitialBasisHeuristic_MIN
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL GlopParameters_PricingRule_descriptor()
GlopParameters_ScalingAlgorithm
@ GlopParameters_ScalingAlgorithm_EQUILIBRATION
@ GlopParameters_ScalingAlgorithm_LINEAR_PROGRAM
@ GlopParameters_ScalingAlgorithm_DEFAULT
constexpr GlopParameters_ScalingAlgorithm GlopParameters_ScalingAlgorithm_ScalingAlgorithm_MIN
PROTOBUF_CONSTINIT const uint32_t GlopParameters_CostScalingAlgorithm_internal_data_[]
GlopParameters_SolverBehavior
@ GlopParameters_SolverBehavior_ALWAYS_DO
@ GlopParameters_SolverBehavior_LET_SOLVER_DECIDE
@ GlopParameters_SolverBehavior_NEVER_DO
const ::std::string & GlopParameters_PricingRule_Name(T value)
constexpr GlopParameters_ScalingAlgorithm GlopParameters_ScalingAlgorithm_ScalingAlgorithm_MAX
constexpr int GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_ARRAYSIZE
constexpr GlopParameters_PricingRule GlopParameters_PricingRule_PricingRule_MAX
bool GlopParameters_InitialBasisHeuristic_IsValid(int value)
bool GlopParameters_ScalingAlgorithm_Parse(::absl::string_view name, GlopParameters_ScalingAlgorithm *PROTOBUF_NONNULL value)
PROTOBUF_CONSTINIT const uint32_t GlopParameters_SolverBehavior_internal_data_[]
const ::std::string & GlopParameters_CostScalingAlgorithm_Name(T value)
bool GlopParameters_CostScalingAlgorithm_Parse(::absl::string_view name, GlopParameters_CostScalingAlgorithm *PROTOBUF_NONNULL value)
bool GlopParameters_InitialBasisHeuristic_Parse(::absl::string_view name, GlopParameters_InitialBasisHeuristic *PROTOBUF_NONNULL value)
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GlopParametersDefaultTypeInternal _GlopParameters_default_instance_
bool GlopParameters_SolverBehavior_IsValid(int value)
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL GlopParameters_ScalingAlgorithm_descriptor()
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL GlopParameters_CostScalingAlgorithm_descriptor()
constexpr GlopParameters_CostScalingAlgorithm GlopParameters_CostScalingAlgorithm_CostScalingAlgorithm_MAX
bool GlopParameters_PricingRule_IsValid(int value)
bool GlopParameters_ScalingAlgorithm_IsValid(int value)
constexpr GlopParameters_PricingRule GlopParameters_PricingRule_PricingRule_MIN
constexpr int GlopParameters_PricingRule_PricingRule_ARRAYSIZE
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL GlopParameters_SolverBehavior_descriptor()
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const::google::protobuf::internal::ClassDataFull GlopParameters_class_data_
PROTOBUF_CONSTINIT const uint32_t GlopParameters_InitialBasisHeuristic_internal_data_[]
const ::std::string & GlopParameters_SolverBehavior_Name(T value)
In SWIG mode, we don't want anything besides these top-level includes.