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