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