OR-Tools  9.2
parameters.pb.cc
Go to the documentation of this file.
1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: ortools/glop/parameters.proto
3 
4 #include "ortools/glop/parameters.pb.h"
5 
6 #include <algorithm>
7 
8 #include <google/protobuf/io/coded_stream.h>
9 #include <google/protobuf/extension_set.h>
10 #include <google/protobuf/wire_format_lite.h>
11 #include <google/protobuf/descriptor.h>
12 #include <google/protobuf/generated_message_reflection.h>
13 #include <google/protobuf/reflection_ops.h>
14 #include <google/protobuf/wire_format.h>
15 // @@protoc_insertion_point(includes)
16 #include <google/protobuf/port_def.inc>
17 
18 PROTOBUF_PRAGMA_INIT_SEG
19 namespace operations_research {
20 namespace glop {
21 constexpr GlopParameters::GlopParameters(
22  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
23  : use_dual_simplex_(false)
24  , allow_simplex_algorithm_change_(false)
25  , perturb_costs_in_dual_simplex_(false)
26  , log_search_progress_(false)
27  , use_implied_free_preprocessor_(true)
28  , feasibility_rule_(1)
29 
30  , optimization_rule_(1)
31 
32  , refactorization_threshold_(1e-09)
33  , recompute_reduced_costs_threshold_(1e-08)
34  , recompute_edges_norm_threshold_(100)
35  , primal_feasibility_tolerance_(1e-08)
36  , dual_feasibility_tolerance_(1e-08)
37  , ratio_test_zero_threshold_(1e-09)
38  , harris_tolerance_ratio_(0.5)
39  , small_pivot_threshold_(1e-06)
40  , minimum_acceptable_pivot_(1e-06)
41  , initial_basis_(2)
42 
43  , basis_refactorization_period_(64)
44  , dualizer_threshold_(1.5)
45  , solution_feasibility_tolerance_(1e-06)
46  , solve_dual_problem_(2)
47 
48  , markowitz_zlatev_parameter_(3)
49  , lu_factorization_pivot_threshold_(0.01)
50  , max_time_in_seconds_(std::numeric_limits<double>::infinity())
51  , max_number_of_iterations_(int64_t{-1})
52  , markowitz_singularity_threshold_(1e-15)
53  , use_scaling_(true)
54  , use_transposed_matrix_(true)
55  , dynamically_adjust_refactorization_period_(true)
56  , provide_strong_optimal_guarantee_(true)
57  , devex_weights_reset_period_(150)
58  , dual_small_pivot_threshold_(0.0001)
59  , preprocessor_zero_tolerance_(1e-09)
60  , objective_lower_limit_(-std::numeric_limits<double>::infinity())
61  , objective_upper_limit_(std::numeric_limits<double>::infinity())
62  , change_status_to_imprecise_(true)
63  , use_preprocessing_(true)
64  , use_middle_product_form_update_(true)
65  , initialize_devex_with_column_norms_(true)
66  , random_seed_(1)
67  , degenerate_ministep_factor_(0.01)
68  , max_deterministic_time_(std::numeric_limits<double>::infinity())
69  , num_omp_threads_(1)
70  , scaling_method_(1)
71 
72  , drop_tolerance_(1e-14)
73  , relative_cost_perturbation_(1e-05)
74  , relative_max_cost_perturbation_(1e-07)
75  , max_number_of_reoptimizations_(40)
76  , exploit_singleton_column_in_initial_basis_(true)
77  , use_dedicated_dual_feasibility_algorithm_(true)
78  , log_to_stdout_(true)
79  , push_to_vertex_(true)
80  , cost_scaling_(1)
81 
82  , initial_condition_number_threshold_(1e+50)
83  , crossover_bound_snapping_distance_(std::numeric_limits<double>::infinity()){}
84 struct GlopParametersDefaultTypeInternal {
85  constexpr GlopParametersDefaultTypeInternal()
86  : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
87  ~GlopParametersDefaultTypeInternal() {}
88  union {
89  GlopParameters _instance;
90  };
91 };
92 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GlopParametersDefaultTypeInternal _GlopParameters_default_instance_;
93 } // namespace glop
94 } // namespace operations_research
95 static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_ortools_2fglop_2fparameters_2eproto[1];
96 static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_ortools_2fglop_2fparameters_2eproto[5];
97 static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_ortools_2fglop_2fparameters_2eproto = nullptr;
98 
99 const uint32_t TableStruct_ortools_2fglop_2fparameters_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
100  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, _has_bits_),
101  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, _internal_metadata_),
102  ~0u, // no _extensions_
103  ~0u, // no _oneof_case_
104  ~0u, // no _weak_field_map_
105  ~0u, // no _inlined_string_donated_
106  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, scaling_method_),
107  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, feasibility_rule_),
108  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, optimization_rule_),
109  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, refactorization_threshold_),
110  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, recompute_reduced_costs_threshold_),
111  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, recompute_edges_norm_threshold_),
112  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, primal_feasibility_tolerance_),
113  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, dual_feasibility_tolerance_),
114  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, ratio_test_zero_threshold_),
115  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, harris_tolerance_ratio_),
116  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, small_pivot_threshold_),
117  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, minimum_acceptable_pivot_),
118  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, drop_tolerance_),
119  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, use_scaling_),
120  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, cost_scaling_),
121  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, initial_basis_),
122  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, use_transposed_matrix_),
123  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, basis_refactorization_period_),
124  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, dynamically_adjust_refactorization_period_),
125  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, solve_dual_problem_),
126  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, dualizer_threshold_),
127  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, solution_feasibility_tolerance_),
128  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, provide_strong_optimal_guarantee_),
129  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, change_status_to_imprecise_),
130  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, max_number_of_reoptimizations_),
131  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, lu_factorization_pivot_threshold_),
132  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, max_time_in_seconds_),
133  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, max_deterministic_time_),
134  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, max_number_of_iterations_),
135  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, markowitz_zlatev_parameter_),
136  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, markowitz_singularity_threshold_),
137  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, use_dual_simplex_),
138  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, allow_simplex_algorithm_change_),
139  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, devex_weights_reset_period_),
140  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, use_preprocessing_),
141  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, use_middle_product_form_update_),
142  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, initialize_devex_with_column_norms_),
143  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, exploit_singleton_column_in_initial_basis_),
144  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, dual_small_pivot_threshold_),
145  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, preprocessor_zero_tolerance_),
146  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, objective_lower_limit_),
147  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, objective_upper_limit_),
148  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, degenerate_ministep_factor_),
149  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, random_seed_),
150  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, num_omp_threads_),
151  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, perturb_costs_in_dual_simplex_),
152  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, use_dedicated_dual_feasibility_algorithm_),
153  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, relative_cost_perturbation_),
154  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, relative_max_cost_perturbation_),
155  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, initial_condition_number_threshold_),
156  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, log_search_progress_),
157  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, log_to_stdout_),
158  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, crossover_bound_snapping_distance_),
159  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, push_to_vertex_),
160  PROTOBUF_FIELD_OFFSET(::operations_research::glop::GlopParameters, use_implied_free_preprocessor_),
161  43,
162  5,
163  6,
164  7,
165  8,
166  9,
167  10,
168  11,
169  12,
170  13,
171  14,
172  15,
173  44,
174  26,
175  52,
176  16,
177  27,
178  17,
179  28,
180  20,
181  18,
182  19,
183  29,
184  35,
185  47,
186  22,
187  23,
188  41,
189  24,
190  21,
191  25,
192  0,
193  1,
194  30,
195  36,
196  37,
197  38,
198  48,
199  31,
200  32,
201  33,
202  34,
203  40,
204  39,
205  42,
206  2,
207  49,
208  45,
209  46,
210  53,
211  3,
212  50,
213  54,
214  51,
215  4,
216 };
217 static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
218  { 0, 61, -1, sizeof(::operations_research::glop::GlopParameters)},
219 };
220 
221 static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
222  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::glop::_GlopParameters_default_instance_),
223 };
224 
225 const char descriptor_table_protodef_ortools_2fglop_2fparameters_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
226  "\n\035ortools/glop/parameters.proto\022\030operati"
227  "ons_research.glop\"\342\027\n\016GlopParameters\022`\n\016"
228  "scaling_method\0309 \001(\01629.operations_resear"
229  "ch.glop.GlopParameters.ScalingAlgorithm:"
230  "\rEQUILIBRATION\022]\n\020feasibility_rule\030\001 \001(\016"
231  "24.operations_research.glop.GlopParamete"
232  "rs.PricingRule:\rSTEEPEST_EDGE\022^\n\021optimiz"
233  "ation_rule\030\002 \001(\01624.operations_research.g"
234  "lop.GlopParameters.PricingRule:\rSTEEPEST"
235  "_EDGE\022(\n\031refactorization_threshold\030\006 \001(\001"
236  ":\0051e-09\0220\n!recompute_reduced_costs_thres"
237  "hold\030\010 \001(\001:\0051e-08\022+\n\036recompute_edges_nor"
238  "m_threshold\030\t \001(\001:\003100\022+\n\034primal_feasibi"
239  "lity_tolerance\030\n \001(\001:\0051e-08\022)\n\032dual_feas"
240  "ibility_tolerance\030\013 \001(\001:\0051e-08\022(\n\031ratio_"
241  "test_zero_threshold\030\014 \001(\001:\0051e-09\022#\n\026harr"
242  "is_tolerance_ratio\030\r \001(\001:\0030.5\022$\n\025small_p"
243  "ivot_threshold\030\016 \001(\001:\0051e-06\022\'\n\030minimum_a"
244  "cceptable_pivot\030\017 \001(\001:\0051e-06\022\035\n\016drop_tol"
245  "erance\0304 \001(\001:\0051e-14\022\031\n\013use_scaling\030\020 \001(\010"
246  ":\004true\022m\n\014cost_scaling\030< \001(\0162=.operation"
247  "s_research.glop.GlopParameters.CostScali"
248  "ngAlgorithm:\030CONTAIN_ONE_COST_SCALING\022a\n"
249  "\rinitial_basis\030\021 \001(\0162>.operations_resear"
250  "ch.glop.GlopParameters.InitialBasisHeuri"
251  "stic:\nTRIANGULAR\022#\n\025use_transposed_matri"
252  "x\030\022 \001(\010:\004true\022(\n\034basis_refactorization_p"
253  "eriod\030\023 \001(\005:\00264\0227\n)dynamically_adjust_re"
254  "factorization_period\030\? \001(\010:\004true\022f\n\022solv"
255  "e_dual_problem\030\024 \001(\01627.operations_resear"
256  "ch.glop.GlopParameters.SolverBehavior:\021L"
257  "ET_SOLVER_DECIDE\022\037\n\022dualizer_threshold\030\025"
258  " \001(\001:\0031.5\022-\n\036solution_feasibility_tolera"
259  "nce\030\026 \001(\001:\0051e-06\022.\n provide_strong_optim"
260  "al_guarantee\030\030 \001(\010:\004true\022(\n\032change_statu"
261  "s_to_imprecise\030: \001(\010:\004true\022)\n\035max_number"
262  "_of_reoptimizations\0308 \001(\001:\00240\022.\n lu_fact"
263  "orization_pivot_threshold\030\031 \001(\001:\0040.01\022 \n"
264  "\023max_time_in_seconds\030\032 \001(\001:\003inf\022#\n\026max_d"
265  "eterministic_time\030- \001(\001:\003inf\022$\n\030max_numb"
266  "er_of_iterations\030\033 \001(\003:\002-1\022%\n\032markowitz_"
267  "zlatev_parameter\030\035 \001(\005:\0013\022.\n\037markowitz_s"
268  "ingularity_threshold\030\036 \001(\001:\0051e-15\022\037\n\020use"
269  "_dual_simplex\030\037 \001(\010:\005false\022-\n\036allow_simp"
270  "lex_algorithm_change\030 \001(\010:\005false\022\'\n\032dev"
271  "ex_weights_reset_period\030! \001(\005:\003150\022\037\n\021us"
272  "e_preprocessing\030\" \001(\010:\004true\022,\n\036use_middl"
273  "e_product_form_update\030# \001(\010:\004true\0220\n\"ini"
274  "tialize_devex_with_column_norms\030$ \001(\010:\004t"
275  "rue\0227\n)exploit_singleton_column_in_initi"
276  "al_basis\030% \001(\010:\004true\022*\n\032dual_small_pivot"
277  "_threshold\030& \001(\001:\0060.0001\022*\n\033preprocessor"
278  "_zero_tolerance\030\' \001(\001:\0051e-09\022#\n\025objectiv"
279  "e_lower_limit\030( \001(\001:\004-inf\022\"\n\025objective_u"
280  "pper_limit\030) \001(\001:\003inf\022(\n\032degenerate_mini"
281  "step_factor\030* \001(\001:\0040.01\022\026\n\013random_seed\030+"
282  " \001(\005:\0011\022\032\n\017num_omp_threads\030, \001(\005:\0011\022,\n\035p"
283  "erturb_costs_in_dual_simplex\0305 \001(\010:\005fals"
284  "e\0226\n(use_dedicated_dual_feasibility_algo"
285  "rithm\030> \001(\010:\004true\022)\n\032relative_cost_pertu"
286  "rbation\0306 \001(\001:\0051e-05\022-\n\036relative_max_cos"
287  "t_perturbation\0307 \001(\001:\0051e-07\0221\n\"initial_c"
288  "ondition_number_threshold\030; \001(\001:\0051e+50\022\""
289  "\n\023log_search_progress\030= \001(\010:\005false\022\033\n\rlo"
290  "g_to_stdout\030B \001(\010:\004true\022.\n!crossover_bou"
291  "nd_snapping_distance\030@ \001(\001:\003inf\022\034\n\016push_"
292  "to_vertex\030A \001(\010:\004true\022+\n\035use_implied_fre"
293  "e_preprocessor\030C \001(\010:\004true\"F\n\020ScalingAlg"
294  "orithm\022\013\n\007DEFAULT\020\000\022\021\n\rEQUILIBRATION\020\001\022\022"
295  "\n\016LINEAR_PROGRAM\020\002\"D\n\016SolverBehavior\022\r\n\t"
296  "ALWAYS_DO\020\000\022\014\n\010NEVER_DO\020\001\022\025\n\021LET_SOLVER_"
297  "DECIDE\020\002\"8\n\013PricingRule\022\013\n\007DANTZIG\020\000\022\021\n\r"
298  "STEEPEST_EDGE\020\001\022\t\n\005DEVEX\020\002\"G\n\025InitialBas"
299  "isHeuristic\022\010\n\004NONE\020\000\022\t\n\005BIXBY\020\001\022\016\n\nTRIA"
300  "NGULAR\020\002\022\t\n\005MAROS\020\003\"y\n\024CostScalingAlgori"
301  "thm\022\023\n\017NO_COST_SCALING\020\000\022\034\n\030CONTAIN_ONE_"
302  "COST_SCALING\020\001\022\025\n\021MEAN_COST_SCALING\020\002\022\027\n"
303  "\023MEDIAN_COST_SCALING\020\003"
304  ;
305 static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_ortools_2fglop_2fparameters_2eproto_once;
306 const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ortools_2fglop_2fparameters_2eproto = {
307  false, false, 3102, descriptor_table_protodef_ortools_2fglop_2fparameters_2eproto, "ortools/glop/parameters.proto",
308  &descriptor_table_ortools_2fglop_2fparameters_2eproto_once, nullptr, 0, 1,
309  schemas, file_default_instances, TableStruct_ortools_2fglop_2fparameters_2eproto::offsets,
310  file_level_metadata_ortools_2fglop_2fparameters_2eproto, file_level_enum_descriptors_ortools_2fglop_2fparameters_2eproto, file_level_service_descriptors_ortools_2fglop_2fparameters_2eproto,
311 };
312 PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_ortools_2fglop_2fparameters_2eproto_getter() {
313  return &descriptor_table_ortools_2fglop_2fparameters_2eproto;
314 }
315 
316 // Force running AddDescriptors() at dynamic initialization time.
317 PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_ortools_2fglop_2fparameters_2eproto(&descriptor_table_ortools_2fglop_2fparameters_2eproto);
318 namespace operations_research {
319 namespace glop {
320 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GlopParameters_ScalingAlgorithm_descriptor() {
321  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2fglop_2fparameters_2eproto);
322  return file_level_enum_descriptors_ortools_2fglop_2fparameters_2eproto[0];
323 }
324 bool GlopParameters_ScalingAlgorithm_IsValid(int value) {
325  switch (value) {
326  case 0:
327  case 1:
328  case 2:
329  return true;
330  default:
331  return false;
332  }
333 }
334 
335 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
336 constexpr GlopParameters_ScalingAlgorithm GlopParameters::DEFAULT;
337 constexpr GlopParameters_ScalingAlgorithm GlopParameters::EQUILIBRATION;
338 constexpr GlopParameters_ScalingAlgorithm GlopParameters::LINEAR_PROGRAM;
339 constexpr GlopParameters_ScalingAlgorithm GlopParameters::ScalingAlgorithm_MIN;
340 constexpr GlopParameters_ScalingAlgorithm GlopParameters::ScalingAlgorithm_MAX;
341 constexpr int GlopParameters::ScalingAlgorithm_ARRAYSIZE;
342 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
343 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GlopParameters_SolverBehavior_descriptor() {
344  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2fglop_2fparameters_2eproto);
345  return file_level_enum_descriptors_ortools_2fglop_2fparameters_2eproto[1];
346 }
347 bool GlopParameters_SolverBehavior_IsValid(int value) {
348  switch (value) {
349  case 0:
350  case 1:
351  case 2:
352  return true;
353  default:
354  return false;
355  }
356 }
357 
358 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
359 constexpr GlopParameters_SolverBehavior GlopParameters::ALWAYS_DO;
360 constexpr GlopParameters_SolverBehavior GlopParameters::NEVER_DO;
361 constexpr GlopParameters_SolverBehavior GlopParameters::LET_SOLVER_DECIDE;
362 constexpr GlopParameters_SolverBehavior GlopParameters::SolverBehavior_MIN;
363 constexpr GlopParameters_SolverBehavior GlopParameters::SolverBehavior_MAX;
364 constexpr int GlopParameters::SolverBehavior_ARRAYSIZE;
365 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
366 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GlopParameters_PricingRule_descriptor() {
367  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2fglop_2fparameters_2eproto);
368  return file_level_enum_descriptors_ortools_2fglop_2fparameters_2eproto[2];
369 }
370 bool GlopParameters_PricingRule_IsValid(int value) {
371  switch (value) {
372  case 0:
373  case 1:
374  case 2:
375  return true;
376  default:
377  return false;
378  }
379 }
380 
381 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
382 constexpr GlopParameters_PricingRule GlopParameters::DANTZIG;
383 constexpr GlopParameters_PricingRule GlopParameters::STEEPEST_EDGE;
384 constexpr GlopParameters_PricingRule GlopParameters::DEVEX;
385 constexpr GlopParameters_PricingRule GlopParameters::PricingRule_MIN;
386 constexpr GlopParameters_PricingRule GlopParameters::PricingRule_MAX;
387 constexpr int GlopParameters::PricingRule_ARRAYSIZE;
388 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
389 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GlopParameters_InitialBasisHeuristic_descriptor() {
390  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2fglop_2fparameters_2eproto);
391  return file_level_enum_descriptors_ortools_2fglop_2fparameters_2eproto[3];
392 }
393 bool GlopParameters_InitialBasisHeuristic_IsValid(int value) {
394  switch (value) {
395  case 0:
396  case 1:
397  case 2:
398  case 3:
399  return true;
400  default:
401  return false;
402  }
403 }
404 
405 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
406 constexpr GlopParameters_InitialBasisHeuristic GlopParameters::NONE;
407 constexpr GlopParameters_InitialBasisHeuristic GlopParameters::BIXBY;
408 constexpr GlopParameters_InitialBasisHeuristic GlopParameters::TRIANGULAR;
409 constexpr GlopParameters_InitialBasisHeuristic GlopParameters::MAROS;
410 constexpr GlopParameters_InitialBasisHeuristic GlopParameters::InitialBasisHeuristic_MIN;
411 constexpr GlopParameters_InitialBasisHeuristic GlopParameters::InitialBasisHeuristic_MAX;
412 constexpr int GlopParameters::InitialBasisHeuristic_ARRAYSIZE;
413 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
414 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GlopParameters_CostScalingAlgorithm_descriptor() {
415  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2fglop_2fparameters_2eproto);
416  return file_level_enum_descriptors_ortools_2fglop_2fparameters_2eproto[4];
417 }
418 bool GlopParameters_CostScalingAlgorithm_IsValid(int value) {
419  switch (value) {
420  case 0:
421  case 1:
422  case 2:
423  case 3:
424  return true;
425  default:
426  return false;
427  }
428 }
429 
430 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
431 constexpr GlopParameters_CostScalingAlgorithm GlopParameters::NO_COST_SCALING;
432 constexpr GlopParameters_CostScalingAlgorithm GlopParameters::CONTAIN_ONE_COST_SCALING;
433 constexpr GlopParameters_CostScalingAlgorithm GlopParameters::MEAN_COST_SCALING;
434 constexpr GlopParameters_CostScalingAlgorithm GlopParameters::MEDIAN_COST_SCALING;
435 constexpr GlopParameters_CostScalingAlgorithm GlopParameters::CostScalingAlgorithm_MIN;
436 constexpr GlopParameters_CostScalingAlgorithm GlopParameters::CostScalingAlgorithm_MAX;
437 constexpr int GlopParameters::CostScalingAlgorithm_ARRAYSIZE;
438 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
439 
440 // ===================================================================
441 
442 class GlopParameters::_Internal {
443  public:
444  using HasBits = decltype(std::declval<GlopParameters>()._has_bits_);
445  static void set_has_scaling_method(HasBits* has_bits) {
446  (*has_bits)[1] |= 2048u;
447  }
448  static void set_has_feasibility_rule(HasBits* has_bits) {
449  (*has_bits)[0] |= 32u;
450  }
451  static void set_has_optimization_rule(HasBits* has_bits) {
452  (*has_bits)[0] |= 64u;
453  }
454  static void set_has_refactorization_threshold(HasBits* has_bits) {
455  (*has_bits)[0] |= 128u;
456  }
457  static void set_has_recompute_reduced_costs_threshold(HasBits* has_bits) {
458  (*has_bits)[0] |= 256u;
459  }
460  static void set_has_recompute_edges_norm_threshold(HasBits* has_bits) {
461  (*has_bits)[0] |= 512u;
462  }
463  static void set_has_primal_feasibility_tolerance(HasBits* has_bits) {
464  (*has_bits)[0] |= 1024u;
465  }
466  static void set_has_dual_feasibility_tolerance(HasBits* has_bits) {
467  (*has_bits)[0] |= 2048u;
468  }
469  static void set_has_ratio_test_zero_threshold(HasBits* has_bits) {
470  (*has_bits)[0] |= 4096u;
471  }
472  static void set_has_harris_tolerance_ratio(HasBits* has_bits) {
473  (*has_bits)[0] |= 8192u;
474  }
475  static void set_has_small_pivot_threshold(HasBits* has_bits) {
476  (*has_bits)[0] |= 16384u;
477  }
478  static void set_has_minimum_acceptable_pivot(HasBits* has_bits) {
479  (*has_bits)[0] |= 32768u;
480  }
481  static void set_has_drop_tolerance(HasBits* has_bits) {
482  (*has_bits)[1] |= 4096u;
483  }
484  static void set_has_use_scaling(HasBits* has_bits) {
485  (*has_bits)[0] |= 67108864u;
486  }
487  static void set_has_cost_scaling(HasBits* has_bits) {
488  (*has_bits)[1] |= 1048576u;
489  }
490  static void set_has_initial_basis(HasBits* has_bits) {
491  (*has_bits)[0] |= 65536u;
492  }
493  static void set_has_use_transposed_matrix(HasBits* has_bits) {
494  (*has_bits)[0] |= 134217728u;
495  }
496  static void set_has_basis_refactorization_period(HasBits* has_bits) {
497  (*has_bits)[0] |= 131072u;
498  }
499  static void set_has_dynamically_adjust_refactorization_period(HasBits* has_bits) {
500  (*has_bits)[0] |= 268435456u;
501  }
502  static void set_has_solve_dual_problem(HasBits* has_bits) {
503  (*has_bits)[0] |= 1048576u;
504  }
505  static void set_has_dualizer_threshold(HasBits* has_bits) {
506  (*has_bits)[0] |= 262144u;
507  }
508  static void set_has_solution_feasibility_tolerance(HasBits* has_bits) {
509  (*has_bits)[0] |= 524288u;
510  }
511  static void set_has_provide_strong_optimal_guarantee(HasBits* has_bits) {
512  (*has_bits)[0] |= 536870912u;
513  }
514  static void set_has_change_status_to_imprecise(HasBits* has_bits) {
515  (*has_bits)[1] |= 8u;
516  }
517  static void set_has_max_number_of_reoptimizations(HasBits* has_bits) {
518  (*has_bits)[1] |= 32768u;
519  }
520  static void set_has_lu_factorization_pivot_threshold(HasBits* has_bits) {
521  (*has_bits)[0] |= 4194304u;
522  }
523  static void set_has_max_time_in_seconds(HasBits* has_bits) {
524  (*has_bits)[0] |= 8388608u;
525  }
526  static void set_has_max_deterministic_time(HasBits* has_bits) {
527  (*has_bits)[1] |= 512u;
528  }
529  static void set_has_max_number_of_iterations(HasBits* has_bits) {
530  (*has_bits)[0] |= 16777216u;
531  }
532  static void set_has_markowitz_zlatev_parameter(HasBits* has_bits) {
533  (*has_bits)[0] |= 2097152u;
534  }
535  static void set_has_markowitz_singularity_threshold(HasBits* has_bits) {
536  (*has_bits)[0] |= 33554432u;
537  }
538  static void set_has_use_dual_simplex(HasBits* has_bits) {
539  (*has_bits)[0] |= 1u;
540  }
541  static void set_has_allow_simplex_algorithm_change(HasBits* has_bits) {
542  (*has_bits)[0] |= 2u;
543  }
544  static void set_has_devex_weights_reset_period(HasBits* has_bits) {
545  (*has_bits)[0] |= 1073741824u;
546  }
547  static void set_has_use_preprocessing(HasBits* has_bits) {
548  (*has_bits)[1] |= 16u;
549  }
550  static void set_has_use_middle_product_form_update(HasBits* has_bits) {
551  (*has_bits)[1] |= 32u;
552  }
553  static void set_has_initialize_devex_with_column_norms(HasBits* has_bits) {
554  (*has_bits)[1] |= 64u;
555  }
556  static void set_has_exploit_singleton_column_in_initial_basis(HasBits* has_bits) {
557  (*has_bits)[1] |= 65536u;
558  }
559  static void set_has_dual_small_pivot_threshold(HasBits* has_bits) {
560  (*has_bits)[0] |= 2147483648u;
561  }
562  static void set_has_preprocessor_zero_tolerance(HasBits* has_bits) {
563  (*has_bits)[1] |= 1u;
564  }
565  static void set_has_objective_lower_limit(HasBits* has_bits) {
566  (*has_bits)[1] |= 2u;
567  }
568  static void set_has_objective_upper_limit(HasBits* has_bits) {
569  (*has_bits)[1] |= 4u;
570  }
571  static void set_has_degenerate_ministep_factor(HasBits* has_bits) {
572  (*has_bits)[1] |= 256u;
573  }
574  static void set_has_random_seed(HasBits* has_bits) {
575  (*has_bits)[1] |= 128u;
576  }
577  static void set_has_num_omp_threads(HasBits* has_bits) {
578  (*has_bits)[1] |= 1024u;
579  }
580  static void set_has_perturb_costs_in_dual_simplex(HasBits* has_bits) {
581  (*has_bits)[0] |= 4u;
582  }
583  static void set_has_use_dedicated_dual_feasibility_algorithm(HasBits* has_bits) {
584  (*has_bits)[1] |= 131072u;
585  }
586  static void set_has_relative_cost_perturbation(HasBits* has_bits) {
587  (*has_bits)[1] |= 8192u;
588  }
589  static void set_has_relative_max_cost_perturbation(HasBits* has_bits) {
590  (*has_bits)[1] |= 16384u;
591  }
592  static void set_has_initial_condition_number_threshold(HasBits* has_bits) {
593  (*has_bits)[1] |= 2097152u;
594  }
595  static void set_has_log_search_progress(HasBits* has_bits) {
596  (*has_bits)[0] |= 8u;
597  }
598  static void set_has_log_to_stdout(HasBits* has_bits) {
599  (*has_bits)[1] |= 262144u;
600  }
601  static void set_has_crossover_bound_snapping_distance(HasBits* has_bits) {
602  (*has_bits)[1] |= 4194304u;
603  }
604  static void set_has_push_to_vertex(HasBits* has_bits) {
605  (*has_bits)[1] |= 524288u;
606  }
607  static void set_has_use_implied_free_preprocessor(HasBits* has_bits) {
608  (*has_bits)[0] |= 16u;
609  }
610 };
611 
612 GlopParameters::GlopParameters(::PROTOBUF_NAMESPACE_ID::Arena* arena,
613  bool is_message_owned)
614  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
615  SharedCtor();
616  if (!is_message_owned) {
617  RegisterArenaDtor(arena);
618  }
619  // @@protoc_insertion_point(arena_constructor:operations_research.glop.GlopParameters)
620 }
621 GlopParameters::GlopParameters(const GlopParameters& from)
622  : ::PROTOBUF_NAMESPACE_ID::Message(),
623  _has_bits_(from._has_bits_) {
624  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
625  ::memcpy(&use_dual_simplex_, &from.use_dual_simplex_,
626  static_cast<size_t>(reinterpret_cast<char*>(&crossover_bound_snapping_distance_) -
627  reinterpret_cast<char*>(&use_dual_simplex_)) + sizeof(crossover_bound_snapping_distance_));
628  // @@protoc_insertion_point(copy_constructor:operations_research.glop.GlopParameters)
629 }
630 
631 inline void GlopParameters::SharedCtor() {
632 ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
633  reinterpret_cast<char*>(&use_dual_simplex_) - reinterpret_cast<char*>(this)),
634  0, static_cast<size_t>(reinterpret_cast<char*>(&log_search_progress_) -
635  reinterpret_cast<char*>(&use_dual_simplex_)) + sizeof(log_search_progress_));
636 use_implied_free_preprocessor_ = true;
637 feasibility_rule_ = 1;
638 optimization_rule_ = 1;
639 refactorization_threshold_ = 1e-09;
640 recompute_reduced_costs_threshold_ = 1e-08;
641 recompute_edges_norm_threshold_ = 100;
642 primal_feasibility_tolerance_ = 1e-08;
643 dual_feasibility_tolerance_ = 1e-08;
644 ratio_test_zero_threshold_ = 1e-09;
645 harris_tolerance_ratio_ = 0.5;
646 small_pivot_threshold_ = 1e-06;
647 minimum_acceptable_pivot_ = 1e-06;
648 initial_basis_ = 2;
649 basis_refactorization_period_ = 64;
650 dualizer_threshold_ = 1.5;
651 solution_feasibility_tolerance_ = 1e-06;
652 solve_dual_problem_ = 2;
653 markowitz_zlatev_parameter_ = 3;
654 lu_factorization_pivot_threshold_ = 0.01;
655 max_time_in_seconds_ = std::numeric_limits<double>::infinity();
656 max_number_of_iterations_ = int64_t{-1};
657 markowitz_singularity_threshold_ = 1e-15;
658 use_scaling_ = true;
659 use_transposed_matrix_ = true;
660 dynamically_adjust_refactorization_period_ = true;
661 provide_strong_optimal_guarantee_ = true;
662 devex_weights_reset_period_ = 150;
663 dual_small_pivot_threshold_ = 0.0001;
664 preprocessor_zero_tolerance_ = 1e-09;
665 objective_lower_limit_ = -std::numeric_limits<double>::infinity();
666 objective_upper_limit_ = std::numeric_limits<double>::infinity();
667 change_status_to_imprecise_ = true;
668 use_preprocessing_ = true;
669 use_middle_product_form_update_ = true;
670 initialize_devex_with_column_norms_ = true;
671 random_seed_ = 1;
672 degenerate_ministep_factor_ = 0.01;
673 max_deterministic_time_ = std::numeric_limits<double>::infinity();
674 num_omp_threads_ = 1;
675 scaling_method_ = 1;
676 drop_tolerance_ = 1e-14;
677 relative_cost_perturbation_ = 1e-05;
678 relative_max_cost_perturbation_ = 1e-07;
679 max_number_of_reoptimizations_ = 40;
680 exploit_singleton_column_in_initial_basis_ = true;
681 use_dedicated_dual_feasibility_algorithm_ = true;
682 log_to_stdout_ = true;
683 push_to_vertex_ = true;
684 cost_scaling_ = 1;
685 initial_condition_number_threshold_ = 1e+50;
686 crossover_bound_snapping_distance_ = std::numeric_limits<double>::infinity();
687 }
688 
689 GlopParameters::~GlopParameters() {
690  // @@protoc_insertion_point(destructor:operations_research.glop.GlopParameters)
691  if (GetArenaForAllocation() != nullptr) return;
692  SharedDtor();
693  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
694 }
695 
696 inline void GlopParameters::SharedDtor() {
697  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
698 }
699 
700 void GlopParameters::ArenaDtor(void* object) {
701  GlopParameters* _this = reinterpret_cast< GlopParameters* >(object);
702  (void)_this;
703 }
704 void GlopParameters::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
705 }
706 void GlopParameters::SetCachedSize(int size) const {
707  _cached_size_.Set(size);
708 }
709 
710 void GlopParameters::Clear() {
711 // @@protoc_insertion_point(message_clear_start:operations_research.glop.GlopParameters)
712  uint32_t cached_has_bits = 0;
713  // Prevent compiler warnings about cached_has_bits being unused
714  (void) cached_has_bits;
715 
716  ::memset(&use_dual_simplex_, 0, static_cast<size_t>(
717  reinterpret_cast<char*>(&log_search_progress_) -
718  reinterpret_cast<char*>(&use_dual_simplex_)) + sizeof(log_search_progress_));
719  cached_has_bits = _has_bits_[0];
720  if (cached_has_bits & 0x000000f0u) {
721  use_implied_free_preprocessor_ = true;
722  feasibility_rule_ = 1;
723  optimization_rule_ = 1;
724  refactorization_threshold_ = 1e-09;
725  }
726  if (cached_has_bits & 0x0000ff00u) {
727  recompute_reduced_costs_threshold_ = 1e-08;
728  recompute_edges_norm_threshold_ = 100;
729  primal_feasibility_tolerance_ = 1e-08;
730  dual_feasibility_tolerance_ = 1e-08;
731  ratio_test_zero_threshold_ = 1e-09;
732  harris_tolerance_ratio_ = 0.5;
733  small_pivot_threshold_ = 1e-06;
734  minimum_acceptable_pivot_ = 1e-06;
735  }
736  if (cached_has_bits & 0x00ff0000u) {
737  initial_basis_ = 2;
738  basis_refactorization_period_ = 64;
739  dualizer_threshold_ = 1.5;
740  solution_feasibility_tolerance_ = 1e-06;
741  solve_dual_problem_ = 2;
742  markowitz_zlatev_parameter_ = 3;
743  lu_factorization_pivot_threshold_ = 0.01;
744  max_time_in_seconds_ = std::numeric_limits<double>::infinity();
745  }
746  if (cached_has_bits & 0xff000000u) {
747  max_number_of_iterations_ = int64_t{-1};
748  markowitz_singularity_threshold_ = 1e-15;
749  use_scaling_ = true;
750  use_transposed_matrix_ = true;
751  dynamically_adjust_refactorization_period_ = true;
752  provide_strong_optimal_guarantee_ = true;
753  devex_weights_reset_period_ = 150;
754  dual_small_pivot_threshold_ = 0.0001;
755  }
756  cached_has_bits = _has_bits_[1];
757  if (cached_has_bits & 0x000000ffu) {
758  preprocessor_zero_tolerance_ = 1e-09;
759  objective_lower_limit_ = -std::numeric_limits<double>::infinity();
760  objective_upper_limit_ = std::numeric_limits<double>::infinity();
761  change_status_to_imprecise_ = true;
762  use_preprocessing_ = true;
763  use_middle_product_form_update_ = true;
764  initialize_devex_with_column_norms_ = true;
765  random_seed_ = 1;
766  }
767  if (cached_has_bits & 0x0000ff00u) {
768  degenerate_ministep_factor_ = 0.01;
769  max_deterministic_time_ = std::numeric_limits<double>::infinity();
770  num_omp_threads_ = 1;
771  scaling_method_ = 1;
772  drop_tolerance_ = 1e-14;
773  relative_cost_perturbation_ = 1e-05;
774  relative_max_cost_perturbation_ = 1e-07;
775  max_number_of_reoptimizations_ = 40;
776  }
777  if (cached_has_bits & 0x007f0000u) {
778  exploit_singleton_column_in_initial_basis_ = true;
779  use_dedicated_dual_feasibility_algorithm_ = true;
780  log_to_stdout_ = true;
781  push_to_vertex_ = true;
782  cost_scaling_ = 1;
783  initial_condition_number_threshold_ = 1e+50;
784  crossover_bound_snapping_distance_ = std::numeric_limits<double>::infinity();
785  }
786  _has_bits_.Clear();
787  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
788 }
789 
790 const char* GlopParameters::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
791 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
792  while (!ctx->Done(&ptr)) {
793  uint32_t tag;
794  ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
795  switch (tag >> 3) {
796  // optional .operations_research.glop.GlopParameters.PricingRule feasibility_rule = 1 [default = STEEPEST_EDGE];
797  case 1:
798  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
799  uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
800  CHK_(ptr);
801  if (PROTOBUF_PREDICT_TRUE(::operations_research::glop::GlopParameters_PricingRule_IsValid(val))) {
802  _internal_set_feasibility_rule(static_cast<::operations_research::glop::GlopParameters_PricingRule>(val));
803  } else {
804  ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
805  }
806  } else
807  goto handle_unusual;
808  continue;
809  // optional .operations_research.glop.GlopParameters.PricingRule optimization_rule = 2 [default = STEEPEST_EDGE];
810  case 2:
811  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
812  uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
813  CHK_(ptr);
814  if (PROTOBUF_PREDICT_TRUE(::operations_research::glop::GlopParameters_PricingRule_IsValid(val))) {
815  _internal_set_optimization_rule(static_cast<::operations_research::glop::GlopParameters_PricingRule>(val));
816  } else {
817  ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
818  }
819  } else
820  goto handle_unusual;
821  continue;
822  // optional double refactorization_threshold = 6 [default = 1e-09];
823  case 6:
824  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 49)) {
825  _Internal::set_has_refactorization_threshold(&_has_bits_);
826  refactorization_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
827  ptr += sizeof(double);
828  } else
829  goto handle_unusual;
830  continue;
831  // optional double recompute_reduced_costs_threshold = 8 [default = 1e-08];
832  case 8:
833  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 65)) {
834  _Internal::set_has_recompute_reduced_costs_threshold(&_has_bits_);
835  recompute_reduced_costs_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
836  ptr += sizeof(double);
837  } else
838  goto handle_unusual;
839  continue;
840  // optional double recompute_edges_norm_threshold = 9 [default = 100];
841  case 9:
842  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 73)) {
843  _Internal::set_has_recompute_edges_norm_threshold(&_has_bits_);
844  recompute_edges_norm_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
845  ptr += sizeof(double);
846  } else
847  goto handle_unusual;
848  continue;
849  // optional double primal_feasibility_tolerance = 10 [default = 1e-08];
850  case 10:
851  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 81)) {
852  _Internal::set_has_primal_feasibility_tolerance(&_has_bits_);
853  primal_feasibility_tolerance_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
854  ptr += sizeof(double);
855  } else
856  goto handle_unusual;
857  continue;
858  // optional double dual_feasibility_tolerance = 11 [default = 1e-08];
859  case 11:
860  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 89)) {
861  _Internal::set_has_dual_feasibility_tolerance(&_has_bits_);
862  dual_feasibility_tolerance_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
863  ptr += sizeof(double);
864  } else
865  goto handle_unusual;
866  continue;
867  // optional double ratio_test_zero_threshold = 12 [default = 1e-09];
868  case 12:
869  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 97)) {
870  _Internal::set_has_ratio_test_zero_threshold(&_has_bits_);
871  ratio_test_zero_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
872  ptr += sizeof(double);
873  } else
874  goto handle_unusual;
875  continue;
876  // optional double harris_tolerance_ratio = 13 [default = 0.5];
877  case 13:
878  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 105)) {
879  _Internal::set_has_harris_tolerance_ratio(&_has_bits_);
880  harris_tolerance_ratio_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
881  ptr += sizeof(double);
882  } else
883  goto handle_unusual;
884  continue;
885  // optional double small_pivot_threshold = 14 [default = 1e-06];
886  case 14:
887  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 113)) {
888  _Internal::set_has_small_pivot_threshold(&_has_bits_);
889  small_pivot_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
890  ptr += sizeof(double);
891  } else
892  goto handle_unusual;
893  continue;
894  // optional double minimum_acceptable_pivot = 15 [default = 1e-06];
895  case 15:
896  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 121)) {
897  _Internal::set_has_minimum_acceptable_pivot(&_has_bits_);
898  minimum_acceptable_pivot_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
899  ptr += sizeof(double);
900  } else
901  goto handle_unusual;
902  continue;
903  // optional bool use_scaling = 16 [default = true];
904  case 16:
905  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 128)) {
906  _Internal::set_has_use_scaling(&_has_bits_);
907  use_scaling_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
908  CHK_(ptr);
909  } else
910  goto handle_unusual;
911  continue;
912  // optional .operations_research.glop.GlopParameters.InitialBasisHeuristic initial_basis = 17 [default = TRIANGULAR];
913  case 17:
914  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 136)) {
915  uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
916  CHK_(ptr);
917  if (PROTOBUF_PREDICT_TRUE(::operations_research::glop::GlopParameters_InitialBasisHeuristic_IsValid(val))) {
918  _internal_set_initial_basis(static_cast<::operations_research::glop::GlopParameters_InitialBasisHeuristic>(val));
919  } else {
920  ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(17, val, mutable_unknown_fields());
921  }
922  } else
923  goto handle_unusual;
924  continue;
925  // optional bool use_transposed_matrix = 18 [default = true];
926  case 18:
927  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 144)) {
928  _Internal::set_has_use_transposed_matrix(&_has_bits_);
929  use_transposed_matrix_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
930  CHK_(ptr);
931  } else
932  goto handle_unusual;
933  continue;
934  // optional int32 basis_refactorization_period = 19 [default = 64];
935  case 19:
936  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 152)) {
937  _Internal::set_has_basis_refactorization_period(&_has_bits_);
938  basis_refactorization_period_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
939  CHK_(ptr);
940  } else
941  goto handle_unusual;
942  continue;
943  // optional .operations_research.glop.GlopParameters.SolverBehavior solve_dual_problem = 20 [default = LET_SOLVER_DECIDE];
944  case 20:
945  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 160)) {
946  uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
947  CHK_(ptr);
948  if (PROTOBUF_PREDICT_TRUE(::operations_research::glop::GlopParameters_SolverBehavior_IsValid(val))) {
949  _internal_set_solve_dual_problem(static_cast<::operations_research::glop::GlopParameters_SolverBehavior>(val));
950  } else {
951  ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(20, val, mutable_unknown_fields());
952  }
953  } else
954  goto handle_unusual;
955  continue;
956  // optional double dualizer_threshold = 21 [default = 1.5];
957  case 21:
958  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 169)) {
959  _Internal::set_has_dualizer_threshold(&_has_bits_);
960  dualizer_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
961  ptr += sizeof(double);
962  } else
963  goto handle_unusual;
964  continue;
965  // optional double solution_feasibility_tolerance = 22 [default = 1e-06];
966  case 22:
967  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 177)) {
968  _Internal::set_has_solution_feasibility_tolerance(&_has_bits_);
969  solution_feasibility_tolerance_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
970  ptr += sizeof(double);
971  } else
972  goto handle_unusual;
973  continue;
974  // optional bool provide_strong_optimal_guarantee = 24 [default = true];
975  case 24:
976  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 192)) {
977  _Internal::set_has_provide_strong_optimal_guarantee(&_has_bits_);
978  provide_strong_optimal_guarantee_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
979  CHK_(ptr);
980  } else
981  goto handle_unusual;
982  continue;
983  // optional double lu_factorization_pivot_threshold = 25 [default = 0.01];
984  case 25:
985  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 201)) {
986  _Internal::set_has_lu_factorization_pivot_threshold(&_has_bits_);
987  lu_factorization_pivot_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
988  ptr += sizeof(double);
989  } else
990  goto handle_unusual;
991  continue;
992  // optional double max_time_in_seconds = 26 [default = inf];
993  case 26:
994  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 209)) {
995  _Internal::set_has_max_time_in_seconds(&_has_bits_);
996  max_time_in_seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
997  ptr += sizeof(double);
998  } else
999  goto handle_unusual;
1000  continue;
1001  // optional int64 max_number_of_iterations = 27 [default = -1];
1002  case 27:
1003  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 216)) {
1004  _Internal::set_has_max_number_of_iterations(&_has_bits_);
1005  max_number_of_iterations_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1006  CHK_(ptr);
1007  } else
1008  goto handle_unusual;
1009  continue;
1010  // optional int32 markowitz_zlatev_parameter = 29 [default = 3];
1011  case 29:
1012  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 232)) {
1013  _Internal::set_has_markowitz_zlatev_parameter(&_has_bits_);
1014  markowitz_zlatev_parameter_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1015  CHK_(ptr);
1016  } else
1017  goto handle_unusual;
1018  continue;
1019  // optional double markowitz_singularity_threshold = 30 [default = 1e-15];
1020  case 30:
1021  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 241)) {
1022  _Internal::set_has_markowitz_singularity_threshold(&_has_bits_);
1023  markowitz_singularity_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
1024  ptr += sizeof(double);
1025  } else
1026  goto handle_unusual;
1027  continue;
1028  // optional bool use_dual_simplex = 31 [default = false];
1029  case 31:
1030  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 248)) {
1031  _Internal::set_has_use_dual_simplex(&_has_bits_);
1032  use_dual_simplex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1033  CHK_(ptr);
1034  } else
1035  goto handle_unusual;
1036  continue;
1037  // optional bool allow_simplex_algorithm_change = 32 [default = false];
1038  case 32:
1039  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 0)) {
1040  _Internal::set_has_allow_simplex_algorithm_change(&_has_bits_);
1041  allow_simplex_algorithm_change_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1042  CHK_(ptr);
1043  } else
1044  goto handle_unusual;
1045  continue;
1046  // optional int32 devex_weights_reset_period = 33 [default = 150];
1047  case 33:
1048  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
1049  _Internal::set_has_devex_weights_reset_period(&_has_bits_);
1050  devex_weights_reset_period_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1051  CHK_(ptr);
1052  } else
1053  goto handle_unusual;
1054  continue;
1055  // optional bool use_preprocessing = 34 [default = true];
1056  case 34:
1057  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
1058  _Internal::set_has_use_preprocessing(&_has_bits_);
1059  use_preprocessing_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1060  CHK_(ptr);
1061  } else
1062  goto handle_unusual;
1063  continue;
1064  // optional bool use_middle_product_form_update = 35 [default = true];
1065  case 35:
1066  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
1067  _Internal::set_has_use_middle_product_form_update(&_has_bits_);
1068  use_middle_product_form_update_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1069  CHK_(ptr);
1070  } else
1071  goto handle_unusual;
1072  continue;
1073  // optional bool initialize_devex_with_column_norms = 36 [default = true];
1074  case 36:
1075  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
1076  _Internal::set_has_initialize_devex_with_column_norms(&_has_bits_);
1077  initialize_devex_with_column_norms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1078  CHK_(ptr);
1079  } else
1080  goto handle_unusual;
1081  continue;
1082  // optional bool exploit_singleton_column_in_initial_basis = 37 [default = true];
1083  case 37:
1084  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
1085  _Internal::set_has_exploit_singleton_column_in_initial_basis(&_has_bits_);
1086  exploit_singleton_column_in_initial_basis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1087  CHK_(ptr);
1088  } else
1089  goto handle_unusual;
1090  continue;
1091  // optional double dual_small_pivot_threshold = 38 [default = 0.0001];
1092  case 38:
1093  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 49)) {
1094  _Internal::set_has_dual_small_pivot_threshold(&_has_bits_);
1095  dual_small_pivot_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
1096  ptr += sizeof(double);
1097  } else
1098  goto handle_unusual;
1099  continue;
1100  // optional double preprocessor_zero_tolerance = 39 [default = 1e-09];
1101  case 39:
1102  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 57)) {
1103  _Internal::set_has_preprocessor_zero_tolerance(&_has_bits_);
1104  preprocessor_zero_tolerance_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
1105  ptr += sizeof(double);
1106  } else
1107  goto handle_unusual;
1108  continue;
1109  // optional double objective_lower_limit = 40 [default = -inf];
1110  case 40:
1111  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 65)) {
1112  _Internal::set_has_objective_lower_limit(&_has_bits_);
1113  objective_lower_limit_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
1114  ptr += sizeof(double);
1115  } else
1116  goto handle_unusual;
1117  continue;
1118  // optional double objective_upper_limit = 41 [default = inf];
1119  case 41:
1120  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 73)) {
1121  _Internal::set_has_objective_upper_limit(&_has_bits_);
1122  objective_upper_limit_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
1123  ptr += sizeof(double);
1124  } else
1125  goto handle_unusual;
1126  continue;
1127  // optional double degenerate_ministep_factor = 42 [default = 0.01];
1128  case 42:
1129  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 81)) {
1130  _Internal::set_has_degenerate_ministep_factor(&_has_bits_);
1131  degenerate_ministep_factor_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
1132  ptr += sizeof(double);
1133  } else
1134  goto handle_unusual;
1135  continue;
1136  // optional int32 random_seed = 43 [default = 1];
1137  case 43:
1138  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
1139  _Internal::set_has_random_seed(&_has_bits_);
1140  random_seed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1141  CHK_(ptr);
1142  } else
1143  goto handle_unusual;
1144  continue;
1145  // optional int32 num_omp_threads = 44 [default = 1];
1146  case 44:
1147  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
1148  _Internal::set_has_num_omp_threads(&_has_bits_);
1149  num_omp_threads_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1150  CHK_(ptr);
1151  } else
1152  goto handle_unusual;
1153  continue;
1154  // optional double max_deterministic_time = 45 [default = inf];
1155  case 45:
1156  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 105)) {
1157  _Internal::set_has_max_deterministic_time(&_has_bits_);
1158  max_deterministic_time_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
1159  ptr += sizeof(double);
1160  } else
1161  goto handle_unusual;
1162  continue;
1163  // optional double drop_tolerance = 52 [default = 1e-14];
1164  case 52:
1165  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 161)) {
1166  _Internal::set_has_drop_tolerance(&_has_bits_);
1167  drop_tolerance_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
1168  ptr += sizeof(double);
1169  } else
1170  goto handle_unusual;
1171  continue;
1172  // optional bool perturb_costs_in_dual_simplex = 53 [default = false];
1173  case 53:
1174  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 168)) {
1175  _Internal::set_has_perturb_costs_in_dual_simplex(&_has_bits_);
1176  perturb_costs_in_dual_simplex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1177  CHK_(ptr);
1178  } else
1179  goto handle_unusual;
1180  continue;
1181  // optional double relative_cost_perturbation = 54 [default = 1e-05];
1182  case 54:
1183  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 177)) {
1184  _Internal::set_has_relative_cost_perturbation(&_has_bits_);
1185  relative_cost_perturbation_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
1186  ptr += sizeof(double);
1187  } else
1188  goto handle_unusual;
1189  continue;
1190  // optional double relative_max_cost_perturbation = 55 [default = 1e-07];
1191  case 55:
1192  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 185)) {
1193  _Internal::set_has_relative_max_cost_perturbation(&_has_bits_);
1194  relative_max_cost_perturbation_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
1195  ptr += sizeof(double);
1196  } else
1197  goto handle_unusual;
1198  continue;
1199  // optional double max_number_of_reoptimizations = 56 [default = 40];
1200  case 56:
1201  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 193)) {
1202  _Internal::set_has_max_number_of_reoptimizations(&_has_bits_);
1203  max_number_of_reoptimizations_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
1204  ptr += sizeof(double);
1205  } else
1206  goto handle_unusual;
1207  continue;
1208  // optional .operations_research.glop.GlopParameters.ScalingAlgorithm scaling_method = 57 [default = EQUILIBRATION];
1209  case 57:
1210  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 200)) {
1211  uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1212  CHK_(ptr);
1213  if (PROTOBUF_PREDICT_TRUE(::operations_research::glop::GlopParameters_ScalingAlgorithm_IsValid(val))) {
1214  _internal_set_scaling_method(static_cast<::operations_research::glop::GlopParameters_ScalingAlgorithm>(val));
1215  } else {
1216  ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(57, val, mutable_unknown_fields());
1217  }
1218  } else
1219  goto handle_unusual;
1220  continue;
1221  // optional bool change_status_to_imprecise = 58 [default = true];
1222  case 58:
1223  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 208)) {
1224  _Internal::set_has_change_status_to_imprecise(&_has_bits_);
1225  change_status_to_imprecise_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1226  CHK_(ptr);
1227  } else
1228  goto handle_unusual;
1229  continue;
1230  // optional double initial_condition_number_threshold = 59 [default = 1e+50];
1231  case 59:
1232  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 217)) {
1233  _Internal::set_has_initial_condition_number_threshold(&_has_bits_);
1234  initial_condition_number_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
1235  ptr += sizeof(double);
1236  } else
1237  goto handle_unusual;
1238  continue;
1239  // optional .operations_research.glop.GlopParameters.CostScalingAlgorithm cost_scaling = 60 [default = CONTAIN_ONE_COST_SCALING];
1240  case 60:
1241  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 224)) {
1242  uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1243  CHK_(ptr);
1244  if (PROTOBUF_PREDICT_TRUE(::operations_research::glop::GlopParameters_CostScalingAlgorithm_IsValid(val))) {
1245  _internal_set_cost_scaling(static_cast<::operations_research::glop::GlopParameters_CostScalingAlgorithm>(val));
1246  } else {
1247  ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(60, val, mutable_unknown_fields());
1248  }
1249  } else
1250  goto handle_unusual;
1251  continue;
1252  // optional bool log_search_progress = 61 [default = false];
1253  case 61:
1254  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 232)) {
1255  _Internal::set_has_log_search_progress(&_has_bits_);
1256  log_search_progress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1257  CHK_(ptr);
1258  } else
1259  goto handle_unusual;
1260  continue;
1261  // optional bool use_dedicated_dual_feasibility_algorithm = 62 [default = true];
1262  case 62:
1263  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 240)) {
1264  _Internal::set_has_use_dedicated_dual_feasibility_algorithm(&_has_bits_);
1265  use_dedicated_dual_feasibility_algorithm_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1266  CHK_(ptr);
1267  } else
1268  goto handle_unusual;
1269  continue;
1270  // optional bool dynamically_adjust_refactorization_period = 63 [default = true];
1271  case 63:
1272  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 248)) {
1273  _Internal::set_has_dynamically_adjust_refactorization_period(&_has_bits_);
1274  dynamically_adjust_refactorization_period_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1275  CHK_(ptr);
1276  } else
1277  goto handle_unusual;
1278  continue;
1279  // optional double crossover_bound_snapping_distance = 64 [default = inf];
1280  case 64:
1281  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 1)) {
1282  _Internal::set_has_crossover_bound_snapping_distance(&_has_bits_);
1283  crossover_bound_snapping_distance_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
1284  ptr += sizeof(double);
1285  } else
1286  goto handle_unusual;
1287  continue;
1288  // optional bool push_to_vertex = 65 [default = true];
1289  case 65:
1290  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
1291  _Internal::set_has_push_to_vertex(&_has_bits_);
1292  push_to_vertex_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1293  CHK_(ptr);
1294  } else
1295  goto handle_unusual;
1296  continue;
1297  // optional bool log_to_stdout = 66 [default = true];
1298  case 66:
1299  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
1300  _Internal::set_has_log_to_stdout(&_has_bits_);
1301  log_to_stdout_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1302  CHK_(ptr);
1303  } else
1304  goto handle_unusual;
1305  continue;
1306  // optional bool use_implied_free_preprocessor = 67 [default = true];
1307  case 67:
1308  if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
1309  _Internal::set_has_use_implied_free_preprocessor(&_has_bits_);
1310  use_implied_free_preprocessor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1311  CHK_(ptr);
1312  } else
1313  goto handle_unusual;
1314  continue;
1315  default:
1316  goto handle_unusual;
1317  } // switch
1318  handle_unusual:
1319  if ((tag == 0) || ((tag & 7) == 4)) {
1320  CHK_(ptr);
1321  ctx->SetLastTag(tag);
1322  goto message_done;
1323  }
1324  ptr = UnknownFieldParse(
1325  tag,
1326  _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
1327  ptr, ctx);
1328  CHK_(ptr != nullptr);
1329  } // while
1330 message_done:
1331  return ptr;
1332 failure:
1333  ptr = nullptr;
1334  goto message_done;
1335 #undef CHK_
1336 }
1337 
1338 uint8_t* GlopParameters::_InternalSerialize(
1339  uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1340  // @@protoc_insertion_point(serialize_to_array_start:operations_research.glop.GlopParameters)
1341  uint32_t cached_has_bits = 0;
1342  (void) cached_has_bits;
1343 
1344  cached_has_bits = _has_bits_[0];
1345  // optional .operations_research.glop.GlopParameters.PricingRule feasibility_rule = 1 [default = STEEPEST_EDGE];
1346  if (cached_has_bits & 0x00000020u) {
1347  target = stream->EnsureSpace(target);
1348  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
1349  1, this->_internal_feasibility_rule(), target);
1350  }
1351 
1352  // optional .operations_research.glop.GlopParameters.PricingRule optimization_rule = 2 [default = STEEPEST_EDGE];
1353  if (cached_has_bits & 0x00000040u) {
1354  target = stream->EnsureSpace(target);
1355  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
1356  2, this->_internal_optimization_rule(), target);
1357  }
1358 
1359  // optional double refactorization_threshold = 6 [default = 1e-09];
1360  if (cached_has_bits & 0x00000080u) {
1361  target = stream->EnsureSpace(target);
1362  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(6, this->_internal_refactorization_threshold(), target);
1363  }
1364 
1365  // optional double recompute_reduced_costs_threshold = 8 [default = 1e-08];
1366  if (cached_has_bits & 0x00000100u) {
1367  target = stream->EnsureSpace(target);
1368  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(8, this->_internal_recompute_reduced_costs_threshold(), target);
1369  }
1370 
1371  // optional double recompute_edges_norm_threshold = 9 [default = 100];
1372  if (cached_has_bits & 0x00000200u) {
1373  target = stream->EnsureSpace(target);
1374  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(9, this->_internal_recompute_edges_norm_threshold(), target);
1375  }
1376 
1377  // optional double primal_feasibility_tolerance = 10 [default = 1e-08];
1378  if (cached_has_bits & 0x00000400u) {
1379  target = stream->EnsureSpace(target);
1380  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(10, this->_internal_primal_feasibility_tolerance(), target);
1381  }
1382 
1383  // optional double dual_feasibility_tolerance = 11 [default = 1e-08];
1384  if (cached_has_bits & 0x00000800u) {
1385  target = stream->EnsureSpace(target);
1386  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(11, this->_internal_dual_feasibility_tolerance(), target);
1387  }
1388 
1389  // optional double ratio_test_zero_threshold = 12 [default = 1e-09];
1390  if (cached_has_bits & 0x00001000u) {
1391  target = stream->EnsureSpace(target);
1392  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(12, this->_internal_ratio_test_zero_threshold(), target);
1393  }
1394 
1395  // optional double harris_tolerance_ratio = 13 [default = 0.5];
1396  if (cached_has_bits & 0x00002000u) {
1397  target = stream->EnsureSpace(target);
1398  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(13, this->_internal_harris_tolerance_ratio(), target);
1399  }
1400 
1401  // optional double small_pivot_threshold = 14 [default = 1e-06];
1402  if (cached_has_bits & 0x00004000u) {
1403  target = stream->EnsureSpace(target);
1404  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(14, this->_internal_small_pivot_threshold(), target);
1405  }
1406 
1407  // optional double minimum_acceptable_pivot = 15 [default = 1e-06];
1408  if (cached_has_bits & 0x00008000u) {
1409  target = stream->EnsureSpace(target);
1410  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(15, this->_internal_minimum_acceptable_pivot(), target);
1411  }
1412 
1413  // optional bool use_scaling = 16 [default = true];
1414  if (cached_has_bits & 0x04000000u) {
1415  target = stream->EnsureSpace(target);
1416  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(16, this->_internal_use_scaling(), target);
1417  }
1418 
1419  // optional .operations_research.glop.GlopParameters.InitialBasisHeuristic initial_basis = 17 [default = TRIANGULAR];
1420  if (cached_has_bits & 0x00010000u) {
1421  target = stream->EnsureSpace(target);
1422  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
1423  17, this->_internal_initial_basis(), target);
1424  }
1425 
1426  // optional bool use_transposed_matrix = 18 [default = true];
1427  if (cached_has_bits & 0x08000000u) {
1428  target = stream->EnsureSpace(target);
1429  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(18, this->_internal_use_transposed_matrix(), target);
1430  }
1431 
1432  // optional int32 basis_refactorization_period = 19 [default = 64];
1433  if (cached_has_bits & 0x00020000u) {
1434  target = stream->EnsureSpace(target);
1435  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(19, this->_internal_basis_refactorization_period(), target);
1436  }
1437 
1438  // optional .operations_research.glop.GlopParameters.SolverBehavior solve_dual_problem = 20 [default = LET_SOLVER_DECIDE];
1439  if (cached_has_bits & 0x00100000u) {
1440  target = stream->EnsureSpace(target);
1441  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
1442  20, this->_internal_solve_dual_problem(), target);
1443  }
1444 
1445  // optional double dualizer_threshold = 21 [default = 1.5];
1446  if (cached_has_bits & 0x00040000u) {
1447  target = stream->EnsureSpace(target);
1448  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(21, this->_internal_dualizer_threshold(), target);
1449  }
1450 
1451  // optional double solution_feasibility_tolerance = 22 [default = 1e-06];
1452  if (cached_has_bits & 0x00080000u) {
1453  target = stream->EnsureSpace(target);
1454  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(22, this->_internal_solution_feasibility_tolerance(), target);
1455  }
1456 
1457  // optional bool provide_strong_optimal_guarantee = 24 [default = true];
1458  if (cached_has_bits & 0x20000000u) {
1459  target = stream->EnsureSpace(target);
1460  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(24, this->_internal_provide_strong_optimal_guarantee(), target);
1461  }
1462 
1463  // optional double lu_factorization_pivot_threshold = 25 [default = 0.01];
1464  if (cached_has_bits & 0x00400000u) {
1465  target = stream->EnsureSpace(target);
1466  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(25, this->_internal_lu_factorization_pivot_threshold(), target);
1467  }
1468 
1469  // optional double max_time_in_seconds = 26 [default = inf];
1470  if (cached_has_bits & 0x00800000u) {
1471  target = stream->EnsureSpace(target);
1472  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(26, this->_internal_max_time_in_seconds(), target);
1473  }
1474 
1475  // optional int64 max_number_of_iterations = 27 [default = -1];
1476  if (cached_has_bits & 0x01000000u) {
1477  target = stream->EnsureSpace(target);
1478  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(27, this->_internal_max_number_of_iterations(), target);
1479  }
1480 
1481  // optional int32 markowitz_zlatev_parameter = 29 [default = 3];
1482  if (cached_has_bits & 0x00200000u) {
1483  target = stream->EnsureSpace(target);
1484  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(29, this->_internal_markowitz_zlatev_parameter(), target);
1485  }
1486 
1487  // optional double markowitz_singularity_threshold = 30 [default = 1e-15];
1488  if (cached_has_bits & 0x02000000u) {
1489  target = stream->EnsureSpace(target);
1490  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(30, this->_internal_markowitz_singularity_threshold(), target);
1491  }
1492 
1493  // optional bool use_dual_simplex = 31 [default = false];
1494  if (cached_has_bits & 0x00000001u) {
1495  target = stream->EnsureSpace(target);
1496  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(31, this->_internal_use_dual_simplex(), target);
1497  }
1498 
1499  // optional bool allow_simplex_algorithm_change = 32 [default = false];
1500  if (cached_has_bits & 0x00000002u) {
1501  target = stream->EnsureSpace(target);
1502  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(32, this->_internal_allow_simplex_algorithm_change(), target);
1503  }
1504 
1505  // optional int32 devex_weights_reset_period = 33 [default = 150];
1506  if (cached_has_bits & 0x40000000u) {
1507  target = stream->EnsureSpace(target);
1508  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(33, this->_internal_devex_weights_reset_period(), target);
1509  }
1510 
1511  cached_has_bits = _has_bits_[1];
1512  // optional bool use_preprocessing = 34 [default = true];
1513  if (cached_has_bits & 0x00000010u) {
1514  target = stream->EnsureSpace(target);
1515  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(34, this->_internal_use_preprocessing(), target);
1516  }
1517 
1518  // optional bool use_middle_product_form_update = 35 [default = true];
1519  if (cached_has_bits & 0x00000020u) {
1520  target = stream->EnsureSpace(target);
1521  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(35, this->_internal_use_middle_product_form_update(), target);
1522  }
1523 
1524  // optional bool initialize_devex_with_column_norms = 36 [default = true];
1525  if (cached_has_bits & 0x00000040u) {
1526  target = stream->EnsureSpace(target);
1527  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(36, this->_internal_initialize_devex_with_column_norms(), target);
1528  }
1529 
1530  // optional bool exploit_singleton_column_in_initial_basis = 37 [default = true];
1531  if (cached_has_bits & 0x00010000u) {
1532  target = stream->EnsureSpace(target);
1533  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(37, this->_internal_exploit_singleton_column_in_initial_basis(), target);
1534  }
1535 
1536  cached_has_bits = _has_bits_[0];
1537  // optional double dual_small_pivot_threshold = 38 [default = 0.0001];
1538  if (cached_has_bits & 0x80000000u) {
1539  target = stream->EnsureSpace(target);
1540  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(38, this->_internal_dual_small_pivot_threshold(), target);
1541  }
1542 
1543  cached_has_bits = _has_bits_[1];
1544  // optional double preprocessor_zero_tolerance = 39 [default = 1e-09];
1545  if (cached_has_bits & 0x00000001u) {
1546  target = stream->EnsureSpace(target);
1547  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(39, this->_internal_preprocessor_zero_tolerance(), target);
1548  }
1549 
1550  // optional double objective_lower_limit = 40 [default = -inf];
1551  if (cached_has_bits & 0x00000002u) {
1552  target = stream->EnsureSpace(target);
1553  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(40, this->_internal_objective_lower_limit(), target);
1554  }
1555 
1556  // optional double objective_upper_limit = 41 [default = inf];
1557  if (cached_has_bits & 0x00000004u) {
1558  target = stream->EnsureSpace(target);
1559  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(41, this->_internal_objective_upper_limit(), target);
1560  }
1561 
1562  // optional double degenerate_ministep_factor = 42 [default = 0.01];
1563  if (cached_has_bits & 0x00000100u) {
1564  target = stream->EnsureSpace(target);
1565  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(42, this->_internal_degenerate_ministep_factor(), target);
1566  }
1567 
1568  // optional int32 random_seed = 43 [default = 1];
1569  if (cached_has_bits & 0x00000080u) {
1570  target = stream->EnsureSpace(target);
1571  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(43, this->_internal_random_seed(), target);
1572  }
1573 
1574  // optional int32 num_omp_threads = 44 [default = 1];
1575  if (cached_has_bits & 0x00000400u) {
1576  target = stream->EnsureSpace(target);
1577  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(44, this->_internal_num_omp_threads(), target);
1578  }
1579 
1580  // optional double max_deterministic_time = 45 [default = inf];
1581  if (cached_has_bits & 0x00000200u) {
1582  target = stream->EnsureSpace(target);
1583  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(45, this->_internal_max_deterministic_time(), target);
1584  }
1585 
1586  // optional double drop_tolerance = 52 [default = 1e-14];
1587  if (cached_has_bits & 0x00001000u) {
1588  target = stream->EnsureSpace(target);
1589  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(52, this->_internal_drop_tolerance(), target);
1590  }
1591 
1592  cached_has_bits = _has_bits_[0];
1593  // optional bool perturb_costs_in_dual_simplex = 53 [default = false];
1594  if (cached_has_bits & 0x00000004u) {
1595  target = stream->EnsureSpace(target);
1596  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(53, this->_internal_perturb_costs_in_dual_simplex(), target);
1597  }
1598 
1599  cached_has_bits = _has_bits_[1];
1600  // optional double relative_cost_perturbation = 54 [default = 1e-05];
1601  if (cached_has_bits & 0x00002000u) {
1602  target = stream->EnsureSpace(target);
1603  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(54, this->_internal_relative_cost_perturbation(), target);
1604  }
1605 
1606  // optional double relative_max_cost_perturbation = 55 [default = 1e-07];
1607  if (cached_has_bits & 0x00004000u) {
1608  target = stream->EnsureSpace(target);
1609  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(55, this->_internal_relative_max_cost_perturbation(), target);
1610  }
1611 
1612  // optional double max_number_of_reoptimizations = 56 [default = 40];
1613  if (cached_has_bits & 0x00008000u) {
1614  target = stream->EnsureSpace(target);
1615  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(56, this->_internal_max_number_of_reoptimizations(), target);
1616  }
1617 
1618  // optional .operations_research.glop.GlopParameters.ScalingAlgorithm scaling_method = 57 [default = EQUILIBRATION];
1619  if (cached_has_bits & 0x00000800u) {
1620  target = stream->EnsureSpace(target);
1621  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
1622  57, this->_internal_scaling_method(), target);
1623  }
1624 
1625  // optional bool change_status_to_imprecise = 58 [default = true];
1626  if (cached_has_bits & 0x00000008u) {
1627  target = stream->EnsureSpace(target);
1628  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(58, this->_internal_change_status_to_imprecise(), target);
1629  }
1630 
1631  // optional double initial_condition_number_threshold = 59 [default = 1e+50];
1632  if (cached_has_bits & 0x00200000u) {
1633  target = stream->EnsureSpace(target);
1634  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(59, this->_internal_initial_condition_number_threshold(), target);
1635  }
1636 
1637  // optional .operations_research.glop.GlopParameters.CostScalingAlgorithm cost_scaling = 60 [default = CONTAIN_ONE_COST_SCALING];
1638  if (cached_has_bits & 0x00100000u) {
1639  target = stream->EnsureSpace(target);
1640  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
1641  60, this->_internal_cost_scaling(), target);
1642  }
1643 
1644  cached_has_bits = _has_bits_[0];
1645  // optional bool log_search_progress = 61 [default = false];
1646  if (cached_has_bits & 0x00000008u) {
1647  target = stream->EnsureSpace(target);
1648  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(61, this->_internal_log_search_progress(), target);
1649  }
1650 
1651  cached_has_bits = _has_bits_[1];
1652  // optional bool use_dedicated_dual_feasibility_algorithm = 62 [default = true];
1653  if (cached_has_bits & 0x00020000u) {
1654  target = stream->EnsureSpace(target);
1655  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(62, this->_internal_use_dedicated_dual_feasibility_algorithm(), target);
1656  }
1657 
1658  cached_has_bits = _has_bits_[0];
1659  // optional bool dynamically_adjust_refactorization_period = 63 [default = true];
1660  if (cached_has_bits & 0x10000000u) {
1661  target = stream->EnsureSpace(target);
1662  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(63, this->_internal_dynamically_adjust_refactorization_period(), target);
1663  }
1664 
1665  cached_has_bits = _has_bits_[1];
1666  // optional double crossover_bound_snapping_distance = 64 [default = inf];
1667  if (cached_has_bits & 0x00400000u) {
1668  target = stream->EnsureSpace(target);
1669  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(64, this->_internal_crossover_bound_snapping_distance(), target);
1670  }
1671 
1672  // optional bool push_to_vertex = 65 [default = true];
1673  if (cached_has_bits & 0x00080000u) {
1674  target = stream->EnsureSpace(target);
1675  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(65, this->_internal_push_to_vertex(), target);
1676  }
1677 
1678  // optional bool log_to_stdout = 66 [default = true];
1679  if (cached_has_bits & 0x00040000u) {
1680  target = stream->EnsureSpace(target);
1681  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(66, this->_internal_log_to_stdout(), target);
1682  }
1683 
1684  cached_has_bits = _has_bits_[0];
1685  // optional bool use_implied_free_preprocessor = 67 [default = true];
1686  if (cached_has_bits & 0x00000010u) {
1687  target = stream->EnsureSpace(target);
1688  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(67, this->_internal_use_implied_free_preprocessor(), target);
1689  }
1690 
1691  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1692  target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
1693  _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
1694  }
1695  // @@protoc_insertion_point(serialize_to_array_end:operations_research.glop.GlopParameters)
1696  return target;
1697 }
1698 
1699 size_t GlopParameters::ByteSizeLong() const {
1700 // @@protoc_insertion_point(message_byte_size_start:operations_research.glop.GlopParameters)
1701  size_t total_size = 0;
1702 
1703  uint32_t cached_has_bits = 0;
1704  // Prevent compiler warnings about cached_has_bits being unused
1705  (void) cached_has_bits;
1706 
1707  cached_has_bits = _has_bits_[0];
1708  if (cached_has_bits & 0x000000ffu) {
1709  // optional bool use_dual_simplex = 31 [default = false];
1710  if (cached_has_bits & 0x00000001u) {
1711  total_size += 2 + 1;
1712  }
1713 
1714  // optional bool allow_simplex_algorithm_change = 32 [default = false];
1715  if (cached_has_bits & 0x00000002u) {
1716  total_size += 2 + 1;
1717  }
1718 
1719  // optional bool perturb_costs_in_dual_simplex = 53 [default = false];
1720  if (cached_has_bits & 0x00000004u) {
1721  total_size += 2 + 1;
1722  }
1723 
1724  // optional bool log_search_progress = 61 [default = false];
1725  if (cached_has_bits & 0x00000008u) {
1726  total_size += 2 + 1;
1727  }
1728 
1729  // optional bool use_implied_free_preprocessor = 67 [default = true];
1730  if (cached_has_bits & 0x00000010u) {
1731  total_size += 2 + 1;
1732  }
1733 
1734  // optional .operations_research.glop.GlopParameters.PricingRule feasibility_rule = 1 [default = STEEPEST_EDGE];
1735  if (cached_has_bits & 0x00000020u) {
1736  total_size += 1 +
1737  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_feasibility_rule());
1738  }
1739 
1740  // optional .operations_research.glop.GlopParameters.PricingRule optimization_rule = 2 [default = STEEPEST_EDGE];
1741  if (cached_has_bits & 0x00000040u) {
1742  total_size += 1 +
1743  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_optimization_rule());
1744  }
1745 
1746  // optional double refactorization_threshold = 6 [default = 1e-09];
1747  if (cached_has_bits & 0x00000080u) {
1748  total_size += 1 + 8;
1749  }
1750 
1751  }
1752  if (cached_has_bits & 0x0000ff00u) {
1753  // optional double recompute_reduced_costs_threshold = 8 [default = 1e-08];
1754  if (cached_has_bits & 0x00000100u) {
1755  total_size += 1 + 8;
1756  }
1757 
1758  // optional double recompute_edges_norm_threshold = 9 [default = 100];
1759  if (cached_has_bits & 0x00000200u) {
1760  total_size += 1 + 8;
1761  }
1762 
1763  // optional double primal_feasibility_tolerance = 10 [default = 1e-08];
1764  if (cached_has_bits & 0x00000400u) {
1765  total_size += 1 + 8;
1766  }
1767 
1768  // optional double dual_feasibility_tolerance = 11 [default = 1e-08];
1769  if (cached_has_bits & 0x00000800u) {
1770  total_size += 1 + 8;
1771  }
1772 
1773  // optional double ratio_test_zero_threshold = 12 [default = 1e-09];
1774  if (cached_has_bits & 0x00001000u) {
1775  total_size += 1 + 8;
1776  }
1777 
1778  // optional double harris_tolerance_ratio = 13 [default = 0.5];
1779  if (cached_has_bits & 0x00002000u) {
1780  total_size += 1 + 8;
1781  }
1782 
1783  // optional double small_pivot_threshold = 14 [default = 1e-06];
1784  if (cached_has_bits & 0x00004000u) {
1785  total_size += 1 + 8;
1786  }
1787 
1788  // optional double minimum_acceptable_pivot = 15 [default = 1e-06];
1789  if (cached_has_bits & 0x00008000u) {
1790  total_size += 1 + 8;
1791  }
1792 
1793  }
1794  if (cached_has_bits & 0x00ff0000u) {
1795  // optional .operations_research.glop.GlopParameters.InitialBasisHeuristic initial_basis = 17 [default = TRIANGULAR];
1796  if (cached_has_bits & 0x00010000u) {
1797  total_size += 2 +
1798  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_initial_basis());
1799  }
1800 
1801  // optional int32 basis_refactorization_period = 19 [default = 64];
1802  if (cached_has_bits & 0x00020000u) {
1803  total_size += 2 +
1804  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
1805  this->_internal_basis_refactorization_period());
1806  }
1807 
1808  // optional double dualizer_threshold = 21 [default = 1.5];
1809  if (cached_has_bits & 0x00040000u) {
1810  total_size += 2 + 8;
1811  }
1812 
1813  // optional double solution_feasibility_tolerance = 22 [default = 1e-06];
1814  if (cached_has_bits & 0x00080000u) {
1815  total_size += 2 + 8;
1816  }
1817 
1818  // optional .operations_research.glop.GlopParameters.SolverBehavior solve_dual_problem = 20 [default = LET_SOLVER_DECIDE];
1819  if (cached_has_bits & 0x00100000u) {
1820  total_size += 2 +
1821  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_solve_dual_problem());
1822  }
1823 
1824  // optional int32 markowitz_zlatev_parameter = 29 [default = 3];
1825  if (cached_has_bits & 0x00200000u) {
1826  total_size += 2 +
1827  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
1828  this->_internal_markowitz_zlatev_parameter());
1829  }
1830 
1831  // optional double lu_factorization_pivot_threshold = 25 [default = 0.01];
1832  if (cached_has_bits & 0x00400000u) {
1833  total_size += 2 + 8;
1834  }
1835 
1836  // optional double max_time_in_seconds = 26 [default = inf];
1837  if (cached_has_bits & 0x00800000u) {
1838  total_size += 2 + 8;
1839  }
1840 
1841  }
1842  if (cached_has_bits & 0xff000000u) {
1843  // optional int64 max_number_of_iterations = 27 [default = -1];
1844  if (cached_has_bits & 0x01000000u) {
1845  total_size += 2 +
1846  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
1847  this->_internal_max_number_of_iterations());
1848  }
1849 
1850  // optional double markowitz_singularity_threshold = 30 [default = 1e-15];
1851  if (cached_has_bits & 0x02000000u) {
1852  total_size += 2 + 8;
1853  }
1854 
1855  // optional bool use_scaling = 16 [default = true];
1856  if (cached_has_bits & 0x04000000u) {
1857  total_size += 2 + 1;
1858  }
1859 
1860  // optional bool use_transposed_matrix = 18 [default = true];
1861  if (cached_has_bits & 0x08000000u) {
1862  total_size += 2 + 1;
1863  }
1864 
1865  // optional bool dynamically_adjust_refactorization_period = 63 [default = true];
1866  if (cached_has_bits & 0x10000000u) {
1867  total_size += 2 + 1;
1868  }
1869 
1870  // optional bool provide_strong_optimal_guarantee = 24 [default = true];
1871  if (cached_has_bits & 0x20000000u) {
1872  total_size += 2 + 1;
1873  }
1874 
1875  // optional int32 devex_weights_reset_period = 33 [default = 150];
1876  if (cached_has_bits & 0x40000000u) {
1877  total_size += 2 +
1878  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
1879  this->_internal_devex_weights_reset_period());
1880  }
1881 
1882  // optional double dual_small_pivot_threshold = 38 [default = 0.0001];
1883  if (cached_has_bits & 0x80000000u) {
1884  total_size += 2 + 8;
1885  }
1886 
1887  }
1888  cached_has_bits = _has_bits_[1];
1889  if (cached_has_bits & 0x000000ffu) {
1890  // optional double preprocessor_zero_tolerance = 39 [default = 1e-09];
1891  if (cached_has_bits & 0x00000001u) {
1892  total_size += 2 + 8;
1893  }
1894 
1895  // optional double objective_lower_limit = 40 [default = -inf];
1896  if (cached_has_bits & 0x00000002u) {
1897  total_size += 2 + 8;
1898  }
1899 
1900  // optional double objective_upper_limit = 41 [default = inf];
1901  if (cached_has_bits & 0x00000004u) {
1902  total_size += 2 + 8;
1903  }
1904 
1905  // optional bool change_status_to_imprecise = 58 [default = true];
1906  if (cached_has_bits & 0x00000008u) {
1907  total_size += 2 + 1;
1908  }
1909 
1910  // optional bool use_preprocessing = 34 [default = true];
1911  if (cached_has_bits & 0x00000010u) {
1912  total_size += 2 + 1;
1913  }
1914 
1915  // optional bool use_middle_product_form_update = 35 [default = true];
1916  if (cached_has_bits & 0x00000020u) {
1917  total_size += 2 + 1;
1918  }
1919 
1920  // optional bool initialize_devex_with_column_norms = 36 [default = true];
1921  if (cached_has_bits & 0x00000040u) {
1922  total_size += 2 + 1;
1923  }
1924 
1925  // optional int32 random_seed = 43 [default = 1];
1926  if (cached_has_bits & 0x00000080u) {
1927  total_size += 2 +
1928  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
1929  this->_internal_random_seed());
1930  }
1931 
1932  }
1933  if (cached_has_bits & 0x0000ff00u) {
1934  // optional double degenerate_ministep_factor = 42 [default = 0.01];
1935  if (cached_has_bits & 0x00000100u) {
1936  total_size += 2 + 8;
1937  }
1938 
1939  // optional double max_deterministic_time = 45 [default = inf];
1940  if (cached_has_bits & 0x00000200u) {
1941  total_size += 2 + 8;
1942  }
1943 
1944  // optional int32 num_omp_threads = 44 [default = 1];
1945  if (cached_has_bits & 0x00000400u) {
1946  total_size += 2 +
1947  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
1948  this->_internal_num_omp_threads());
1949  }
1950 
1951  // optional .operations_research.glop.GlopParameters.ScalingAlgorithm scaling_method = 57 [default = EQUILIBRATION];
1952  if (cached_has_bits & 0x00000800u) {
1953  total_size += 2 +
1954  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_scaling_method());
1955  }
1956 
1957  // optional double drop_tolerance = 52 [default = 1e-14];
1958  if (cached_has_bits & 0x00001000u) {
1959  total_size += 2 + 8;
1960  }
1961 
1962  // optional double relative_cost_perturbation = 54 [default = 1e-05];
1963  if (cached_has_bits & 0x00002000u) {
1964  total_size += 2 + 8;
1965  }
1966 
1967  // optional double relative_max_cost_perturbation = 55 [default = 1e-07];
1968  if (cached_has_bits & 0x00004000u) {
1969  total_size += 2 + 8;
1970  }
1971 
1972  // optional double max_number_of_reoptimizations = 56 [default = 40];
1973  if (cached_has_bits & 0x00008000u) {
1974  total_size += 2 + 8;
1975  }
1976 
1977  }
1978  if (cached_has_bits & 0x007f0000u) {
1979  // optional bool exploit_singleton_column_in_initial_basis = 37 [default = true];
1980  if (cached_has_bits & 0x00010000u) {
1981  total_size += 2 + 1;
1982  }
1983 
1984  // optional bool use_dedicated_dual_feasibility_algorithm = 62 [default = true];
1985  if (cached_has_bits & 0x00020000u) {
1986  total_size += 2 + 1;
1987  }
1988 
1989  // optional bool log_to_stdout = 66 [default = true];
1990  if (cached_has_bits & 0x00040000u) {
1991  total_size += 2 + 1;
1992  }
1993 
1994  // optional bool push_to_vertex = 65 [default = true];
1995  if (cached_has_bits & 0x00080000u) {
1996  total_size += 2 + 1;
1997  }
1998 
1999  // optional .operations_research.glop.GlopParameters.CostScalingAlgorithm cost_scaling = 60 [default = CONTAIN_ONE_COST_SCALING];
2000  if (cached_has_bits & 0x00100000u) {
2001  total_size += 2 +
2002  ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_cost_scaling());
2003  }
2004 
2005  // optional double initial_condition_number_threshold = 59 [default = 1e+50];
2006  if (cached_has_bits & 0x00200000u) {
2007  total_size += 2 + 8;
2008  }
2009 
2010  // optional double crossover_bound_snapping_distance = 64 [default = inf];
2011  if (cached_has_bits & 0x00400000u) {
2012  total_size += 2 + 8;
2013  }
2014 
2015  }
2016  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
2017 }
2018 
2019 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData GlopParameters::_class_data_ = {
2020  ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
2021  GlopParameters::MergeImpl
2022 };
2023 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GlopParameters::GetClassData() const { return &_class_data_; }
2024 
2025 void GlopParameters::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
2026  const ::PROTOBUF_NAMESPACE_ID::Message& from) {
2027  static_cast<GlopParameters *>(to)->MergeFrom(
2028  static_cast<const GlopParameters &>(from));
2029 }
2030 
2031 
2032 void GlopParameters::MergeFrom(const GlopParameters& from) {
2033 // @@protoc_insertion_point(class_specific_merge_from_start:operations_research.glop.GlopParameters)
2034  GOOGLE_DCHECK_NE(&from, this);
2035  uint32_t cached_has_bits = 0;
2036  (void) cached_has_bits;
2037 
2038  cached_has_bits = from._has_bits_[0];
2039  if (cached_has_bits & 0x000000ffu) {
2040  if (cached_has_bits & 0x00000001u) {
2041  use_dual_simplex_ = from.use_dual_simplex_;
2042  }
2043  if (cached_has_bits & 0x00000002u) {
2044  allow_simplex_algorithm_change_ = from.allow_simplex_algorithm_change_;
2045  }
2046  if (cached_has_bits & 0x00000004u) {
2047  perturb_costs_in_dual_simplex_ = from.perturb_costs_in_dual_simplex_;
2048  }
2049  if (cached_has_bits & 0x00000008u) {
2050  log_search_progress_ = from.log_search_progress_;
2051  }
2052  if (cached_has_bits & 0x00000010u) {
2053  use_implied_free_preprocessor_ = from.use_implied_free_preprocessor_;
2054  }
2055  if (cached_has_bits & 0x00000020u) {
2056  feasibility_rule_ = from.feasibility_rule_;
2057  }
2058  if (cached_has_bits & 0x00000040u) {
2059  optimization_rule_ = from.optimization_rule_;
2060  }
2061  if (cached_has_bits & 0x00000080u) {
2062  refactorization_threshold_ = from.refactorization_threshold_;
2063  }
2064  _has_bits_[0] |= cached_has_bits;
2065  }
2066  if (cached_has_bits & 0x0000ff00u) {
2067  if (cached_has_bits & 0x00000100u) {
2068  recompute_reduced_costs_threshold_ = from.recompute_reduced_costs_threshold_;
2069  }
2070  if (cached_has_bits & 0x00000200u) {
2071  recompute_edges_norm_threshold_ = from.recompute_edges_norm_threshold_;
2072  }
2073  if (cached_has_bits & 0x00000400u) {
2074  primal_feasibility_tolerance_ = from.primal_feasibility_tolerance_;
2075  }
2076  if (cached_has_bits & 0x00000800u) {
2077  dual_feasibility_tolerance_ = from.dual_feasibility_tolerance_;
2078  }
2079  if (cached_has_bits & 0x00001000u) {
2080  ratio_test_zero_threshold_ = from.ratio_test_zero_threshold_;
2081  }
2082  if (cached_has_bits & 0x00002000u) {
2083  harris_tolerance_ratio_ = from.harris_tolerance_ratio_;
2084  }
2085  if (cached_has_bits & 0x00004000u) {
2086  small_pivot_threshold_ = from.small_pivot_threshold_;
2087  }
2088  if (cached_has_bits & 0x00008000u) {
2089  minimum_acceptable_pivot_ = from.minimum_acceptable_pivot_;
2090  }
2091  _has_bits_[0] |= cached_has_bits;
2092  }
2093  if (cached_has_bits & 0x00ff0000u) {
2094  if (cached_has_bits & 0x00010000u) {
2095  initial_basis_ = from.initial_basis_;
2096  }
2097  if (cached_has_bits & 0x00020000u) {
2098  basis_refactorization_period_ = from.basis_refactorization_period_;
2099  }
2100  if (cached_has_bits & 0x00040000u) {
2101  dualizer_threshold_ = from.dualizer_threshold_;
2102  }
2103  if (cached_has_bits & 0x00080000u) {
2104  solution_feasibility_tolerance_ = from.solution_feasibility_tolerance_;
2105  }
2106  if (cached_has_bits & 0x00100000u) {
2107  solve_dual_problem_ = from.solve_dual_problem_;
2108  }
2109  if (cached_has_bits & 0x00200000u) {
2110  markowitz_zlatev_parameter_ = from.markowitz_zlatev_parameter_;
2111  }
2112  if (cached_has_bits & 0x00400000u) {
2113  lu_factorization_pivot_threshold_ = from.lu_factorization_pivot_threshold_;
2114  }
2115  if (cached_has_bits & 0x00800000u) {
2116  max_time_in_seconds_ = from.max_time_in_seconds_;
2117  }
2118  _has_bits_[0] |= cached_has_bits;
2119  }
2120  if (cached_has_bits & 0xff000000u) {
2121  if (cached_has_bits & 0x01000000u) {
2122  max_number_of_iterations_ = from.max_number_of_iterations_;
2123  }
2124  if (cached_has_bits & 0x02000000u) {
2125  markowitz_singularity_threshold_ = from.markowitz_singularity_threshold_;
2126  }
2127  if (cached_has_bits & 0x04000000u) {
2128  use_scaling_ = from.use_scaling_;
2129  }
2130  if (cached_has_bits & 0x08000000u) {
2131  use_transposed_matrix_ = from.use_transposed_matrix_;
2132  }
2133  if (cached_has_bits & 0x10000000u) {
2134  dynamically_adjust_refactorization_period_ = from.dynamically_adjust_refactorization_period_;
2135  }
2136  if (cached_has_bits & 0x20000000u) {
2137  provide_strong_optimal_guarantee_ = from.provide_strong_optimal_guarantee_;
2138  }
2139  if (cached_has_bits & 0x40000000u) {
2140  devex_weights_reset_period_ = from.devex_weights_reset_period_;
2141  }
2142  if (cached_has_bits & 0x80000000u) {
2143  dual_small_pivot_threshold_ = from.dual_small_pivot_threshold_;
2144  }
2145  _has_bits_[0] |= cached_has_bits;
2146  }
2147  cached_has_bits = from._has_bits_[1];
2148  if (cached_has_bits & 0x000000ffu) {
2149  if (cached_has_bits & 0x00000001u) {
2150  preprocessor_zero_tolerance_ = from.preprocessor_zero_tolerance_;
2151  }
2152  if (cached_has_bits & 0x00000002u) {
2153  objective_lower_limit_ = from.objective_lower_limit_;
2154  }
2155  if (cached_has_bits & 0x00000004u) {
2156  objective_upper_limit_ = from.objective_upper_limit_;
2157  }
2158  if (cached_has_bits & 0x00000008u) {
2159  change_status_to_imprecise_ = from.change_status_to_imprecise_;
2160  }
2161  if (cached_has_bits & 0x00000010u) {
2162  use_preprocessing_ = from.use_preprocessing_;
2163  }
2164  if (cached_has_bits & 0x00000020u) {
2165  use_middle_product_form_update_ = from.use_middle_product_form_update_;
2166  }
2167  if (cached_has_bits & 0x00000040u) {
2168  initialize_devex_with_column_norms_ = from.initialize_devex_with_column_norms_;
2169  }
2170  if (cached_has_bits & 0x00000080u) {
2171  random_seed_ = from.random_seed_;
2172  }
2173  _has_bits_[1] |= cached_has_bits;
2174  }
2175  if (cached_has_bits & 0x0000ff00u) {
2176  if (cached_has_bits & 0x00000100u) {
2177  degenerate_ministep_factor_ = from.degenerate_ministep_factor_;
2178  }
2179  if (cached_has_bits & 0x00000200u) {
2180  max_deterministic_time_ = from.max_deterministic_time_;
2181  }
2182  if (cached_has_bits & 0x00000400u) {
2183  num_omp_threads_ = from.num_omp_threads_;
2184  }
2185  if (cached_has_bits & 0x00000800u) {
2186  scaling_method_ = from.scaling_method_;
2187  }
2188  if (cached_has_bits & 0x00001000u) {
2189  drop_tolerance_ = from.drop_tolerance_;
2190  }
2191  if (cached_has_bits & 0x00002000u) {
2192  relative_cost_perturbation_ = from.relative_cost_perturbation_;
2193  }
2194  if (cached_has_bits & 0x00004000u) {
2195  relative_max_cost_perturbation_ = from.relative_max_cost_perturbation_;
2196  }
2197  if (cached_has_bits & 0x00008000u) {
2198  max_number_of_reoptimizations_ = from.max_number_of_reoptimizations_;
2199  }
2200  _has_bits_[1] |= cached_has_bits;
2201  }
2202  if (cached_has_bits & 0x007f0000u) {
2203  if (cached_has_bits & 0x00010000u) {
2204  exploit_singleton_column_in_initial_basis_ = from.exploit_singleton_column_in_initial_basis_;
2205  }
2206  if (cached_has_bits & 0x00020000u) {
2207  use_dedicated_dual_feasibility_algorithm_ = from.use_dedicated_dual_feasibility_algorithm_;
2208  }
2209  if (cached_has_bits & 0x00040000u) {
2210  log_to_stdout_ = from.log_to_stdout_;
2211  }
2212  if (cached_has_bits & 0x00080000u) {
2213  push_to_vertex_ = from.push_to_vertex_;
2214  }
2215  if (cached_has_bits & 0x00100000u) {
2216  cost_scaling_ = from.cost_scaling_;
2217  }
2218  if (cached_has_bits & 0x00200000u) {
2219  initial_condition_number_threshold_ = from.initial_condition_number_threshold_;
2220  }
2221  if (cached_has_bits & 0x00400000u) {
2222  crossover_bound_snapping_distance_ = from.crossover_bound_snapping_distance_;
2223  }
2224  _has_bits_[1] |= cached_has_bits;
2225  }
2226  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
2227 }
2228 
2229 void GlopParameters::CopyFrom(const GlopParameters& from) {
2230 // @@protoc_insertion_point(class_specific_copy_from_start:operations_research.glop.GlopParameters)
2231  if (&from == this) return;
2232  Clear();
2233  MergeFrom(from);
2234 }
2235 
2236 bool GlopParameters::IsInitialized() const {
2237  return true;
2238 }
2239 
2240 void GlopParameters::InternalSwap(GlopParameters* other) {
2241  using std::swap;
2242  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2243  swap(_has_bits_[0], other->_has_bits_[0]);
2244  swap(_has_bits_[1], other->_has_bits_[1]);
2245  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2246  PROTOBUF_FIELD_OFFSET(GlopParameters, log_search_progress_)
2247  + sizeof(GlopParameters::log_search_progress_)
2248  - PROTOBUF_FIELD_OFFSET(GlopParameters, use_dual_simplex_)>(
2249  reinterpret_cast<char*>(&use_dual_simplex_),
2250  reinterpret_cast<char*>(&other->use_dual_simplex_));
2251  swap(use_implied_free_preprocessor_, other->use_implied_free_preprocessor_);
2252  swap(feasibility_rule_, other->feasibility_rule_);
2253  swap(optimization_rule_, other->optimization_rule_);
2254  swap(refactorization_threshold_, other->refactorization_threshold_);
2255  swap(recompute_reduced_costs_threshold_, other->recompute_reduced_costs_threshold_);
2256  swap(recompute_edges_norm_threshold_, other->recompute_edges_norm_threshold_);
2257  swap(primal_feasibility_tolerance_, other->primal_feasibility_tolerance_);
2258  swap(dual_feasibility_tolerance_, other->dual_feasibility_tolerance_);
2259  swap(ratio_test_zero_threshold_, other->ratio_test_zero_threshold_);
2260  swap(harris_tolerance_ratio_, other->harris_tolerance_ratio_);
2261  swap(small_pivot_threshold_, other->small_pivot_threshold_);
2262  swap(minimum_acceptable_pivot_, other->minimum_acceptable_pivot_);
2263  swap(initial_basis_, other->initial_basis_);
2264  swap(basis_refactorization_period_, other->basis_refactorization_period_);
2265  swap(dualizer_threshold_, other->dualizer_threshold_);
2266  swap(solution_feasibility_tolerance_, other->solution_feasibility_tolerance_);
2267  swap(solve_dual_problem_, other->solve_dual_problem_);
2268  swap(markowitz_zlatev_parameter_, other->markowitz_zlatev_parameter_);
2269  swap(lu_factorization_pivot_threshold_, other->lu_factorization_pivot_threshold_);
2270  swap(max_time_in_seconds_, other->max_time_in_seconds_);
2271  swap(max_number_of_iterations_, other->max_number_of_iterations_);
2272  swap(markowitz_singularity_threshold_, other->markowitz_singularity_threshold_);
2273  swap(use_scaling_, other->use_scaling_);
2274  swap(use_transposed_matrix_, other->use_transposed_matrix_);
2275  swap(dynamically_adjust_refactorization_period_, other->dynamically_adjust_refactorization_period_);
2276  swap(provide_strong_optimal_guarantee_, other->provide_strong_optimal_guarantee_);
2277  swap(devex_weights_reset_period_, other->devex_weights_reset_period_);
2278  swap(dual_small_pivot_threshold_, other->dual_small_pivot_threshold_);
2279  swap(preprocessor_zero_tolerance_, other->preprocessor_zero_tolerance_);
2280  swap(objective_lower_limit_, other->objective_lower_limit_);
2281  swap(objective_upper_limit_, other->objective_upper_limit_);
2282  swap(change_status_to_imprecise_, other->change_status_to_imprecise_);
2283  swap(use_preprocessing_, other->use_preprocessing_);
2284  swap(use_middle_product_form_update_, other->use_middle_product_form_update_);
2285  swap(initialize_devex_with_column_norms_, other->initialize_devex_with_column_norms_);
2286  swap(random_seed_, other->random_seed_);
2287  swap(degenerate_ministep_factor_, other->degenerate_ministep_factor_);
2288  swap(max_deterministic_time_, other->max_deterministic_time_);
2289  swap(num_omp_threads_, other->num_omp_threads_);
2290  swap(scaling_method_, other->scaling_method_);
2291  swap(drop_tolerance_, other->drop_tolerance_);
2292  swap(relative_cost_perturbation_, other->relative_cost_perturbation_);
2293  swap(relative_max_cost_perturbation_, other->relative_max_cost_perturbation_);
2294  swap(max_number_of_reoptimizations_, other->max_number_of_reoptimizations_);
2295  swap(exploit_singleton_column_in_initial_basis_, other->exploit_singleton_column_in_initial_basis_);
2296  swap(use_dedicated_dual_feasibility_algorithm_, other->use_dedicated_dual_feasibility_algorithm_);
2297  swap(log_to_stdout_, other->log_to_stdout_);
2298  swap(push_to_vertex_, other->push_to_vertex_);
2299  swap(cost_scaling_, other->cost_scaling_);
2300  swap(initial_condition_number_threshold_, other->initial_condition_number_threshold_);
2301  swap(crossover_bound_snapping_distance_, other->crossover_bound_snapping_distance_);
2302 }
2303 
2304 ::PROTOBUF_NAMESPACE_ID::Metadata GlopParameters::GetMetadata() const {
2305  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
2306  &descriptor_table_ortools_2fglop_2fparameters_2eproto_getter, &descriptor_table_ortools_2fglop_2fparameters_2eproto_once,
2307  file_level_metadata_ortools_2fglop_2fparameters_2eproto[0]);
2308 }
2309 
2310 // @@protoc_insertion_point(namespace_scope)
2311 } // namespace glop
2312 } // namespace operations_research
2313 PROTOBUF_NAMESPACE_OPEN
2314 template<> PROTOBUF_NOINLINE ::operations_research::glop::GlopParameters* Arena::CreateMaybeMessage< ::operations_research::glop::GlopParameters >(Arena* arena) {
2315  return Arena::CreateMessageInternal< ::operations_research::glop::GlopParameters >(arena);
2316 }
2317 PROTOBUF_NAMESPACE_CLOSE
2318 
2319 // @@protoc_insertion_point(global_scope)
2320 #include <google/protobuf/port_undef.inc>
operations_research::glop::GlopParameters::NONE
static constexpr InitialBasisHeuristic NONE
Definition: parameters.pb.h:417
operations_research::glop::GlopParameters::CostScalingAlgorithm_ARRAYSIZE
static constexpr int CostScalingAlgorithm_ARRAYSIZE
Definition: parameters.pb.h:466
operations_research::glop::GlopParameters::MergeFrom
void MergeFrom(const GlopParameters &from)
Definition: parameters.pb.cc:2032
operations_research::glop::GlopParameters::NO_COST_SCALING
static constexpr CostScalingAlgorithm NO_COST_SCALING
Definition: parameters.pb.h:451
operations_research::glop::GlopParameters::_Internal::set_has_basis_refactorization_period
static void set_has_basis_refactorization_period(HasBits *has_bits)
Definition: parameters.pb.cc:496
operations_research::glop::GlopParameters::_Internal::set_has_small_pivot_threshold
static void set_has_small_pivot_threshold(HasBits *has_bits)
Definition: parameters.pb.cc:475
operations_research::glop::GlopParameters_SolverBehavior
GlopParameters_SolverBehavior
Definition: parameters.pb.h:94
operations_research::glop::GlopParameters::NEVER_DO
static constexpr SolverBehavior NEVER_DO
Definition: parameters.pb.h:355
operations_research::glop::GlopParameters::_Internal::set_has_max_number_of_reoptimizations
static void set_has_max_number_of_reoptimizations(HasBits *has_bits)
Definition: parameters.pb.cc:517
operations_research::glop::GlopParametersDefaultTypeInternal::GlopParametersDefaultTypeInternal
constexpr GlopParametersDefaultTypeInternal()
Definition: parameters.pb.cc:85
operations_research::glop::GlopParameters::_Internal::set_has_use_dedicated_dual_feasibility_algorithm
static void set_has_use_dedicated_dual_feasibility_algorithm(HasBits *has_bits)
Definition: parameters.pb.cc:583
file_level_metadata_ortools_2fglop_2fparameters_2eproto
::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_ortools_2fglop_2fparameters_2eproto[1]
Definition: parameters.pb.cc:95
operations_research::glop::GlopParameters::_Internal::set_has_allow_simplex_algorithm_change
static void set_has_allow_simplex_algorithm_change(HasBits *has_bits)
Definition: parameters.pb.cc:541
operations_research::glop::GlopParameters_ScalingAlgorithm
GlopParameters_ScalingAlgorithm
Definition: parameters.pb.h:70
operations_research::glop::GlopParameters::CONTAIN_ONE_COST_SCALING
static constexpr CostScalingAlgorithm CONTAIN_ONE_COST_SCALING
Definition: parameters.pb.h:453
operations_research::glop::GlopParameters::_Internal::set_has_objective_lower_limit
static void set_has_objective_lower_limit(HasBits *has_bits)
Definition: parameters.pb.cc:565
operations_research::glop::GlopParameters::SolverBehavior_MAX
static constexpr SolverBehavior SolverBehavior_MAX
Definition: parameters.pb.h:364
operations_research::glop::GlopParameters::PricingRule_ARRAYSIZE
static constexpr int PricingRule_ARRAYSIZE
Definition: parameters.pb.h:398
operations_research::glop::GlopParameters::_Internal::set_has_markowitz_singularity_threshold
static void set_has_markowitz_singularity_threshold(HasBits *has_bits)
Definition: parameters.pb.cc:535
operations_research::glop::GlopParameters::DEFAULT
static constexpr ScalingAlgorithm DEFAULT
Definition: parameters.pb.h:321
operations_research::glop::GlopParameters::PricingRule_MIN
static constexpr PricingRule PricingRule_MIN
Definition: parameters.pb.h:394
operations_research::glop::GlopParameters::_Internal::set_has_lu_factorization_pivot_threshold
static void set_has_lu_factorization_pivot_threshold(HasBits *has_bits)
Definition: parameters.pb.cc:520
operations_research::glop::GlopParameters::ByteSizeLong
size_t ByteSizeLong() const final
Definition: parameters.pb.cc:1699
operations_research::glop::GlopParameters::IsInitialized
bool IsInitialized() const final
Definition: parameters.pb.cc:2236
operations_research::glop::GlopParameters_PricingRule_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * GlopParameters_PricingRule_descriptor()
Definition: parameters.pb.cc:366
operations_research::glop::GlopParameters::_Internal::set_has_initialize_devex_with_column_norms
static void set_has_initialize_devex_with_column_norms(HasBits *has_bits)
Definition: parameters.pb.cc:553
operations_research::glop::GlopParameters::_Internal::set_has_optimization_rule
static void set_has_optimization_rule(HasBits *has_bits)
Definition: parameters.pb.cc:451
operations_research::glop::GlopParameters_ScalingAlgorithm_IsValid
bool GlopParameters_ScalingAlgorithm_IsValid(int value)
Definition: parameters.pb.cc:324
operations_research::glop::GlopParameters::_Internal::set_has_random_seed
static void set_has_random_seed(HasBits *has_bits)
Definition: parameters.pb.cc:574
operations_research::glop::GlopParameters::_InternalParse
const char * _InternalParse(const char *ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final
Definition: parameters.pb.cc:790
operations_research::glop::GlopParameters::ScalingAlgorithm_ARRAYSIZE
static constexpr int ScalingAlgorithm_ARRAYSIZE
Definition: parameters.pb.h:334
operations_research::glop::GlopParametersDefaultTypeInternal::~GlopParametersDefaultTypeInternal
~GlopParametersDefaultTypeInternal()
Definition: parameters.pb.cc:87
operations_research::glop::GlopParameters::_Internal::set_has_cost_scaling
static void set_has_cost_scaling(HasBits *has_bits)
Definition: parameters.pb.cc:487
operations_research::math_opt::swap
void swap(IdMap< K, V > &a, IdMap< K, V > &b)
Definition: id_map.h:263
operations_research::glop::GlopParameters::_Internal::set_has_refactorization_threshold
static void set_has_refactorization_threshold(HasBits *has_bits)
Definition: parameters.pb.cc:454
operations_research::glop::GlopParameters_PricingRule_IsValid
bool GlopParameters_PricingRule_IsValid(int value)
Definition: parameters.pb.cc:370
operations_research::glop::GlopParameters::_Internal::set_has_feasibility_rule
static void set_has_feasibility_rule(HasBits *has_bits)
Definition: parameters.pb.cc:448
operations_research::glop::GlopParameters::SolverBehavior_ARRAYSIZE
static constexpr int SolverBehavior_ARRAYSIZE
Definition: parameters.pb.h:366
operations_research::glop::GlopParameters_CostScalingAlgorithm_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * GlopParameters_CostScalingAlgorithm_descriptor()
Definition: parameters.pb.cc:414
operations_research::glop::GlopParameters::_Internal::set_has_solution_feasibility_tolerance
static void set_has_solution_feasibility_tolerance(HasBits *has_bits)
Definition: parameters.pb.cc:508
operations_research::glop::GlopParameters::swap
friend void swap(GlopParameters &a, GlopParameters &b)
Definition: parameters.pb.h:251
operations_research::glop::GlopParameters::_Internal::set_has_solve_dual_problem
static void set_has_solve_dual_problem(HasBits *has_bits)
Definition: parameters.pb.cc:502
operations_research::glop::GlopParameters::_Internal::set_has_change_status_to_imprecise
static void set_has_change_status_to_imprecise(HasBits *has_bits)
Definition: parameters.pb.cc:514
operations_research::glop::GlopParameters::_Internal::set_has_use_dual_simplex
static void set_has_use_dual_simplex(HasBits *has_bits)
Definition: parameters.pb.cc:538
operations_research::glop::GlopParameters::_Internal::set_has_max_deterministic_time
static void set_has_max_deterministic_time(HasBits *has_bits)
Definition: parameters.pb.cc:526
PROTOBUF_SECTION_VARIABLE
const uint32_t TableStruct_ortools_2fglop_2fparameters_2eproto::offsets [] PROTOBUF_SECTION_VARIABLE(protodesc_cold)
operations_research::glop::GlopParameters::_Internal::set_has_minimum_acceptable_pivot
static void set_has_minimum_acceptable_pivot(HasBits *has_bits)
Definition: parameters.pb.cc:478
operations_research::glop::GlopParameters::_Internal::set_has_use_preprocessing
static void set_has_use_preprocessing(HasBits *has_bits)
Definition: parameters.pb.cc:547
operations_research::glop::GlopParameters::ScalingAlgorithm_MIN
static constexpr ScalingAlgorithm ScalingAlgorithm_MIN
Definition: parameters.pb.h:330
operations_research::glop::GlopParameters::_Internal::set_has_ratio_test_zero_threshold
static void set_has_ratio_test_zero_threshold(HasBits *has_bits)
Definition: parameters.pb.cc:469
operations_research::glop::GlopParameters::_Internal::set_has_harris_tolerance_ratio
static void set_has_harris_tolerance_ratio(HasBits *has_bits)
Definition: parameters.pb.cc:472
file_level_service_descriptors_ortools_2fglop_2fparameters_2eproto
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const ** file_level_service_descriptors_ortools_2fglop_2fparameters_2eproto
Definition: parameters.pb.cc:97
operations_research::glop::GlopParametersDefaultTypeInternal::_instance
GlopParameters _instance
Definition: parameters.pb.cc:89
operations_research::glop::GlopParameters::MEAN_COST_SCALING
static constexpr CostScalingAlgorithm MEAN_COST_SCALING
Definition: parameters.pb.h:455
operations_research::glop::GlopParameters::_Internal::set_has_max_number_of_iterations
static void set_has_max_number_of_iterations(HasBits *has_bits)
Definition: parameters.pb.cc:529
operations_research::glop::GlopParameters::_Internal::set_has_degenerate_ministep_factor
static void set_has_degenerate_ministep_factor(HasBits *has_bits)
Definition: parameters.pb.cc:571
descriptor_table_ortools_2fglop_2fparameters_2eproto_getter
PROTOBUF_ATTRIBUTE_WEAKconst ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable * descriptor_table_ortools_2fglop_2fparameters_2eproto_getter()
Definition: parameters.pb.cc:312
operations_research::glop::GlopParameters_SolverBehavior_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * GlopParameters_SolverBehavior_descriptor()
Definition: parameters.pb.cc:343
operations_research::glop::GlopParameters::BIXBY
static constexpr InitialBasisHeuristic BIXBY
Definition: parameters.pb.h:419
operations_research::glop::GlopParameters_CostScalingAlgorithm
GlopParameters_CostScalingAlgorithm
Definition: parameters.pb.h:167
operations_research::glop::GlopParameters::_Internal::set_has_max_time_in_seconds
static void set_has_max_time_in_seconds(HasBits *has_bits)
Definition: parameters.pb.cc:523
operations_research::glop::GlopParameters::MAROS
static constexpr InitialBasisHeuristic MAROS
Definition: parameters.pb.h:423
operations_research::glop::GlopParameters_SolverBehavior_IsValid
bool GlopParameters_SolverBehavior_IsValid(int value)
Definition: parameters.pb.cc:347
operations_research::glop::GlopParameters::_Internal::set_has_recompute_reduced_costs_threshold
static void set_has_recompute_reduced_costs_threshold(HasBits *has_bits)
Definition: parameters.pb.cc:457
operations_research::glop::GlopParameters_CostScalingAlgorithm_IsValid
bool GlopParameters_CostScalingAlgorithm_IsValid(int value)
Definition: parameters.pb.cc:418
operations_research::glop::GlopParameters::_Internal::set_has_log_search_progress
static void set_has_log_search_progress(HasBits *has_bits)
Definition: parameters.pb.cc:595
operations_research::glop::GlopParameters::ALWAYS_DO
static constexpr SolverBehavior ALWAYS_DO
Definition: parameters.pb.h:353
operations_research::glop::GlopParameters::_Internal::set_has_perturb_costs_in_dual_simplex
static void set_has_perturb_costs_in_dual_simplex(HasBits *has_bits)
Definition: parameters.pb.cc:580
operations_research::glop::GlopParameters::_Internal::set_has_scaling_method
static void set_has_scaling_method(HasBits *has_bits)
Definition: parameters.pb.cc:445
operations_research::glop::GlopParameters::LET_SOLVER_DECIDE
static constexpr SolverBehavior LET_SOLVER_DECIDE
Definition: parameters.pb.h:357
operations_research::glop::GlopParameters::STEEPEST_EDGE
static constexpr PricingRule STEEPEST_EDGE
Definition: parameters.pb.h:387
operations_research::glop::GlopParameters::_Internal::set_has_relative_cost_perturbation
static void set_has_relative_cost_perturbation(HasBits *has_bits)
Definition: parameters.pb.cc:586
operations_research::glop::GlopParameters::_Internal::set_has_relative_max_cost_perturbation
static void set_has_relative_max_cost_perturbation(HasBits *has_bits)
Definition: parameters.pb.cc:589
operations_research::glop::GlopParameters::SolverBehavior_MIN
static constexpr SolverBehavior SolverBehavior_MIN
Definition: parameters.pb.h:362
operations_research::glop::GlopParameters::_Internal::set_has_objective_upper_limit
static void set_has_objective_upper_limit(HasBits *has_bits)
Definition: parameters.pb.cc:568
operations_research::glop::GlopParameters::_Internal::set_has_push_to_vertex
static void set_has_push_to_vertex(HasBits *has_bits)
Definition: parameters.pb.cc:604
operations_research::glop::GlopParameters::DEVEX
static constexpr PricingRule DEVEX
Definition: parameters.pb.h:389
operations_research::glop::GlopParameters::Clear
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final
Definition: parameters.pb.cc:710
operations_research::glop::GlopParameters::PricingRule_MAX
static constexpr PricingRule PricingRule_MAX
Definition: parameters.pb.h:396
operations_research::glop::GlopParameters::CostScalingAlgorithm_MAX
static constexpr CostScalingAlgorithm CostScalingAlgorithm_MAX
Definition: parameters.pb.h:464
operations_research::glop::GlopParameters::mutable_unknown_fields
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet * mutable_unknown_fields()
Definition: parameters.pb.h:228
operations_research::glop::GlopParameters::GetClassData
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData * GetClassData() const final
Definition: parameters.pb.cc:2023
operations_research::glop::GlopParameters::EQUILIBRATION
static constexpr ScalingAlgorithm EQUILIBRATION
Definition: parameters.pb.h:323
operations_research::glop::GlopParameters::~GlopParameters
~GlopParameters() override
Definition: parameters.pb.cc:689
operations_research::glop::GlopParameters::_Internal::set_has_markowitz_zlatev_parameter
static void set_has_markowitz_zlatev_parameter(HasBits *has_bits)
Definition: parameters.pb.cc:532
operations_research::glop::GlopParameters::LINEAR_PROGRAM
static constexpr ScalingAlgorithm LINEAR_PROGRAM
Definition: parameters.pb.h:325
operations_research::glop::GlopParameters::_Internal
Definition: parameters.pb.cc:442
operations_research::glop::GlopParameters::CopyFrom
void CopyFrom(const GlopParameters &from)
Definition: parameters.pb.cc:2229
operations_research::glop::GlopParameters::GlopParameters
GlopParameters()
Definition: parameters.pb.h:197
operations_research::glop::GlopParameters::_Internal::set_has_initial_condition_number_threshold
static void set_has_initial_condition_number_threshold(HasBits *has_bits)
Definition: parameters.pb.cc:592
operations_research::glop::GlopParametersDefaultTypeInternal
Definition: parameters.pb.cc:84
operations_research::glop::GlopParameters_InitialBasisHeuristic
GlopParameters_InitialBasisHeuristic
Definition: parameters.pb.h:142
operations_research::glop::GlopParameters::TRIANGULAR
static constexpr InitialBasisHeuristic TRIANGULAR
Definition: parameters.pb.h:421
operations_research::glop::GlopParameters::_Internal::set_has_primal_feasibility_tolerance
static void set_has_primal_feasibility_tolerance(HasBits *has_bits)
Definition: parameters.pb.cc:463
descriptor_table_ortools_2fglop_2fparameters_2eproto
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ortools_2fglop_2fparameters_2eproto
Definition: parameters.pb.cc:306
descriptor_table_ortools_2fglop_2fparameters_2eproto_once
::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_ortools_2fglop_2fparameters_2eproto_once
Definition: parameters.pb.cc:305
operations_research::glop::GlopParameters::_Internal::set_has_dynamically_adjust_refactorization_period
static void set_has_dynamically_adjust_refactorization_period(HasBits *has_bits)
Definition: parameters.pb.cc:499
file_level_enum_descriptors_ortools_2fglop_2fparameters_2eproto
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * file_level_enum_descriptors_ortools_2fglop_2fparameters_2eproto[5]
Definition: parameters.pb.cc:96
operations_research::glop::GlopParameters::_Internal::set_has_initial_basis
static void set_has_initial_basis(HasBits *has_bits)
Definition: parameters.pb.cc:490
operations_research::glop::GlopParameters::_Internal::set_has_drop_tolerance
static void set_has_drop_tolerance(HasBits *has_bits)
Definition: parameters.pb.cc:481
operations_research::glop::GlopParameters::_Internal::set_has_log_to_stdout
static void set_has_log_to_stdout(HasBits *has_bits)
Definition: parameters.pb.cc:598
operations_research::glop::GlopParameters_PricingRule
GlopParameters_PricingRule
Definition: parameters.pb.h:118
operations_research::glop::GlopParameters::_Internal::set_has_use_implied_free_preprocessor
static void set_has_use_implied_free_preprocessor(HasBits *has_bits)
Definition: parameters.pb.cc:607
operations_research::glop::GlopParameters::_Internal::set_has_provide_strong_optimal_guarantee
static void set_has_provide_strong_optimal_guarantee(HasBits *has_bits)
Definition: parameters.pb.cc:511
operations_research::glop::GlopParameters::GetMetadata
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final
Definition: parameters.pb.cc:2304
TableStruct_ortools_2fglop_2fparameters_2eproto::offsets
static const uint32_t offsets[]
Definition: parameters.pb.h:54
operations_research::glop::GlopParameters::DANTZIG
static constexpr PricingRule DANTZIG
Definition: parameters.pb.h:385
CHK_
#define CHK_(x)
CreateMaybeMessage< ::operations_research::glop::GlopParameters >
PROTOBUF_NAMESPACE_OPEN PROTOBUF_NOINLINE ::operations_research::glop::GlopParameters * Arena::CreateMaybeMessage< ::operations_research::glop::GlopParameters >(Arena *arena)
Definition: parameters.pb.cc:2314
operations_research::glop::GlopParameters::InitialBasisHeuristic_ARRAYSIZE
static constexpr int InitialBasisHeuristic_ARRAYSIZE
Definition: parameters.pb.h:432
file_default_instances
::PROTOBUF_NAMESPACE_ID::Message const *const file_default_instances[]
Definition: parameters.pb.cc:221
operations_research::glop::GlopParameters::ScalingAlgorithm_MAX
static constexpr ScalingAlgorithm ScalingAlgorithm_MAX
Definition: parameters.pb.h:332
operations_research::glop::GlopParameters::_InternalSerialize
uint8_t * _InternalSerialize(uint8_t *target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final
Definition: parameters.pb.cc:1338
operations_research::glop::GlopParameters::_Internal::set_has_recompute_edges_norm_threshold
static void set_has_recompute_edges_norm_threshold(HasBits *has_bits)
Definition: parameters.pb.cc:460
operations_research::glop::GlopParameters::CostScalingAlgorithm_MIN
static constexpr CostScalingAlgorithm CostScalingAlgorithm_MIN
Definition: parameters.pb.h:462
operations_research
Collection of objects used to extend the Constraint Solver library.
Definition: dense_doubly_linked_list.h:21
operations_research::glop::GlopParameters::_class_data_
static const ClassData _class_data_
Definition: parameters.pb.h:313
operations_research::glop::GlopParameters_InitialBasisHeuristic_IsValid
bool GlopParameters_InitialBasisHeuristic_IsValid(int value)
Definition: parameters.pb.cc:393
operations_research::glop::GlopParameters::_Internal::set_has_use_transposed_matrix
static void set_has_use_transposed_matrix(HasBits *has_bits)
Definition: parameters.pb.cc:493
operations_research::glop::GlopParameters::_Internal::set_has_dualizer_threshold
static void set_has_dualizer_threshold(HasBits *has_bits)
Definition: parameters.pb.cc:505
operations_research::glop::GlopParameters::_Internal::set_has_exploit_singleton_column_in_initial_basis
static void set_has_exploit_singleton_column_in_initial_basis(HasBits *has_bits)
Definition: parameters.pb.cc:556
operations_research::glop::_GlopParameters_default_instance_
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT GlopParametersDefaultTypeInternal _GlopParameters_default_instance_
Definition: parameters.pb.cc:92
operations_research::glop::GlopParameters::_Internal::HasBits
decltype(std::declval< GlopParameters >()._has_bits_) HasBits
Definition: parameters.pb.cc:444
operations_research::glop::GlopParameters::_Internal::set_has_use_middle_product_form_update
static void set_has_use_middle_product_form_update(HasBits *has_bits)
Definition: parameters.pb.cc:550
operations_research::glop::GlopParameters_ScalingAlgorithm_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * GlopParameters_ScalingAlgorithm_descriptor()
Definition: parameters.pb.cc:320
schemas
static constexpr ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema * schemas
Definition: optional_boolean.pb.cc:24
operations_research::glop::GlopParameters::_Internal::set_has_preprocessor_zero_tolerance
static void set_has_preprocessor_zero_tolerance(HasBits *has_bits)
Definition: parameters.pb.cc:562
operations_research::glop::GlopParameters::_Internal::set_has_dual_feasibility_tolerance
static void set_has_dual_feasibility_tolerance(HasBits *has_bits)
Definition: parameters.pb.cc:466
operations_research::glop::GlopParameters::MEDIAN_COST_SCALING
static constexpr CostScalingAlgorithm MEDIAN_COST_SCALING
Definition: parameters.pb.h:457
operations_research::glop::GlopParameters::_Internal::set_has_dual_small_pivot_threshold
static void set_has_dual_small_pivot_threshold(HasBits *has_bits)
Definition: parameters.pb.cc:559
operations_research::glop::GlopParameters::InitialBasisHeuristic_MIN
static constexpr InitialBasisHeuristic InitialBasisHeuristic_MIN
Definition: parameters.pb.h:428
operations_research::glop::GlopParameters::InitialBasisHeuristic_MAX
static constexpr InitialBasisHeuristic InitialBasisHeuristic_MAX
Definition: parameters.pb.h:430
operations_research::glop::GlopParameters
Definition: parameters.pb.h:194
value
int64_t value
Definition: demon_profiler.cc:44
operations_research::glop::GlopParameters::_Internal::set_has_num_omp_threads
static void set_has_num_omp_threads(HasBits *has_bits)
Definition: parameters.pb.cc:577
operations_research::glop::GlopParameters_InitialBasisHeuristic_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * GlopParameters_InitialBasisHeuristic_descriptor()
Definition: parameters.pb.cc:389
operations_research::glop::GlopParameters::_Internal::set_has_use_scaling
static void set_has_use_scaling(HasBits *has_bits)
Definition: parameters.pb.cc:484
operations_research::glop::GlopParameters::_Internal::set_has_devex_weights_reset_period
static void set_has_devex_weights_reset_period(HasBits *has_bits)
Definition: parameters.pb.cc:544
operations_research::glop::GlopParameters::_Internal::set_has_crossover_bound_snapping_distance
static void set_has_crossover_bound_snapping_distance(HasBits *has_bits)
Definition: parameters.pb.cc:601