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