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