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