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