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