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