Google OR-Tools v9.14
a fast and portable software suite for combinatorial optimization
Loading...
Searching...
No Matches
Parameters.pb.cs
Go to the documentation of this file.
1// <auto-generated>
2// Generated by the protocol buffer compiler. DO NOT EDIT!
3// source: ortools/glop/parameters.proto
4// </auto-generated>
5#pragma warning disable 1591, 0612, 3021, 8981
6#region Designer generated code
7
8using pb = global::Google.Protobuf;
9using pbc = global::Google.Protobuf.Collections;
10using pbr = global::Google.Protobuf.Reflection;
11using scg = global::System.Collections.Generic;
13
15 public static partial class ParametersReflection {
16
17 #region Descriptor
19 public static pbr::FileDescriptor Descriptor {
20 get { return descriptor; }
21 }
22 private static pbr::FileDescriptor descriptor;
23
24 static ParametersReflection() {
25 byte[] descriptorData = global::System.Convert.FromBase64String(
26 string.Concat(
27 "Ch1vcnRvb2xzL2dsb3AvcGFyYW1ldGVycy5wcm90bxIYb3BlcmF0aW9uc19y",
28 "ZXNlYXJjaC5nbG9wIvAYCg5HbG9wUGFyYW1ldGVycxJgCg5zY2FsaW5nX21l",
29 "dGhvZBg5IAEoDjI5Lm9wZXJhdGlvbnNfcmVzZWFyY2guZ2xvcC5HbG9wUGFy",
30 "YW1ldGVycy5TY2FsaW5nQWxnb3JpdGhtOg1FUVVJTElCUkFUSU9OEl0KEGZl",
31 "YXNpYmlsaXR5X3J1bGUYASABKA4yNC5vcGVyYXRpb25zX3Jlc2VhcmNoLmds",
32 "b3AuR2xvcFBhcmFtZXRlcnMuUHJpY2luZ1J1bGU6DVNURUVQRVNUX0VER0US",
33 "XgoRb3B0aW1pemF0aW9uX3J1bGUYAiABKA4yNC5vcGVyYXRpb25zX3Jlc2Vh",
34 "cmNoLmdsb3AuR2xvcFBhcmFtZXRlcnMuUHJpY2luZ1J1bGU6DVNURUVQRVNU",
35 "X0VER0USKAoZcmVmYWN0b3JpemF0aW9uX3RocmVzaG9sZBgGIAEoAToFMWUt",
36 "MDkSMAohcmVjb21wdXRlX3JlZHVjZWRfY29zdHNfdGhyZXNob2xkGAggASgB",
37 "OgUxZS0wOBIrCh5yZWNvbXB1dGVfZWRnZXNfbm9ybV90aHJlc2hvbGQYCSAB",
38 "KAE6AzEwMBIrChxwcmltYWxfZmVhc2liaWxpdHlfdG9sZXJhbmNlGAogASgB",
39 "OgUxZS0wOBIpChpkdWFsX2ZlYXNpYmlsaXR5X3RvbGVyYW5jZRgLIAEoAToF",
40 "MWUtMDgSKAoZcmF0aW9fdGVzdF96ZXJvX3RocmVzaG9sZBgMIAEoAToFMWUt",
41 "MDkSIwoWaGFycmlzX3RvbGVyYW5jZV9yYXRpbxgNIAEoAToDMC41EiQKFXNt",
42 "YWxsX3Bpdm90X3RocmVzaG9sZBgOIAEoAToFMWUtMDYSJwoYbWluaW11bV9h",
43 "Y2NlcHRhYmxlX3Bpdm90GA8gASgBOgUxZS0wNhIdCg5kcm9wX3RvbGVyYW5j",
44 "ZRg0IAEoAToFMWUtMTQSGQoLdXNlX3NjYWxpbmcYECABKAg6BHRydWUSbQoM",
45 "Y29zdF9zY2FsaW5nGDwgASgOMj0ub3BlcmF0aW9uc19yZXNlYXJjaC5nbG9w",
46 "Lkdsb3BQYXJhbWV0ZXJzLkNvc3RTY2FsaW5nQWxnb3JpdGhtOhhDT05UQUlO",
47 "X09ORV9DT1NUX1NDQUxJTkcSYQoNaW5pdGlhbF9iYXNpcxgRIAEoDjI+Lm9w",
48 "ZXJhdGlvbnNfcmVzZWFyY2guZ2xvcC5HbG9wUGFyYW1ldGVycy5Jbml0aWFs",
49 "QmFzaXNIZXVyaXN0aWM6ClRSSUFOR1VMQVISIwoVdXNlX3RyYW5zcG9zZWRf",
50 "bWF0cml4GBIgASgIOgR0cnVlEigKHGJhc2lzX3JlZmFjdG9yaXphdGlvbl9w",
51 "ZXJpb2QYEyABKAU6AjY0EjcKKWR5bmFtaWNhbGx5X2FkanVzdF9yZWZhY3Rv",
52 "cml6YXRpb25fcGVyaW9kGD8gASgIOgR0cnVlEmYKEnNvbHZlX2R1YWxfcHJv",
53 "YmxlbRgUIAEoDjI3Lm9wZXJhdGlvbnNfcmVzZWFyY2guZ2xvcC5HbG9wUGFy",
54 "YW1ldGVycy5Tb2x2ZXJCZWhhdmlvcjoRTEVUX1NPTFZFUl9ERUNJREUSHwoS",
55 "ZHVhbGl6ZXJfdGhyZXNob2xkGBUgASgBOgMxLjUSLQoec29sdXRpb25fZmVh",
56 "c2liaWxpdHlfdG9sZXJhbmNlGBYgASgBOgUxZS0wNhIuCiBwcm92aWRlX3N0",
57 "cm9uZ19vcHRpbWFsX2d1YXJhbnRlZRgYIAEoCDoEdHJ1ZRIoChpjaGFuZ2Vf",
58 "c3RhdHVzX3RvX2ltcHJlY2lzZRg6IAEoCDoEdHJ1ZRIpCh1tYXhfbnVtYmVy",
59 "X29mX3Jlb3B0aW1pemF0aW9ucxg4IAEoAToCNDASLgogbHVfZmFjdG9yaXph",
60 "dGlvbl9waXZvdF90aHJlc2hvbGQYGSABKAE6BDAuMDESIAoTbWF4X3RpbWVf",
61 "aW5fc2Vjb25kcxgaIAEoAToDaW5mEiMKFm1heF9kZXRlcm1pbmlzdGljX3Rp",
62 "bWUYLSABKAE6A2luZhIkChhtYXhfbnVtYmVyX29mX2l0ZXJhdGlvbnMYGyAB",
63 "KAM6Ai0xEiUKGm1hcmtvd2l0el96bGF0ZXZfcGFyYW1ldGVyGB0gASgFOgEz",
64 "Ei4KH21hcmtvd2l0el9zaW5ndWxhcml0eV90aHJlc2hvbGQYHiABKAE6BTFl",
65 "LTE1Eh8KEHVzZV9kdWFsX3NpbXBsZXgYHyABKAg6BWZhbHNlEi0KHmFsbG93",
66 "X3NpbXBsZXhfYWxnb3JpdGhtX2NoYW5nZRggIAEoCDoFZmFsc2USJwoaZGV2",
67 "ZXhfd2VpZ2h0c19yZXNldF9wZXJpb2QYISABKAU6AzE1MBIfChF1c2VfcHJl",
68 "cHJvY2Vzc2luZxgiIAEoCDoEdHJ1ZRIsCh51c2VfbWlkZGxlX3Byb2R1Y3Rf",
69 "Zm9ybV91cGRhdGUYIyABKAg6BHRydWUSMAoiaW5pdGlhbGl6ZV9kZXZleF93",
70 "aXRoX2NvbHVtbl9ub3JtcxgkIAEoCDoEdHJ1ZRI3CilleHBsb2l0X3Npbmds",
71 "ZXRvbl9jb2x1bW5faW5faW5pdGlhbF9iYXNpcxglIAEoCDoEdHJ1ZRIqChpk",
72 "dWFsX3NtYWxsX3Bpdm90X3RocmVzaG9sZBgmIAEoAToGMC4wMDAxEioKG3By",
73 "ZXByb2Nlc3Nvcl96ZXJvX3RvbGVyYW5jZRgnIAEoAToFMWUtMDkSIwoVb2Jq",
74 "ZWN0aXZlX2xvd2VyX2xpbWl0GCggASgBOgQtaW5mEiIKFW9iamVjdGl2ZV91",
75 "cHBlcl9saW1pdBgpIAEoAToDaW5mEigKGmRlZ2VuZXJhdGVfbWluaXN0ZXBf",
76 "ZmFjdG9yGCogASgBOgQwLjAxEhYKC3JhbmRvbV9zZWVkGCsgASgFOgExEh4K",
77 "D3VzZV9hYnNsX3JhbmRvbRhIIAEoCDoFZmFsc2USGgoPbnVtX29tcF90aHJl",
78 "YWRzGCwgASgFOgExEiwKHXBlcnR1cmJfY29zdHNfaW5fZHVhbF9zaW1wbGV4",
79 "GDUgASgIOgVmYWxzZRI2Cih1c2VfZGVkaWNhdGVkX2R1YWxfZmVhc2liaWxp",
80 "dHlfYWxnb3JpdGhtGD4gASgIOgR0cnVlEikKGnJlbGF0aXZlX2Nvc3RfcGVy",
81 "dHVyYmF0aW9uGDYgASgBOgUxZS0wNRItCh5yZWxhdGl2ZV9tYXhfY29zdF9w",
82 "ZXJ0dXJiYXRpb24YNyABKAE6BTFlLTA3EjEKImluaXRpYWxfY29uZGl0aW9u",
83 "X251bWJlcl90aHJlc2hvbGQYOyABKAE6BTFlKzUwEiIKE2xvZ19zZWFyY2hf",
84 "cHJvZ3Jlc3MYPSABKAg6BWZhbHNlEhsKDWxvZ190b19zdGRvdXQYQiABKAg6",
85 "BHRydWUSLgohY3Jvc3NvdmVyX2JvdW5kX3NuYXBwaW5nX2Rpc3RhbmNlGEAg",
86 "ASgBOgNpbmYSHAoOcHVzaF90b192ZXJ0ZXgYQSABKAg6BHRydWUSKwoddXNl",
87 "X2ltcGxpZWRfZnJlZV9wcmVwcm9jZXNzb3IYQyABKAg6BHRydWUSIgoTbWF4",
88 "X3ZhbGlkX21hZ25pdHVkZRhGIAEoAToFMWUrMzASHQoOZHJvcF9tYWduaXR1",
89 "ZGUYRyABKAE6BTFlLTMwEikKGmR1YWxfcHJpY2VfcHJpb3JpdGl6ZV9ub3Jt",
90 "GEUgASgIOgVmYWxzZSJGChBTY2FsaW5nQWxnb3JpdGhtEgsKB0RFRkFVTFQQ",
91 "ABIRCg1FUVVJTElCUkFUSU9OEAESEgoOTElORUFSX1BST0dSQU0QAiJECg5T",
92 "b2x2ZXJCZWhhdmlvchINCglBTFdBWVNfRE8QABIMCghORVZFUl9ETxABEhUK",
93 "EUxFVF9TT0xWRVJfREVDSURFEAIiOAoLUHJpY2luZ1J1bGUSCwoHREFOVFpJ",
94 "RxAAEhEKDVNURUVQRVNUX0VER0UQARIJCgVERVZFWBACIkcKFUluaXRpYWxC",
95 "YXNpc0hldXJpc3RpYxIICgROT05FEAASCQoFQklYQlkQARIOCgpUUklBTkdV",
96 "TEFSEAISCQoFTUFST1MQAyJ5ChRDb3N0U2NhbGluZ0FsZ29yaXRobRITCg9O",
97 "T19DT1NUX1NDQUxJTkcQABIcChhDT05UQUlOX09ORV9DT1NUX1NDQUxJTkcQ",
98 "ARIVChFNRUFOX0NPU1RfU0NBTElORxACEhcKE01FRElBTl9DT1NUX1NDQUxJ",
99 "TkcQA0IxChdjb20uZ29vZ2xlLm9ydG9vbHMuZ2xvcFABqgITR29vZ2xlLk9y",
100 "VG9vbHMuR2xvcA=="));
101 descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
102 new pbr::FileDescriptor[] { },
103 new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
104 new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Glop.GlopParameters), global::Google.OrTools.Glop.GlopParameters.Parser, new[]{ "ScalingMethod", "FeasibilityRule", "OptimizationRule", "RefactorizationThreshold", "RecomputeReducedCostsThreshold", "RecomputeEdgesNormThreshold", "PrimalFeasibilityTolerance", "DualFeasibilityTolerance", "RatioTestZeroThreshold", "HarrisToleranceRatio", "SmallPivotThreshold", "MinimumAcceptablePivot", "DropTolerance", "UseScaling", "CostScaling", "InitialBasis", "UseTransposedMatrix", "BasisRefactorizationPeriod", "DynamicallyAdjustRefactorizationPeriod", "SolveDualProblem", "DualizerThreshold", "SolutionFeasibilityTolerance", "ProvideStrongOptimalGuarantee", "ChangeStatusToImprecise", "MaxNumberOfReoptimizations", "LuFactorizationPivotThreshold", "MaxTimeInSeconds", "MaxDeterministicTime", "MaxNumberOfIterations", "MarkowitzZlatevParameter", "MarkowitzSingularityThreshold", "UseDualSimplex", "AllowSimplexAlgorithmChange", "DevexWeightsResetPeriod", "UsePreprocessing", "UseMiddleProductFormUpdate", "InitializeDevexWithColumnNorms", "ExploitSingletonColumnInInitialBasis", "DualSmallPivotThreshold", "PreprocessorZeroTolerance", "ObjectiveLowerLimit", "ObjectiveUpperLimit", "DegenerateMinistepFactor", "RandomSeed", "UseAbslRandom", "NumOmpThreads", "PerturbCostsInDualSimplex", "UseDedicatedDualFeasibilityAlgorithm", "RelativeCostPerturbation", "RelativeMaxCostPerturbation", "InitialConditionNumberThreshold", "LogSearchProgress", "LogToStdout", "CrossoverBoundSnappingDistance", "PushToVertex", "UseImpliedFreePreprocessor", "MaxValidMagnitude", "DropMagnitude", "DualPricePrioritizeNorm" }, null, new[]{ typeof(global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm), typeof(global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior), typeof(global::Google.OrTools.Glop.GlopParameters.Types.PricingRule), typeof(global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic), typeof(global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm) }, null, null)
105 }));
106 }
107 #endregion
108
109 }
110 #region Messages
114 [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")]
115 public sealed partial class GlopParameters : pb::IMessage<GlopParameters>
116 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
117 , pb::IBufferMessage
118 #endif
119 {
120 private static readonly pb::MessageParser<GlopParameters> _parser = new pb::MessageParser<GlopParameters>(() => new GlopParameters());
121 private pb::UnknownFieldSet _unknownFields;
122 private int _hasBits0;
123 private int _hasBits1;
124 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
125 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
126 public static pb::MessageParser<GlopParameters> Parser { get { return _parser; } }
127
128 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
129 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
130 public static pbr::MessageDescriptor Descriptor {
131 get { return global::Google.OrTools.Glop.ParametersReflection.Descriptor.MessageTypes[0]; }
132 }
133
134 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
135 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
136 pbr::MessageDescriptor pb::IMessage.Descriptor {
137 get { return Descriptor; }
138 }
139
140 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
141 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
142 public GlopParameters() {
143 OnConstruction();
144 }
145
146 partial void OnConstruction();
147
148 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
149 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
150 public GlopParameters(GlopParameters other) : this() {
151 _hasBits0 = other._hasBits0;
152 _hasBits1 = other._hasBits1;
153 scalingMethod_ = other.scalingMethod_;
154 feasibilityRule_ = other.feasibilityRule_;
155 optimizationRule_ = other.optimizationRule_;
156 refactorizationThreshold_ = other.refactorizationThreshold_;
157 recomputeReducedCostsThreshold_ = other.recomputeReducedCostsThreshold_;
158 recomputeEdgesNormThreshold_ = other.recomputeEdgesNormThreshold_;
159 primalFeasibilityTolerance_ = other.primalFeasibilityTolerance_;
160 dualFeasibilityTolerance_ = other.dualFeasibilityTolerance_;
161 ratioTestZeroThreshold_ = other.ratioTestZeroThreshold_;
162 harrisToleranceRatio_ = other.harrisToleranceRatio_;
163 smallPivotThreshold_ = other.smallPivotThreshold_;
164 minimumAcceptablePivot_ = other.minimumAcceptablePivot_;
165 dropTolerance_ = other.dropTolerance_;
166 useScaling_ = other.useScaling_;
167 costScaling_ = other.costScaling_;
168 initialBasis_ = other.initialBasis_;
169 useTransposedMatrix_ = other.useTransposedMatrix_;
170 basisRefactorizationPeriod_ = other.basisRefactorizationPeriod_;
171 dynamicallyAdjustRefactorizationPeriod_ = other.dynamicallyAdjustRefactorizationPeriod_;
172 solveDualProblem_ = other.solveDualProblem_;
173 dualizerThreshold_ = other.dualizerThreshold_;
174 solutionFeasibilityTolerance_ = other.solutionFeasibilityTolerance_;
175 provideStrongOptimalGuarantee_ = other.provideStrongOptimalGuarantee_;
176 changeStatusToImprecise_ = other.changeStatusToImprecise_;
177 maxNumberOfReoptimizations_ = other.maxNumberOfReoptimizations_;
178 luFactorizationPivotThreshold_ = other.luFactorizationPivotThreshold_;
179 maxTimeInSeconds_ = other.maxTimeInSeconds_;
180 maxDeterministicTime_ = other.maxDeterministicTime_;
181 maxNumberOfIterations_ = other.maxNumberOfIterations_;
182 markowitzZlatevParameter_ = other.markowitzZlatevParameter_;
183 markowitzSingularityThreshold_ = other.markowitzSingularityThreshold_;
184 useDualSimplex_ = other.useDualSimplex_;
185 allowSimplexAlgorithmChange_ = other.allowSimplexAlgorithmChange_;
186 devexWeightsResetPeriod_ = other.devexWeightsResetPeriod_;
187 usePreprocessing_ = other.usePreprocessing_;
188 useMiddleProductFormUpdate_ = other.useMiddleProductFormUpdate_;
189 initializeDevexWithColumnNorms_ = other.initializeDevexWithColumnNorms_;
190 exploitSingletonColumnInInitialBasis_ = other.exploitSingletonColumnInInitialBasis_;
191 dualSmallPivotThreshold_ = other.dualSmallPivotThreshold_;
192 preprocessorZeroTolerance_ = other.preprocessorZeroTolerance_;
193 objectiveLowerLimit_ = other.objectiveLowerLimit_;
194 objectiveUpperLimit_ = other.objectiveUpperLimit_;
195 degenerateMinistepFactor_ = other.degenerateMinistepFactor_;
196 randomSeed_ = other.randomSeed_;
197 useAbslRandom_ = other.useAbslRandom_;
198 numOmpThreads_ = other.numOmpThreads_;
199 perturbCostsInDualSimplex_ = other.perturbCostsInDualSimplex_;
200 useDedicatedDualFeasibilityAlgorithm_ = other.useDedicatedDualFeasibilityAlgorithm_;
201 relativeCostPerturbation_ = other.relativeCostPerturbation_;
202 relativeMaxCostPerturbation_ = other.relativeMaxCostPerturbation_;
203 initialConditionNumberThreshold_ = other.initialConditionNumberThreshold_;
204 logSearchProgress_ = other.logSearchProgress_;
205 logToStdout_ = other.logToStdout_;
206 crossoverBoundSnappingDistance_ = other.crossoverBoundSnappingDistance_;
207 pushToVertex_ = other.pushToVertex_;
208 useImpliedFreePreprocessor_ = other.useImpliedFreePreprocessor_;
209 maxValidMagnitude_ = other.maxValidMagnitude_;
210 dropMagnitude_ = other.dropMagnitude_;
211 dualPricePrioritizeNorm_ = other.dualPricePrioritizeNorm_;
212 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
213 }
214
215 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
216 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
218 return new GlopParameters(this);
219 }
220
222 public const int ScalingMethodFieldNumber = 57;
223 private readonly static global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm ScalingMethodDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm.Equilibration;
224
225 private global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm scalingMethod_;
226 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
227 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
229 get { if ((_hasBits1 & 4096) != 0) { return scalingMethod_; } else { return ScalingMethodDefaultValue; } }
230 set {
231 _hasBits1 |= 4096;
232 scalingMethod_ = value;
233 }
234 }
235
236 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
237 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
238 public bool HasScalingMethod {
239 get { return (_hasBits1 & 4096) != 0; }
240 }
241
242 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
243 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
244 public void ClearScalingMethod() {
245 _hasBits1 &= ~4096;
246 }
247
249 public const int FeasibilityRuleFieldNumber = 1;
250 private readonly static global::Google.OrTools.Glop.GlopParameters.Types.PricingRule FeasibilityRuleDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.PricingRule.SteepestEdge;
251
252 private global::Google.OrTools.Glop.GlopParameters.Types.PricingRule feasibilityRule_;
256 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
257 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
259 get { if ((_hasBits0 & 1) != 0) { return feasibilityRule_; } else { return FeasibilityRuleDefaultValue; } }
260 set {
261 _hasBits0 |= 1;
262 feasibilityRule_ = value;
263 }
264 }
265
266 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
267 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
268 public bool HasFeasibilityRule {
269 get { return (_hasBits0 & 1) != 0; }
270 }
271
272 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
273 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
274 public void ClearFeasibilityRule() {
275 _hasBits0 &= ~1;
276 }
277
279 public const int OptimizationRuleFieldNumber = 2;
280 private readonly static global::Google.OrTools.Glop.GlopParameters.Types.PricingRule OptimizationRuleDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.PricingRule.SteepestEdge;
281
282 private global::Google.OrTools.Glop.GlopParameters.Types.PricingRule optimizationRule_;
286 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
287 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
289 get { if ((_hasBits0 & 2) != 0) { return optimizationRule_; } else { return OptimizationRuleDefaultValue; } }
290 set {
291 _hasBits0 |= 2;
292 optimizationRule_ = value;
293 }
294 }
295
296 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
297 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
299 get { return (_hasBits0 & 2) != 0; }
300 }
301
302 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
303 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
304 public void ClearOptimizationRule() {
305 _hasBits0 &= ~2;
306 }
307
310 private readonly static double RefactorizationThresholdDefaultValue = 1e-09D;
311
312 private double refactorizationThreshold_;
321 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
322 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
324 get { if ((_hasBits0 & 4) != 0) { return refactorizationThreshold_; } else { return RefactorizationThresholdDefaultValue; } }
325 set {
326 _hasBits0 |= 4;
327 refactorizationThreshold_ = value;
328 }
329 }
330
331 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
332 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
334 get { return (_hasBits0 & 4) != 0; }
335 }
336
337 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
338 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
340 _hasBits0 &= ~4;
341 }
342
345 private readonly static double RecomputeReducedCostsThresholdDefaultValue = 1e-08D;
346
347 private double recomputeReducedCostsThreshold_;
355 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
356 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
358 get { if ((_hasBits0 & 8) != 0) { return recomputeReducedCostsThreshold_; } else { return RecomputeReducedCostsThresholdDefaultValue; } }
359 set {
360 _hasBits0 |= 8;
361 recomputeReducedCostsThreshold_ = value;
362 }
363 }
364
365 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
366 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
368 get { return (_hasBits0 & 8) != 0; }
369 }
370
371 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
372 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
374 _hasBits0 &= ~8;
375 }
376
379 private readonly static double RecomputeEdgesNormThresholdDefaultValue = 100D;
380
381 private double recomputeEdgesNormThreshold_;
389 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
390 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
392 get { if ((_hasBits0 & 16) != 0) { return recomputeEdgesNormThreshold_; } else { return RecomputeEdgesNormThresholdDefaultValue; } }
393 set {
394 _hasBits0 |= 16;
395 recomputeEdgesNormThreshold_ = value;
396 }
397 }
398
399 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
400 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
402 get { return (_hasBits0 & 16) != 0; }
403 }
404
405 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
406 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
408 _hasBits0 &= ~16;
409 }
410
413 private readonly static double PrimalFeasibilityToleranceDefaultValue = 1e-08D;
414
415 private double primalFeasibilityTolerance_;
425 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
426 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
427 public double PrimalFeasibilityTolerance {
428 get { if ((_hasBits0 & 32) != 0) { return primalFeasibilityTolerance_; } else { return PrimalFeasibilityToleranceDefaultValue; } }
429 set {
430 _hasBits0 |= 32;
431 primalFeasibilityTolerance_ = value;
432 }
433 }
435 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
436 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
437 public bool HasPrimalFeasibilityTolerance {
438 get { return (_hasBits0 & 32) != 0; }
439 }
441 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
442 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
443 public void ClearPrimalFeasibilityTolerance() {
444 _hasBits0 &= ~32;
445 }
446
447
448 public const int DualFeasibilityToleranceFieldNumber = 11;
449 private readonly static double DualFeasibilityToleranceDefaultValue = 1e-08D;
450
451 private double dualFeasibilityTolerance_;
464 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
465 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
466 public double DualFeasibilityTolerance {
467 get { if ((_hasBits0 & 64) != 0) { return dualFeasibilityTolerance_; } else { return DualFeasibilityToleranceDefaultValue; } }
468 set {
469 _hasBits0 |= 64;
470 dualFeasibilityTolerance_ = value;
471 }
472 }
474 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
475 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
476 public bool HasDualFeasibilityTolerance {
477 get { return (_hasBits0 & 64) != 0; }
478 }
479 /// <summary>Clears the value of the "dual_feasibility_tolerance" field</summary>
480 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
481 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
482 public void ClearDualFeasibilityTolerance() {
483 _hasBits0 &= ~64;
484 }
487 public const int RatioTestZeroThresholdFieldNumber = 12;
488 private readonly static double RatioTestZeroThresholdDefaultValue = 1e-09D;
489
490 private double ratioTestZeroThreshold_;
500 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
501 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
502 public double RatioTestZeroThreshold {
503 get { if ((_hasBits0 & 128) != 0) { return ratioTestZeroThreshold_; } else { return RatioTestZeroThresholdDefaultValue; } }
504 set {
505 _hasBits0 |= 128;
506 ratioTestZeroThreshold_ = value;
507 }
508 }
510 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
511 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
512 public bool HasRatioTestZeroThreshold {
513 get { return (_hasBits0 & 128) != 0; }
514 }
516 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
517 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
518 public void ClearRatioTestZeroThreshold() {
519 _hasBits0 &= ~128;
520 }
521
522 /// <summary>Field number for the "harris_tolerance_ratio" field.</summary>
523 public const int HarrisToleranceRatioFieldNumber = 13;
524 private readonly static double HarrisToleranceRatioDefaultValue = 0.5D;
525
526 private double harrisToleranceRatio_;
540 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
541 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
542 public double HarrisToleranceRatio {
543 get { if ((_hasBits0 & 256) != 0) { return harrisToleranceRatio_; } else { return HarrisToleranceRatioDefaultValue; } }
544 set {
545 _hasBits0 |= 256;
546 harrisToleranceRatio_ = value;
548 }
550 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
551 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
552 public bool HasHarrisToleranceRatio {
553 get { return (_hasBits0 & 256) != 0; }
554 }
556 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
557 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
558 public void ClearHarrisToleranceRatio() {
559 _hasBits0 &= ~256;
560 }
561
563 public const int SmallPivotThresholdFieldNumber = 14;
564 private readonly static double SmallPivotThresholdDefaultValue = 1e-06D;
565
566 private double smallPivotThreshold_;
573 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
574 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
575 public double SmallPivotThreshold {
576 get { if ((_hasBits0 & 512) != 0) { return smallPivotThreshold_; } else { return SmallPivotThresholdDefaultValue; } }
577 set {
578 _hasBits0 |= 512;
579 smallPivotThreshold_ = value;
581 }
583 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
584 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
585 public bool HasSmallPivotThreshold {
586 get { return (_hasBits0 & 512) != 0; }
587 }
589 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
590 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
591 public void ClearSmallPivotThreshold() {
592 _hasBits0 &= ~512;
593 }
594
597 private readonly static double MinimumAcceptablePivotDefaultValue = 1e-06D;
598
599 private double minimumAcceptablePivot_;
603 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
604 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
605 public double MinimumAcceptablePivot {
606 get { if ((_hasBits0 & 1024) != 0) { return minimumAcceptablePivot_; } else { return MinimumAcceptablePivotDefaultValue; } }
607 set {
608 _hasBits0 |= 1024;
609 minimumAcceptablePivot_ = value;
611 }
613 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
614 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
615 public bool HasMinimumAcceptablePivot {
616 get { return (_hasBits0 & 1024) != 0; }
617 }
619 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
620 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
621 public void ClearMinimumAcceptablePivot() {
622 _hasBits0 &= ~1024;
623 }
624
626 public const int DropToleranceFieldNumber = 52;
627 private readonly static double DropToleranceDefaultValue = 1e-14D;
628
629 private double dropTolerance_;
635 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
636 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
637 public double DropTolerance {
638 get { if ((_hasBits1 & 128) != 0) { return dropTolerance_; } else { return DropToleranceDefaultValue; } }
639 set {
640 _hasBits1 |= 128;
641 dropTolerance_ = value;
643 }
645 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
646 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
647 public bool HasDropTolerance {
648 get { return (_hasBits1 & 128) != 0; }
649 }
651 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
652 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
653 public void ClearDropTolerance() {
654 _hasBits1 &= ~128;
655 }
656
658 public const int UseScalingFieldNumber = 16;
659 private readonly static bool UseScalingDefaultValue = true;
660
661 private bool useScaling_;
666 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
667 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
668 public bool UseScaling {
669 get { if ((_hasBits0 & 2048) != 0) { return useScaling_; } else { return UseScalingDefaultValue; } }
670 set {
671 _hasBits0 |= 2048;
672 useScaling_ = value;
674 }
676 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
677 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
678 public bool HasUseScaling {
679 get { return (_hasBits0 & 2048) != 0; }
680 }
682 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
683 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
684 public void ClearUseScaling() {
685 _hasBits0 &= ~2048;
686 }
687
689 public const int CostScalingFieldNumber = 60;
690 private readonly static global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm CostScalingDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm.ContainOneCostScaling;
691
692 private global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm costScaling_;
693 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
694 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
696 get { if ((_hasBits1 & 32768) != 0) { return costScaling_; } else { return CostScalingDefaultValue; } }
697 set {
698 _hasBits1 |= 32768;
699 costScaling_ = value;
701 }
703 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
704 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
705 public bool HasCostScaling {
706 get { return (_hasBits1 & 32768) != 0; }
707 }
709 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
710 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
711 public void ClearCostScaling() {
712 _hasBits1 &= ~32768;
713 }
714
716 public const int InitialBasisFieldNumber = 17;
717 private readonly static global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic InitialBasisDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic.Triangular;
718
719 private global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic initialBasis_;
724 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
725 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
727 get { if ((_hasBits0 & 4096) != 0) { return initialBasis_; } else { return InitialBasisDefaultValue; } }
728 set {
729 _hasBits0 |= 4096;
730 initialBasis_ = value;
732 }
734 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
735 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
736 public bool HasInitialBasis {
737 get { return (_hasBits0 & 4096) != 0; }
738 }
740 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
741 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
742 public void ClearInitialBasis() {
743 _hasBits0 &= ~4096;
744 }
745
747 public const int UseTransposedMatrixFieldNumber = 18;
748 private readonly static bool UseTransposedMatrixDefaultValue = true;
749
750 private bool useTransposedMatrix_;
756 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
757 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
758 public bool UseTransposedMatrix {
759 get { if ((_hasBits0 & 8192) != 0) { return useTransposedMatrix_; } else { return UseTransposedMatrixDefaultValue; } }
760 set {
761 _hasBits0 |= 8192;
762 useTransposedMatrix_ = value;
764 }
766 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
767 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
768 public bool HasUseTransposedMatrix {
769 get { return (_hasBits0 & 8192) != 0; }
770 }
772 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
773 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
774 public void ClearUseTransposedMatrix() {
775 _hasBits0 &= ~8192;
776 }
777
780 private readonly static int BasisRefactorizationPeriodDefaultValue = 64;
781
782 private int basisRefactorizationPeriod_;
788 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
789 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
790 public int BasisRefactorizationPeriod {
791 get { if ((_hasBits0 & 16384) != 0) { return basisRefactorizationPeriod_; } else { return BasisRefactorizationPeriodDefaultValue; } }
792 set {
793 _hasBits0 |= 16384;
794 basisRefactorizationPeriod_ = value;
796 }
798 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
799 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
800 public bool HasBasisRefactorizationPeriod {
801 get { return (_hasBits0 & 16384) != 0; }
802 }
804 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
805 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
806 public void ClearBasisRefactorizationPeriod() {
807 _hasBits0 &= ~16384;
808 }
809
812 private readonly static bool DynamicallyAdjustRefactorizationPeriodDefaultValue = true;
813
814 private bool dynamicallyAdjustRefactorizationPeriod_;
822 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
823 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
825 get { if ((_hasBits1 & 262144) != 0) { return dynamicallyAdjustRefactorizationPeriod_; } else { return DynamicallyAdjustRefactorizationPeriodDefaultValue; } }
826 set {
827 _hasBits1 |= 262144;
828 dynamicallyAdjustRefactorizationPeriod_ = value;
830 }
832 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
833 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
834 public bool HasDynamicallyAdjustRefactorizationPeriod {
835 get { return (_hasBits1 & 262144) != 0; }
836 }
838 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
839 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
841 _hasBits1 &= ~262144;
842 }
843
845 public const int SolveDualProblemFieldNumber = 20;
846 private readonly static global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior SolveDualProblemDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior.LetSolverDecide;
847
848 private global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior solveDualProblem_;
854 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
855 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
857 get { if ((_hasBits0 & 32768) != 0) { return solveDualProblem_; } else { return SolveDualProblemDefaultValue; } }
858 set {
859 _hasBits0 |= 32768;
860 solveDualProblem_ = value;
862 }
864 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
865 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
866 public bool HasSolveDualProblem {
867 get { return (_hasBits0 & 32768) != 0; }
868 }
870 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
871 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
872 public void ClearSolveDualProblem() {
873 _hasBits0 &= ~32768;
874 }
875
877 public const int DualizerThresholdFieldNumber = 21;
878 private readonly static double DualizerThresholdDefaultValue = 1.5D;
879
880 private double dualizerThreshold_;
886 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
887 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
888 public double DualizerThreshold {
889 get { if ((_hasBits0 & 65536) != 0) { return dualizerThreshold_; } else { return DualizerThresholdDefaultValue; } }
890 set {
891 _hasBits0 |= 65536;
892 dualizerThreshold_ = value;
894 }
896 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
897 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
898 public bool HasDualizerThreshold {
899 get { return (_hasBits0 & 65536) != 0; }
900 }
902 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
903 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
904 public void ClearDualizerThreshold() {
905 _hasBits0 &= ~65536;
906 }
907
910 private readonly static double SolutionFeasibilityToleranceDefaultValue = 1e-06D;
911
912 private double solutionFeasibilityTolerance_;
923 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
924 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
925 public double SolutionFeasibilityTolerance {
926 get { if ((_hasBits0 & 131072) != 0) { return solutionFeasibilityTolerance_; } else { return SolutionFeasibilityToleranceDefaultValue; } }
927 set {
928 _hasBits0 |= 131072;
929 solutionFeasibilityTolerance_ = value;
930 }
933 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
934 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
935 public bool HasSolutionFeasibilityTolerance {
936 get { return (_hasBits0 & 131072) != 0; }
937 }
938
939 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
940 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
942 _hasBits0 &= ~131072;
943 }
944
946 public const int ProvideStrongOptimalGuaranteeFieldNumber = 24;
947 private readonly static bool ProvideStrongOptimalGuaranteeDefaultValue = true;
948
949 private bool provideStrongOptimalGuarantee_;
950
970 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
971 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
973 get { if ((_hasBits0 & 262144) != 0) { return provideStrongOptimalGuarantee_; } else { return ProvideStrongOptimalGuaranteeDefaultValue; } }
974 set {
975 _hasBits0 |= 262144;
976 provideStrongOptimalGuarantee_ = value;
977 }
978 }
980 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
981 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
983 get { return (_hasBits0 & 262144) != 0; }
984 }
986 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
987 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
988 public void ClearProvideStrongOptimalGuarantee() {
989 _hasBits0 &= ~262144;
991
993 public const int ChangeStatusToImpreciseFieldNumber = 58;
994 private readonly static bool ChangeStatusToImpreciseDefaultValue = true;
995
996 private bool changeStatusToImprecise_;
999
1001 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1002 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1003 public bool ChangeStatusToImprecise {
1004 get { if ((_hasBits1 & 8192) != 0) { return changeStatusToImprecise_; } else { return ChangeStatusToImpreciseDefaultValue; } }
1005 set {
1006 _hasBits1 |= 8192;
1007 changeStatusToImprecise_ = value;
1008 }
1009 }
1011 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1012 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1013 public bool HasChangeStatusToImprecise {
1014 get { return (_hasBits1 & 8192) != 0; }
1015 }
1017 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1018 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1019 public void ClearChangeStatusToImprecise() {
1020 _hasBits1 &= ~8192;
1022
1024 public const int MaxNumberOfReoptimizationsFieldNumber = 56;
1025 private readonly static double MaxNumberOfReoptimizationsDefaultValue = 40D;
1026
1027 private double maxNumberOfReoptimizations_;
1030
1034 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1035 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1036 public double MaxNumberOfReoptimizations {
1037 get { if ((_hasBits1 & 2048) != 0) { return maxNumberOfReoptimizations_; } else { return MaxNumberOfReoptimizationsDefaultValue; } }
1038 set {
1039 _hasBits1 |= 2048;
1040 maxNumberOfReoptimizations_ = value;
1041 }
1042 }
1044 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1045 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1046 public bool HasMaxNumberOfReoptimizations {
1047 get { return (_hasBits1 & 2048) != 0; }
1048 }
1050 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1051 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1052 public void ClearMaxNumberOfReoptimizations() {
1053 _hasBits1 &= ~2048;
1055
1057 public const int LuFactorizationPivotThresholdFieldNumber = 25;
1058 private readonly static double LuFactorizationPivotThresholdDefaultValue = 0.01D;
1059
1060 private double luFactorizationPivotThreshold_;
1063
1067 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1068 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1069 public double LuFactorizationPivotThreshold {
1070 get { if ((_hasBits0 & 524288) != 0) { return luFactorizationPivotThreshold_; } else { return LuFactorizationPivotThresholdDefaultValue; } }
1071 set {
1072 _hasBits0 |= 524288;
1073 luFactorizationPivotThreshold_ = value;
1074 }
1075 }
1077 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1078 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1080 get { return (_hasBits0 & 524288) != 0; }
1081 }
1083 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1084 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1085 public void ClearLuFactorizationPivotThreshold() {
1086 _hasBits0 &= ~524288;
1088
1090 public const int MaxTimeInSecondsFieldNumber = 26;
1091 private readonly static double MaxTimeInSecondsDefaultValue = double.PositiveInfinity;
1092
1093 private double maxTimeInSeconds_;
1096
1097 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1098 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1099 public double MaxTimeInSeconds {
1100 get { if ((_hasBits0 & 1048576) != 0) { return maxTimeInSeconds_; } else { return MaxTimeInSecondsDefaultValue; } }
1101 set {
1102 _hasBits0 |= 1048576;
1103 maxTimeInSeconds_ = value;
1104 }
1105 }
1107 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1108 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1109 public bool HasMaxTimeInSeconds {
1110 get { return (_hasBits0 & 1048576) != 0; }
1111 }
1113 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1114 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1115 public void ClearMaxTimeInSeconds() {
1116 _hasBits0 &= ~1048576;
1118
1120 public const int MaxDeterministicTimeFieldNumber = 45;
1121 private readonly static double MaxDeterministicTimeDefaultValue = double.PositiveInfinity;
1122
1123 private double maxDeterministicTime_;
1126
1131 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1132 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1133 public double MaxDeterministicTime {
1134 get { if ((_hasBits1 & 64) != 0) { return maxDeterministicTime_; } else { return MaxDeterministicTimeDefaultValue; } }
1135 set {
1136 _hasBits1 |= 64;
1137 maxDeterministicTime_ = value;
1138 }
1139 }
1141 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1142 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1143 public bool HasMaxDeterministicTime {
1144 get { return (_hasBits1 & 64) != 0; }
1145 }
1147 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1148 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1149 public void ClearMaxDeterministicTime() {
1150 _hasBits1 &= ~64;
1151 }
1154 public const int MaxNumberOfIterationsFieldNumber = 27;
1155 private readonly static long MaxNumberOfIterationsDefaultValue = -1L;
1156
1157 private long maxNumberOfIterations_;
1158 /// <summary>
1159 /// Maximum number of simplex iterations to solve a problem.
1160 /// A value of -1 means no limit.
1161 /// </summary>
1162 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1163 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1164 public long MaxNumberOfIterations {
1165 get { if ((_hasBits0 & 2097152) != 0) { return maxNumberOfIterations_; } else { return MaxNumberOfIterationsDefaultValue; } }
1166 set {
1167 _hasBits0 |= 2097152;
1168 maxNumberOfIterations_ = value;
1169 }
1170 }
1172 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1173 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1174 public bool HasMaxNumberOfIterations {
1175 get { return (_hasBits0 & 2097152) != 0; }
1176 }
1178 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1179 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1180 public void ClearMaxNumberOfIterations() {
1181 _hasBits0 &= ~2097152;
1182 }
1185 public const int MarkowitzZlatevParameterFieldNumber = 29;
1186 private readonly static int MarkowitzZlatevParameterDefaultValue = 3;
1187
1188 private int markowitzZlatevParameter_;
1189 /// <summary>
1190 /// How many columns do we look at in the Markowitz pivoting rule to find
1191 /// a good pivot. See markowitz.h.
1192 /// </summary>
1193 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1194 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1195 public int MarkowitzZlatevParameter {
1196 get { if ((_hasBits0 & 4194304) != 0) { return markowitzZlatevParameter_; } else { return MarkowitzZlatevParameterDefaultValue; } }
1197 set {
1198 _hasBits0 |= 4194304;
1199 markowitzZlatevParameter_ = value;
1200 }
1201 }
1203 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1204 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1205 public bool HasMarkowitzZlatevParameter {
1206 get { return (_hasBits0 & 4194304) != 0; }
1207 }
1209 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1210 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1211 public void ClearMarkowitzZlatevParameter() {
1212 _hasBits0 &= ~4194304;
1213 }
1216 public const int MarkowitzSingularityThresholdFieldNumber = 30;
1217 private readonly static double MarkowitzSingularityThresholdDefaultValue = 1e-15D;
1218
1219 private double markowitzSingularityThreshold_;
1220 /// <summary>
1221 /// If a pivot magnitude is smaller than this during the Markowitz LU
1222 /// factorization, then the matrix is assumed to be singular. Note that
1223 /// this is an absolute threshold and is not relative to the other possible
1224 /// pivots on the same column (see lu_factorization_pivot_threshold).
1225 /// </summary>
1226 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1227 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1228 public double MarkowitzSingularityThreshold {
1229 get { if ((_hasBits0 & 8388608) != 0) { return markowitzSingularityThreshold_; } else { return MarkowitzSingularityThresholdDefaultValue; } }
1230 set {
1231 _hasBits0 |= 8388608;
1232 markowitzSingularityThreshold_ = value;
1233 }
1234 }
1236 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1237 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1239 get { return (_hasBits0 & 8388608) != 0; }
1240 }
1242 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1243 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1244 public void ClearMarkowitzSingularityThreshold() {
1245 _hasBits0 &= ~8388608;
1246 }
1249 public const int UseDualSimplexFieldNumber = 31;
1250 private readonly static bool UseDualSimplexDefaultValue = false;
1251
1252 private bool useDualSimplex_;
1253 /// <summary>
1254 /// Whether or not we use the dual simplex algorithm instead of the primal.
1255 /// </summary>
1256 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1257 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1258 public bool UseDualSimplex {
1259 get { if ((_hasBits0 & 16777216) != 0) { return useDualSimplex_; } else { return UseDualSimplexDefaultValue; } }
1260 set {
1261 _hasBits0 |= 16777216;
1262 useDualSimplex_ = value;
1263 }
1264 }
1266 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1267 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1268 public bool HasUseDualSimplex {
1269 get { return (_hasBits0 & 16777216) != 0; }
1270 }
1272 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1273 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1274 public void ClearUseDualSimplex() {
1275 _hasBits0 &= ~16777216;
1276 }
1279 public const int AllowSimplexAlgorithmChangeFieldNumber = 32;
1280 private readonly static bool AllowSimplexAlgorithmChangeDefaultValue = false;
1281
1282 private bool allowSimplexAlgorithmChange_;
1283 /// <summary>
1284 /// During incremental solve, let the solver decide if it use the primal or
1285 /// dual simplex algorithm depending on the current solution and on the new
1286 /// problem. Note that even if this is true, the value of use_dual_simplex
1287 /// still indicates the default algorithm that the solver will use.
1288 /// </summary>
1289 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1290 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1291 public bool AllowSimplexAlgorithmChange {
1292 get { if ((_hasBits0 & 33554432) != 0) { return allowSimplexAlgorithmChange_; } else { return AllowSimplexAlgorithmChangeDefaultValue; } }
1293 set {
1294 _hasBits0 |= 33554432;
1295 allowSimplexAlgorithmChange_ = value;
1296 }
1297 }
1299 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1300 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1301 public bool HasAllowSimplexAlgorithmChange {
1302 get { return (_hasBits0 & 33554432) != 0; }
1303 }
1305 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1306 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1307 public void ClearAllowSimplexAlgorithmChange() {
1308 _hasBits0 &= ~33554432;
1309 }
1312 public const int DevexWeightsResetPeriodFieldNumber = 33;
1313 private readonly static int DevexWeightsResetPeriodDefaultValue = 150;
1314
1315 private int devexWeightsResetPeriod_;
1316 /// <summary>
1317 /// Devex weights will be reset to 1.0 after that number of updates.
1318 /// </summary>
1319 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1320 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1322 get { if ((_hasBits0 & 67108864) != 0) { return devexWeightsResetPeriod_; } else { return DevexWeightsResetPeriodDefaultValue; } }
1323 set {
1324 _hasBits0 |= 67108864;
1325 devexWeightsResetPeriod_ = value;
1326 }
1327 }
1329 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1330 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1331 public bool HasDevexWeightsResetPeriod {
1332 get { return (_hasBits0 & 67108864) != 0; }
1333 }
1335 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1336 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1337 public void ClearDevexWeightsResetPeriod() {
1338 _hasBits0 &= ~67108864;
1339 }
1342 public const int UsePreprocessingFieldNumber = 34;
1343 private readonly static bool UsePreprocessingDefaultValue = true;
1344
1345 private bool usePreprocessing_;
1346 /// <summary>
1347 /// Whether or not we use advanced preprocessing techniques.
1348 /// </summary>
1349 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1350 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1351 public bool UsePreprocessing {
1352 get { if ((_hasBits0 & 134217728) != 0) { return usePreprocessing_; } else { return UsePreprocessingDefaultValue; } }
1353 set {
1354 _hasBits0 |= 134217728;
1355 usePreprocessing_ = value;
1356 }
1357 }
1359 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1360 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1361 public bool HasUsePreprocessing {
1362 get { return (_hasBits0 & 134217728) != 0; }
1363 }
1365 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1366 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1367 public void ClearUsePreprocessing() {
1368 _hasBits0 &= ~134217728;
1369 }
1372 public const int UseMiddleProductFormUpdateFieldNumber = 35;
1373 private readonly static bool UseMiddleProductFormUpdateDefaultValue = true;
1374
1375 private bool useMiddleProductFormUpdate_;
1376 /// <summary>
1377 /// Whether or not to use the middle product form update rather than the
1378 /// standard eta LU update. The middle form product update should be a lot more
1379 /// efficient (close to the Forrest-Tomlin update, a bit slower but easier to
1380 /// implement). See for more details:
1381 /// Qi Huangfu, J. A. Julian Hall, "Novel update techniques for the revised
1382 /// simplex method", 28 january 2013, Technical Report ERGO-13-0001
1383 /// http://www.maths.ed.ac.uk/hall/HuHa12/ERGO-13-001.pdf
1384 /// </summary>
1385 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1386 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1387 public bool UseMiddleProductFormUpdate {
1388 get { if ((_hasBits0 & 268435456) != 0) { return useMiddleProductFormUpdate_; } else { return UseMiddleProductFormUpdateDefaultValue; } }
1389 set {
1390 _hasBits0 |= 268435456;
1391 useMiddleProductFormUpdate_ = value;
1392 }
1393 }
1395 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1396 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1397 public bool HasUseMiddleProductFormUpdate {
1398 get { return (_hasBits0 & 268435456) != 0; }
1399 }
1401 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1402 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1403 public void ClearUseMiddleProductFormUpdate() {
1404 _hasBits0 &= ~268435456;
1405 }
1409 private readonly static bool InitializeDevexWithColumnNormsDefaultValue = true;
1410
1411 private bool initializeDevexWithColumnNorms_;
1412 /// <summary>
1413 /// Whether we initialize devex weights to 1.0 or to the norms of the matrix
1414 /// columns.
1415 /// </summary>
1416 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1417 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1418 public bool InitializeDevexWithColumnNorms {
1419 get { if ((_hasBits0 & 536870912) != 0) { return initializeDevexWithColumnNorms_; } else { return InitializeDevexWithColumnNormsDefaultValue; } }
1420 set {
1421 _hasBits0 |= 536870912;
1422 initializeDevexWithColumnNorms_ = value;
1423 }
1424 }
1426 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1427 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1429 get { return (_hasBits0 & 536870912) != 0; }
1430 }
1432 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1433 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1434 public void ClearInitializeDevexWithColumnNorms() {
1435 _hasBits0 &= ~536870912;
1436 }
1440 private readonly static bool ExploitSingletonColumnInInitialBasisDefaultValue = true;
1441
1442 private bool exploitSingletonColumnInInitialBasis_;
1443 /// <summary>
1444 /// Whether or not we exploit the singleton columns already present in the
1445 /// problem when we create the initial basis.
1446 /// </summary>
1447 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1448 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1450 get { if ((_hasBits0 & 1073741824) != 0) { return exploitSingletonColumnInInitialBasis_; } else { return ExploitSingletonColumnInInitialBasisDefaultValue; } }
1451 set {
1452 _hasBits0 |= 1073741824;
1453 exploitSingletonColumnInInitialBasis_ = value;
1454 }
1455 }
1457 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1458 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1460 get { return (_hasBits0 & 1073741824) != 0; }
1461 }
1463 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1464 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1465 public void ClearExploitSingletonColumnInInitialBasis() {
1466 _hasBits0 &= ~1073741824;
1467 }
1470 public const int DualSmallPivotThresholdFieldNumber = 38;
1471 private readonly static double DualSmallPivotThresholdDefaultValue = 0.0001D;
1472
1473 private double dualSmallPivotThreshold_;
1474 /// <summary>
1475 /// Like small_pivot_threshold but for the dual simplex. This is needed because
1476 /// the dual algorithm does not interpret this value in the same way.
1477 /// TODO(user): Clean this up and use the same small pivot detection.
1478 /// </summary>
1479 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1480 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1481 public double DualSmallPivotThreshold {
1482 get { if ((_hasBits0 & -2147483648) != 0) { return dualSmallPivotThreshold_; } else { return DualSmallPivotThresholdDefaultValue; } }
1483 set {
1484 _hasBits0 |= -2147483648;
1485 dualSmallPivotThreshold_ = value;
1486 }
1487 }
1489 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1490 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1491 public bool HasDualSmallPivotThreshold {
1492 get { return (_hasBits0 & -2147483648) != 0; }
1493 }
1495 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1496 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1497 public void ClearDualSmallPivotThreshold() {
1498 _hasBits0 &= ~-2147483648;
1499 }
1502 public const int PreprocessorZeroToleranceFieldNumber = 39;
1503 private readonly static double PreprocessorZeroToleranceDefaultValue = 1e-09D;
1504
1505 private double preprocessorZeroTolerance_;
1506 /// <summary>
1507 /// A floating point tolerance used by the preprocessors. This is used for
1508 /// things like detecting if two columns/rows are proportional or if an
1509 /// interval is empty.
1510 ///
1511 /// Note that the preprocessors also use solution_feasibility_tolerance() to
1512 /// detect if a problem is infeasible.
1513 /// </summary>
1514 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1515 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1516 public double PreprocessorZeroTolerance {
1517 get { if ((_hasBits1 & 1) != 0) { return preprocessorZeroTolerance_; } else { return PreprocessorZeroToleranceDefaultValue; } }
1518 set {
1519 _hasBits1 |= 1;
1520 preprocessorZeroTolerance_ = value;
1521 }
1522 }
1524 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1525 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1527 get { return (_hasBits1 & 1) != 0; }
1528 }
1530 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1531 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1532 public void ClearPreprocessorZeroTolerance() {
1533 _hasBits1 &= ~1;
1534 }
1535
1536 /// <summary>Field number for the "objective_lower_limit" field.</summary>
1537 public const int ObjectiveLowerLimitFieldNumber = 40;
1538 private readonly static double ObjectiveLowerLimitDefaultValue = double.NegativeInfinity;
1539
1540 private double objectiveLowerLimit_;
1542 /// The solver will stop as soon as it has proven that the objective is smaller
1543 /// than objective_lower_limit or greater than objective_upper_limit. Depending
1544 /// on the simplex algorithm (primal or dual) and the optimization direction,
1545 /// note that only one bound will be used at the time.
1546 ///
1547 /// Important: The solver does not add any tolerances to these values, and as
1548 /// soon as the objective (as computed by the solver, so with some imprecision)
1549 /// crosses one of these bounds (strictly), the search will stop. It is up to
1550 /// the client to add any tolerance if needed.
1551 /// </summary>
1552 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1553 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1554 public double ObjectiveLowerLimit {
1555 get { if ((_hasBits1 & 2) != 0) { return objectiveLowerLimit_; } else { return ObjectiveLowerLimitDefaultValue; } }
1556 set {
1557 _hasBits1 |= 2;
1558 objectiveLowerLimit_ = value;
1559 }
1560 }
1562 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1563 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1564 public bool HasObjectiveLowerLimit {
1565 get { return (_hasBits1 & 2) != 0; }
1566 }
1568 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1569 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1570 public void ClearObjectiveLowerLimit() {
1571 _hasBits1 &= ~2;
1572 }
1573
1575 public const int ObjectiveUpperLimitFieldNumber = 41;
1576 private readonly static double ObjectiveUpperLimitDefaultValue = double.PositiveInfinity;
1577
1578 private double objectiveUpperLimit_;
1579 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1580 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1581 public double ObjectiveUpperLimit {
1582 get { if ((_hasBits1 & 4) != 0) { return objectiveUpperLimit_; } else { return ObjectiveUpperLimitDefaultValue; } }
1583 set {
1584 _hasBits1 |= 4;
1585 objectiveUpperLimit_ = value;
1587 }
1589 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1590 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1591 public bool HasObjectiveUpperLimit {
1592 get { return (_hasBits1 & 4) != 0; }
1593 }
1595 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1596 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1597 public void ClearObjectiveUpperLimit() {
1598 _hasBits1 &= ~4;
1599 }
1600
1603 private readonly static double DegenerateMinistepFactorDefaultValue = 0.01D;
1604
1605 private double degenerateMinistepFactor_;
1608 /// step of length zero (while shifting the bound of the leaving variable).
1609 /// That is, the variable values are unchanged for the primal simplex or the
1610 /// reduced cost are unchanged for the dual simplex. However, instead of doing
1611 /// a step of length zero, it seems to be better on degenerate problems to do a
1612 /// small positive step. This is what is recommended in the EXPAND procedure
1613 /// described in:
1614 /// P. E. Gill, W. Murray, M. A. Saunders, and M. H. Wright. "A practical anti-
1615 /// cycling procedure for linearly constrained optimization".
1616 /// Mathematical Programming, 45:437\u2013474, 1989.
1617 ///
1618 /// Here, during a degenerate iteration we do a small positive step of this
1619 /// factor times the primal (resp. dual) tolerance. In the primal simplex, this
1620 /// may effectively push variable values (very slightly) further out of their
1621 /// bounds (resp. reduced costs for the dual simplex).
1622 ///
1623 /// Setting this to zero reverts to the more conservative approach of a zero
1624 /// step during degenerate iterations.
1625 /// </summary>
1626 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1627 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1628 public double DegenerateMinistepFactor {
1629 get { if ((_hasBits1 & 8) != 0) { return degenerateMinistepFactor_; } else { return DegenerateMinistepFactorDefaultValue; } }
1630 set {
1631 _hasBits1 |= 8;
1632 degenerateMinistepFactor_ = value;
1633 }
1634 }
1636 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1637 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1638 public bool HasDegenerateMinistepFactor {
1639 get { return (_hasBits1 & 8) != 0; }
1640 }
1641 /// <summary>Clears the value of the "degenerate_ministep_factor" field</summary>
1642 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1643 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1644 public void ClearDegenerateMinistepFactor() {
1645 _hasBits1 &= ~8;
1646 }
1647
1648
1649 public const int RandomSeedFieldNumber = 43;
1650 private readonly static int RandomSeedDefaultValue = 1;
1652 private int randomSeed_;
1654
1657 /// Note that this may lead to a different solution, for example a different
1658 /// optimal basis.
1659 ///
1660 /// For some problems, the running time may vary a lot depending on small
1661 /// change in the solving algorithm. Running the solver with different seeds
1662 /// enables to have more robust benchmarks when evaluating new features.
1663 ///
1664 /// Also note that the solver is fully deterministic: two runs of the same
1665 /// binary, on the same machine, on the exact same data and with the same
1666 /// parameters will go through the exact same iterations. If they hit a time
1667 /// limit, they might of course yield different results because one will have
1668 /// advanced farther than the other.
1669 /// </summary>
1670 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1671 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1672 public int RandomSeed {
1673 get { if ((_hasBits1 & 16) != 0) { return randomSeed_; } else { return RandomSeedDefaultValue; } }
1674 set {
1675 _hasBits1 |= 16;
1676 randomSeed_ = value;
1677 }
1678 }
1680 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1681 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1682 public bool HasRandomSeed {
1683 get { return (_hasBits1 & 16) != 0; }
1684 }
1686 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1687 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1688 public void ClearRandomSeed() {
1689 _hasBits1 &= ~16;
1690 }
1691
1693 public const int UseAbslRandomFieldNumber = 72;
1694 private readonly static bool UseAbslRandomDefaultValue = false;
1695
1696 private bool useAbslRandom_;
1697 /// <summary>
1698 /// Whether to use absl::BitGen instead of MTRandom.
1699 /// </summary>
1700 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1701 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1702 public bool UseAbslRandom {
1703 get { if ((_hasBits1 & 67108864) != 0) { return useAbslRandom_; } else { return UseAbslRandomDefaultValue; } }
1704 set {
1705 _hasBits1 |= 67108864;
1706 useAbslRandom_ = value;
1707 }
1710 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1711 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1712 public bool HasUseAbslRandom {
1713 get { return (_hasBits1 & 67108864) != 0; }
1714 }
1716 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1717 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1718 public void ClearUseAbslRandom() {
1719 _hasBits1 &= ~67108864;
1720 }
1721
1723 public const int NumOmpThreadsFieldNumber = 44;
1724 private readonly static int NumOmpThreadsDefaultValue = 1;
1725
1726 private int numOmpThreads_;
1727 /// <summary>
1728 /// Number of threads in the OMP parallel sections. If left to 1, the code will
1729 /// not create any OMP threads and will remain single-threaded.
1730 /// </summary>
1731 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1732 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1733 public int NumOmpThreads {
1734 get { if ((_hasBits1 & 32) != 0) { return numOmpThreads_; } else { return NumOmpThreadsDefaultValue; } }
1735 set {
1736 _hasBits1 |= 32;
1737 numOmpThreads_ = value;
1739 }
1741 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1742 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1743 public bool HasNumOmpThreads {
1744 get { return (_hasBits1 & 32) != 0; }
1745 }
1747 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1748 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1749 public void ClearNumOmpThreads() {
1750 _hasBits1 &= ~32;
1751 }
1752
1754 public const int PerturbCostsInDualSimplexFieldNumber = 53;
1755 private readonly static bool PerturbCostsInDualSimplexDefaultValue = false;
1756
1757 private bool perturbCostsInDualSimplex_;
1758 /// <summary>
1759 /// When this is true, then the costs are randomly perturbed before the dual
1760 /// simplex is even started. This has been shown to improve the dual simplex
1761 /// performance. For a good reference, see Huangfu Q (2013) "High performance
1762 /// simplex solver", Ph.D, dissertation, University of Edinburgh.
1763 /// </summary>
1764 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1765 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1766 public bool PerturbCostsInDualSimplex {
1767 get { if ((_hasBits1 & 256) != 0) { return perturbCostsInDualSimplex_; } else { return PerturbCostsInDualSimplexDefaultValue; } }
1768 set {
1769 _hasBits1 |= 256;
1770 perturbCostsInDualSimplex_ = value;
1771 }
1772 }
1774 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1775 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1776 public bool HasPerturbCostsInDualSimplex {
1777 get { return (_hasBits1 & 256) != 0; }
1778 }
1780 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1781 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1782 public void ClearPerturbCostsInDualSimplex() {
1783 _hasBits1 &= ~256;
1784 }
1785
1787 public const int UseDedicatedDualFeasibilityAlgorithmFieldNumber = 62;
1788 private readonly static bool UseDedicatedDualFeasibilityAlgorithmDefaultValue = true;
1789
1790 private bool useDedicatedDualFeasibilityAlgorithm_;
1791 /// <summary>
1792 /// We have two possible dual phase I algorithms. Both work on an LP that
1793 /// minimize the sum of dual infeasiblities. One use dedicated code (when this
1794 /// param is true), the other one use exactly the same code as the dual phase
1795 /// II but on an auxiliary problem where the variable bounds of the original
1796 /// problem are changed.
1797 ///
1798 /// TODO(user): For now we have both, but ideally the non-dedicated version
1799 /// will win since it is a lot less code to maintain.
1800 /// </summary>
1801 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1802 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1804 get { if ((_hasBits1 & 131072) != 0) { return useDedicatedDualFeasibilityAlgorithm_; } else { return UseDedicatedDualFeasibilityAlgorithmDefaultValue; } }
1805 set {
1806 _hasBits1 |= 131072;
1807 useDedicatedDualFeasibilityAlgorithm_ = value;
1808 }
1809 }
1811 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1812 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1813 public bool HasUseDedicatedDualFeasibilityAlgorithm {
1814 get { return (_hasBits1 & 131072) != 0; }
1815 }
1817 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1818 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1820 _hasBits1 &= ~131072;
1821 }
1822
1824 public const int RelativeCostPerturbationFieldNumber = 54;
1825 private readonly static double RelativeCostPerturbationDefaultValue = 1e-05D;
1826
1827 private double relativeCostPerturbation_;
1829 /// The magnitude of the cost perturbation is given by
1830 /// RandomIn(1.0, 2.0) * (
1831 /// relative_cost_perturbation * cost
1832 /// + relative_max_cost_perturbation * max_cost);
1833 /// </summary>
1834 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1835 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1836 public double RelativeCostPerturbation {
1837 get { if ((_hasBits1 & 512) != 0) { return relativeCostPerturbation_; } else { return RelativeCostPerturbationDefaultValue; } }
1838 set {
1839 _hasBits1 |= 512;
1840 relativeCostPerturbation_ = value;
1841 }
1842 }
1844 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1845 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1846 public bool HasRelativeCostPerturbation {
1847 get { return (_hasBits1 & 512) != 0; }
1848 }
1850 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1851 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1853 _hasBits1 &= ~512;
1854 }
1855
1857 public const int RelativeMaxCostPerturbationFieldNumber = 55;
1858 private readonly static double RelativeMaxCostPerturbationDefaultValue = 1e-07D;
1859
1860 private double relativeMaxCostPerturbation_;
1861 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1862 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1863 public double RelativeMaxCostPerturbation {
1864 get { if ((_hasBits1 & 1024) != 0) { return relativeMaxCostPerturbation_; } else { return RelativeMaxCostPerturbationDefaultValue; } }
1865 set {
1866 _hasBits1 |= 1024;
1867 relativeMaxCostPerturbation_ = value;
1869 }
1871 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1872 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1874 get { return (_hasBits1 & 1024) != 0; }
1875 }
1877 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1878 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1880 _hasBits1 &= ~1024;
1881 }
1882
1884 public const int InitialConditionNumberThresholdFieldNumber = 59;
1885 private readonly static double InitialConditionNumberThresholdDefaultValue = 1e+50D;
1886
1887 private double initialConditionNumberThreshold_;
1889 /// If our upper bound on the condition number of the initial basis (from our
1890 /// heurisitic or a warm start) is above this threshold, we revert to an all
1891 /// slack basis.
1892 /// </summary>
1893 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1894 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1896 get { if ((_hasBits1 & 16384) != 0) { return initialConditionNumberThreshold_; } else { return InitialConditionNumberThresholdDefaultValue; } }
1897 set {
1898 _hasBits1 |= 16384;
1899 initialConditionNumberThreshold_ = value;
1901 }
1903 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1904 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1905 public bool HasInitialConditionNumberThreshold {
1906 get { return (_hasBits1 & 16384) != 0; }
1907 }
1909 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1910 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1912 _hasBits1 &= ~16384;
1913 }
1914
1916 public const int LogSearchProgressFieldNumber = 61;
1917 private readonly static bool LogSearchProgressDefaultValue = false;
1918
1919 private bool logSearchProgress_;
1921 /// If true, logs the progress of a solve to LOG(INFO). Note that the same
1922 /// messages can also be turned on by displaying logs at level 1 for the
1923 /// relevant files.
1924 /// </summary>
1925 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1926 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1927 public bool LogSearchProgress {
1928 get { if ((_hasBits1 & 65536) != 0) { return logSearchProgress_; } else { return LogSearchProgressDefaultValue; } }
1929 set {
1930 _hasBits1 |= 65536;
1931 logSearchProgress_ = value;
1933 }
1935 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1936 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1937 public bool HasLogSearchProgress {
1938 get { return (_hasBits1 & 65536) != 0; }
1939 }
1941 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1942 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1944 _hasBits1 &= ~65536;
1945 }
1946
1948 public const int LogToStdoutFieldNumber = 66;
1949 private readonly static bool LogToStdoutDefaultValue = true;
1950
1951 private bool logToStdout_;
1953 /// If true, logs will be displayed to stdout instead of using Google log info.
1954 /// </summary>
1955 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1956 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1957 public bool LogToStdout {
1958 get { if ((_hasBits1 & 2097152) != 0) { return logToStdout_; } else { return LogToStdoutDefaultValue; } }
1959 set {
1960 _hasBits1 |= 2097152;
1961 logToStdout_ = value;
1962 }
1963 }
1965 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1966 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1967 public bool HasLogToStdout {
1968 get { return (_hasBits1 & 2097152) != 0; }
1969 }
1971 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1972 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1973 public void ClearLogToStdout() {
1974 _hasBits1 &= ~2097152;
1975 }
1976
1978 public const int CrossoverBoundSnappingDistanceFieldNumber = 64;
1979 private readonly static double CrossoverBoundSnappingDistanceDefaultValue = double.PositiveInfinity;
1980
1981 private double crossoverBoundSnappingDistance_;
1983 /// If the starting basis contains FREE variable with bounds, we will move
1984 /// any such variable to their closer bounds if the distance is smaller than
1985 /// this parameter.
1986 ///
1987 /// The starting statuses can contains FREE variables with bounds, if a user
1988 /// set it like this externally. Also, any variable with an initial BASIC
1989 /// status that was not kept in the initial basis is marked as FREE before this
1990 /// step is applied.
1991 ///
1992 /// Note that by default a FREE variable is assumed to be zero unless a
1993 /// starting value was specified via SetStartingVariableValuesForNextSolve().
1994 ///
1995 /// Note that, at the end of the solve, some of these FREE variable with bounds
1996 /// and an interior point value might still be left in the final solution.
1997 /// Enable push_to_vertex to clean these up.
1998 /// </summary>
1999 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2000 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2001 public double CrossoverBoundSnappingDistance {
2002 get { if ((_hasBits1 & 524288) != 0) { return crossoverBoundSnappingDistance_; } else { return CrossoverBoundSnappingDistanceDefaultValue; } }
2003 set {
2004 _hasBits1 |= 524288;
2005 crossoverBoundSnappingDistance_ = value;
2006 }
2007 }
2009 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2010 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2011 public bool HasCrossoverBoundSnappingDistance {
2012 get { return (_hasBits1 & 524288) != 0; }
2013 }
2015 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2016 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2017 public void ClearCrossoverBoundSnappingDistance() {
2018 _hasBits1 &= ~524288;
2019 }
2022 public const int PushToVertexFieldNumber = 65;
2023 private readonly static bool PushToVertexDefaultValue = true;
2024
2025 private bool pushToVertex_;
2027
2030 /// phase to push these variables to bounds, obtaining a vertex solution. Note
2031 /// this situation can happen only if a starting value was specified via
2032 /// SetStartingVariableValuesForNextSolve().
2033 /// </summary>
2034 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2035 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2036 public bool PushToVertex {
2037 get { if ((_hasBits1 & 1048576) != 0) { return pushToVertex_; } else { return PushToVertexDefaultValue; } }
2038 set {
2039 _hasBits1 |= 1048576;
2040 pushToVertex_ = value;
2042 }
2044 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2045 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2046 public bool HasPushToVertex {
2047 get { return (_hasBits1 & 1048576) != 0; }
2048 }
2050 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2051 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2052 public void ClearPushToVertex() {
2053 _hasBits1 &= ~1048576;
2054 }
2057 public const int UseImpliedFreePreprocessorFieldNumber = 67;
2058 private readonly static bool UseImpliedFreePreprocessorDefaultValue = true;
2059
2060 private bool useImpliedFreePreprocessor_;
2062
2064 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2065 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2066 public bool UseImpliedFreePreprocessor {
2067 get { if ((_hasBits1 & 4194304) != 0) { return useImpliedFreePreprocessor_; } else { return UseImpliedFreePreprocessorDefaultValue; } }
2068 set {
2069 _hasBits1 |= 4194304;
2070 useImpliedFreePreprocessor_ = value;
2072 }
2074 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2075 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2077 get { return (_hasBits1 & 4194304) != 0; }
2078 }
2080 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2081 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2082 public void ClearUseImpliedFreePreprocessor() {
2083 _hasBits1 &= ~4194304;
2084 }
2087 public const int MaxValidMagnitudeFieldNumber = 70;
2088 private readonly static double MaxValidMagnitudeDefaultValue = 1e+30D;
2089
2090 private double maxValidMagnitude_;
2092
2095 /// shouldn't use super large values in an LP. With the default threshold, even
2096 /// evaluating large constraint with variables at their bound shouldn't cause
2097 /// any overflow.
2098 /// </summary>
2099 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2100 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2101 public double MaxValidMagnitude {
2102 get { if ((_hasBits1 & 16777216) != 0) { return maxValidMagnitude_; } else { return MaxValidMagnitudeDefaultValue; } }
2103 set {
2104 _hasBits1 |= 16777216;
2105 maxValidMagnitude_ = value;
2107 }
2109 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2110 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2111 public bool HasMaxValidMagnitude {
2112 get { return (_hasBits1 & 16777216) != 0; }
2113 }
2115 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2116 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2117 public void ClearMaxValidMagnitude() {
2118 _hasBits1 &= ~16777216;
2119 }
2122 public const int DropMagnitudeFieldNumber = 71;
2123 private readonly static double DropMagnitudeDefaultValue = 1e-30D;
2124
2125 private double dropMagnitude_;
2127
2130 /// a * b == 0 iff a or b is zero and things like this.
2131 /// </summary>
2132 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2133 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2134 public double DropMagnitude {
2135 get { if ((_hasBits1 & 33554432) != 0) { return dropMagnitude_; } else { return DropMagnitudeDefaultValue; } }
2136 set {
2137 _hasBits1 |= 33554432;
2138 dropMagnitude_ = value;
2139 }
2140 }
2142 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2143 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2144 public bool HasDropMagnitude {
2145 get { return (_hasBits1 & 33554432) != 0; }
2146 }
2148 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2149 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2150 public void ClearDropMagnitude() {
2151 _hasBits1 &= ~33554432;
2152 }
2155 public const int DualPricePrioritizeNormFieldNumber = 69;
2156 private readonly static bool DualPricePrioritizeNormDefaultValue = false;
2157
2158 private bool dualPricePrioritizeNorm_;
2160
2163 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2164 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2165 public bool DualPricePrioritizeNorm {
2166 get { if ((_hasBits1 & 8388608) != 0) { return dualPricePrioritizeNorm_; } else { return DualPricePrioritizeNormDefaultValue; } }
2167 set {
2168 _hasBits1 |= 8388608;
2169 dualPricePrioritizeNorm_ = value;
2170 }
2171 }
2172
2173 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2174 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2175 public bool HasDualPricePrioritizeNorm {
2176 get { return (_hasBits1 & 8388608) != 0; }
2177 }
2179 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2180 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2181 public void ClearDualPricePrioritizeNorm() {
2182 _hasBits1 &= ~8388608;
2183 }
2185 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2186 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2187 public override bool Equals(object other) {
2188 return Equals(other as GlopParameters);
2189 }
2190
2191 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2192 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2193 public bool Equals(GlopParameters other) {
2194 if (ReferenceEquals(other, null)) {
2195 return false;
2196 }
2197 if (ReferenceEquals(other, this)) {
2198 return true;
2199 }
2200 if (ScalingMethod != other.ScalingMethod) return false;
2201 if (FeasibilityRule != other.FeasibilityRule) return false;
2202 if (OptimizationRule != other.OptimizationRule) return false;
2203 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RefactorizationThreshold, other.RefactorizationThreshold)) return false;
2204 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RecomputeReducedCostsThreshold, other.RecomputeReducedCostsThreshold)) return false;
2205 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RecomputeEdgesNormThreshold, other.RecomputeEdgesNormThreshold)) return false;
2206 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(PrimalFeasibilityTolerance, other.PrimalFeasibilityTolerance)) return false;
2207 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DualFeasibilityTolerance, other.DualFeasibilityTolerance)) return false;
2208 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RatioTestZeroThreshold, other.RatioTestZeroThreshold)) return false;
2209 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(HarrisToleranceRatio, other.HarrisToleranceRatio)) return false;
2210 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(SmallPivotThreshold, other.SmallPivotThreshold)) return false;
2211 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MinimumAcceptablePivot, other.MinimumAcceptablePivot)) return false;
2212 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DropTolerance, other.DropTolerance)) return false;
2213 if (UseScaling != other.UseScaling) return false;
2214 if (CostScaling != other.CostScaling) return false;
2215 if (InitialBasis != other.InitialBasis) return false;
2216 if (UseTransposedMatrix != other.UseTransposedMatrix) return false;
2217 if (BasisRefactorizationPeriod != other.BasisRefactorizationPeriod) return false;
2219 if (SolveDualProblem != other.SolveDualProblem) return false;
2220 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DualizerThreshold, other.DualizerThreshold)) return false;
2221 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(SolutionFeasibilityTolerance, other.SolutionFeasibilityTolerance)) return false;
2223 if (ChangeStatusToImprecise != other.ChangeStatusToImprecise) return false;
2224 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MaxNumberOfReoptimizations, other.MaxNumberOfReoptimizations)) return false;
2225 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(LuFactorizationPivotThreshold, other.LuFactorizationPivotThreshold)) return false;
2226 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MaxTimeInSeconds, other.MaxTimeInSeconds)) return false;
2227 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MaxDeterministicTime, other.MaxDeterministicTime)) return false;
2228 if (MaxNumberOfIterations != other.MaxNumberOfIterations) return false;
2229 if (MarkowitzZlatevParameter != other.MarkowitzZlatevParameter) return false;
2230 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MarkowitzSingularityThreshold, other.MarkowitzSingularityThreshold)) return false;
2231 if (UseDualSimplex != other.UseDualSimplex) return false;
2233 if (DevexWeightsResetPeriod != other.DevexWeightsResetPeriod) return false;
2234 if (UsePreprocessing != other.UsePreprocessing) return false;
2235 if (UseMiddleProductFormUpdate != other.UseMiddleProductFormUpdate) return false;
2238 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DualSmallPivotThreshold, other.DualSmallPivotThreshold)) return false;
2239 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(PreprocessorZeroTolerance, other.PreprocessorZeroTolerance)) return false;
2240 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ObjectiveLowerLimit, other.ObjectiveLowerLimit)) return false;
2241 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ObjectiveUpperLimit, other.ObjectiveUpperLimit)) return false;
2242 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DegenerateMinistepFactor, other.DegenerateMinistepFactor)) return false;
2243 if (RandomSeed != other.RandomSeed) return false;
2244 if (UseAbslRandom != other.UseAbslRandom) return false;
2245 if (NumOmpThreads != other.NumOmpThreads) return false;
2246 if (PerturbCostsInDualSimplex != other.PerturbCostsInDualSimplex) return false;
2248 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RelativeCostPerturbation, other.RelativeCostPerturbation)) return false;
2249 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RelativeMaxCostPerturbation, other.RelativeMaxCostPerturbation)) return false;
2250 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(InitialConditionNumberThreshold, other.InitialConditionNumberThreshold)) return false;
2251 if (LogSearchProgress != other.LogSearchProgress) return false;
2252 if (LogToStdout != other.LogToStdout) return false;
2253 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(CrossoverBoundSnappingDistance, other.CrossoverBoundSnappingDistance)) return false;
2254 if (PushToVertex != other.PushToVertex) return false;
2255 if (UseImpliedFreePreprocessor != other.UseImpliedFreePreprocessor) return false;
2256 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MaxValidMagnitude, other.MaxValidMagnitude)) return false;
2257 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DropMagnitude, other.DropMagnitude)) return false;
2258 if (DualPricePrioritizeNorm != other.DualPricePrioritizeNorm) return false;
2259 return Equals(_unknownFields, other._unknownFields);
2260 }
2261
2262 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2263 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2264 public override int GetHashCode() {
2265 int hash = 1;
2266 if (HasScalingMethod) hash ^= ScalingMethod.GetHashCode();
2267 if (HasFeasibilityRule) hash ^= FeasibilityRule.GetHashCode();
2268 if (HasOptimizationRule) hash ^= OptimizationRule.GetHashCode();
2269 if (HasRefactorizationThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RefactorizationThreshold);
2270 if (HasRecomputeReducedCostsThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RecomputeReducedCostsThreshold);
2271 if (HasRecomputeEdgesNormThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RecomputeEdgesNormThreshold);
2272 if (HasPrimalFeasibilityTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PrimalFeasibilityTolerance);
2273 if (HasDualFeasibilityTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DualFeasibilityTolerance);
2274 if (HasRatioTestZeroThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RatioTestZeroThreshold);
2275 if (HasHarrisToleranceRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(HarrisToleranceRatio);
2276 if (HasSmallPivotThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(SmallPivotThreshold);
2277 if (HasMinimumAcceptablePivot) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MinimumAcceptablePivot);
2278 if (HasDropTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DropTolerance);
2279 if (HasUseScaling) hash ^= UseScaling.GetHashCode();
2280 if (HasCostScaling) hash ^= CostScaling.GetHashCode();
2281 if (HasInitialBasis) hash ^= InitialBasis.GetHashCode();
2282 if (HasUseTransposedMatrix) hash ^= UseTransposedMatrix.GetHashCode();
2285 if (HasSolveDualProblem) hash ^= SolveDualProblem.GetHashCode();
2286 if (HasDualizerThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DualizerThreshold);
2287 if (HasSolutionFeasibilityTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(SolutionFeasibilityTolerance);
2289 if (HasChangeStatusToImprecise) hash ^= ChangeStatusToImprecise.GetHashCode();
2290 if (HasMaxNumberOfReoptimizations) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxNumberOfReoptimizations);
2291 if (HasLuFactorizationPivotThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(LuFactorizationPivotThreshold);
2292 if (HasMaxTimeInSeconds) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxTimeInSeconds);
2293 if (HasMaxDeterministicTime) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxDeterministicTime);
2294 if (HasMaxNumberOfIterations) hash ^= MaxNumberOfIterations.GetHashCode();
2295 if (HasMarkowitzZlatevParameter) hash ^= MarkowitzZlatevParameter.GetHashCode();
2296 if (HasMarkowitzSingularityThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MarkowitzSingularityThreshold);
2297 if (HasUseDualSimplex) hash ^= UseDualSimplex.GetHashCode();
2299 if (HasDevexWeightsResetPeriod) hash ^= DevexWeightsResetPeriod.GetHashCode();
2300 if (HasUsePreprocessing) hash ^= UsePreprocessing.GetHashCode();
2304 if (HasDualSmallPivotThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DualSmallPivotThreshold);
2305 if (HasPreprocessorZeroTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PreprocessorZeroTolerance);
2306 if (HasObjectiveLowerLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ObjectiveLowerLimit);
2307 if (HasObjectiveUpperLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ObjectiveUpperLimit);
2308 if (HasDegenerateMinistepFactor) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DegenerateMinistepFactor);
2309 if (HasRandomSeed) hash ^= RandomSeed.GetHashCode();
2310 if (HasUseAbslRandom) hash ^= UseAbslRandom.GetHashCode();
2311 if (HasNumOmpThreads) hash ^= NumOmpThreads.GetHashCode();
2314 if (HasRelativeCostPerturbation) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RelativeCostPerturbation);
2315 if (HasRelativeMaxCostPerturbation) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RelativeMaxCostPerturbation);
2316 if (HasInitialConditionNumberThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(InitialConditionNumberThreshold);
2317 if (HasLogSearchProgress) hash ^= LogSearchProgress.GetHashCode();
2318 if (HasLogToStdout) hash ^= LogToStdout.GetHashCode();
2319 if (HasCrossoverBoundSnappingDistance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(CrossoverBoundSnappingDistance);
2320 if (HasPushToVertex) hash ^= PushToVertex.GetHashCode();
2322 if (HasMaxValidMagnitude) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxValidMagnitude);
2323 if (HasDropMagnitude) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DropMagnitude);
2324 if (HasDualPricePrioritizeNorm) hash ^= DualPricePrioritizeNorm.GetHashCode();
2325 if (_unknownFields != null) {
2326 hash ^= _unknownFields.GetHashCode();
2327 }
2328 return hash;
2329 }
2330
2331 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2332 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2333 public override string ToString() {
2334 return pb::JsonFormatter.ToDiagnosticString(this);
2335 }
2336
2337 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2338 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2339 public void WriteTo(pb::CodedOutputStream output) {
2340 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2341 output.WriteRawMessage(this);
2342 #else
2343 if (HasFeasibilityRule) {
2344 output.WriteRawTag(8);
2345 output.WriteEnum((int) FeasibilityRule);
2346 }
2347 if (HasOptimizationRule) {
2348 output.WriteRawTag(16);
2349 output.WriteEnum((int) OptimizationRule);
2350 }
2351 if (HasRefactorizationThreshold) {
2352 output.WriteRawTag(49);
2353 output.WriteDouble(RefactorizationThreshold);
2354 }
2355 if (HasRecomputeReducedCostsThreshold) {
2356 output.WriteRawTag(65);
2357 output.WriteDouble(RecomputeReducedCostsThreshold);
2359 if (HasRecomputeEdgesNormThreshold) {
2360 output.WriteRawTag(73);
2361 output.WriteDouble(RecomputeEdgesNormThreshold);
2362 }
2363 if (HasPrimalFeasibilityTolerance) {
2364 output.WriteRawTag(81);
2365 output.WriteDouble(PrimalFeasibilityTolerance);
2366 }
2367 if (HasDualFeasibilityTolerance) {
2368 output.WriteRawTag(89);
2369 output.WriteDouble(DualFeasibilityTolerance);
2370 }
2371 if (HasRatioTestZeroThreshold) {
2372 output.WriteRawTag(97);
2373 output.WriteDouble(RatioTestZeroThreshold);
2374 }
2375 if (HasHarrisToleranceRatio) {
2376 output.WriteRawTag(105);
2377 output.WriteDouble(HarrisToleranceRatio);
2378 }
2379 if (HasSmallPivotThreshold) {
2380 output.WriteRawTag(113);
2381 output.WriteDouble(SmallPivotThreshold);
2382 }
2383 if (HasMinimumAcceptablePivot) {
2384 output.WriteRawTag(121);
2385 output.WriteDouble(MinimumAcceptablePivot);
2386 }
2387 if (HasUseScaling) {
2388 output.WriteRawTag(128, 1);
2389 output.WriteBool(UseScaling);
2390 }
2391 if (HasInitialBasis) {
2392 output.WriteRawTag(136, 1);
2393 output.WriteEnum((int) InitialBasis);
2394 }
2395 if (HasUseTransposedMatrix) {
2396 output.WriteRawTag(144, 1);
2397 output.WriteBool(UseTransposedMatrix);
2398 }
2399 if (HasBasisRefactorizationPeriod) {
2400 output.WriteRawTag(152, 1);
2401 output.WriteInt32(BasisRefactorizationPeriod);
2402 }
2403 if (HasSolveDualProblem) {
2404 output.WriteRawTag(160, 1);
2405 output.WriteEnum((int) SolveDualProblem);
2406 }
2407 if (HasDualizerThreshold) {
2408 output.WriteRawTag(169, 1);
2409 output.WriteDouble(DualizerThreshold);
2410 }
2411 if (HasSolutionFeasibilityTolerance) {
2412 output.WriteRawTag(177, 1);
2413 output.WriteDouble(SolutionFeasibilityTolerance);
2414 }
2415 if (HasProvideStrongOptimalGuarantee) {
2416 output.WriteRawTag(192, 1);
2417 output.WriteBool(ProvideStrongOptimalGuarantee);
2418 }
2419 if (HasLuFactorizationPivotThreshold) {
2420 output.WriteRawTag(201, 1);
2421 output.WriteDouble(LuFactorizationPivotThreshold);
2422 }
2423 if (HasMaxTimeInSeconds) {
2424 output.WriteRawTag(209, 1);
2425 output.WriteDouble(MaxTimeInSeconds);
2426 }
2427 if (HasMaxNumberOfIterations) {
2428 output.WriteRawTag(216, 1);
2429 output.WriteInt64(MaxNumberOfIterations);
2430 }
2431 if (HasMarkowitzZlatevParameter) {
2432 output.WriteRawTag(232, 1);
2433 output.WriteInt32(MarkowitzZlatevParameter);
2434 }
2435 if (HasMarkowitzSingularityThreshold) {
2436 output.WriteRawTag(241, 1);
2437 output.WriteDouble(MarkowitzSingularityThreshold);
2438 }
2439 if (HasUseDualSimplex) {
2440 output.WriteRawTag(248, 1);
2441 output.WriteBool(UseDualSimplex);
2442 }
2443 if (HasAllowSimplexAlgorithmChange) {
2444 output.WriteRawTag(128, 2);
2445 output.WriteBool(AllowSimplexAlgorithmChange);
2446 }
2447 if (HasDevexWeightsResetPeriod) {
2448 output.WriteRawTag(136, 2);
2449 output.WriteInt32(DevexWeightsResetPeriod);
2450 }
2451 if (HasUsePreprocessing) {
2452 output.WriteRawTag(144, 2);
2453 output.WriteBool(UsePreprocessing);
2454 }
2455 if (HasUseMiddleProductFormUpdate) {
2456 output.WriteRawTag(152, 2);
2457 output.WriteBool(UseMiddleProductFormUpdate);
2458 }
2459 if (HasInitializeDevexWithColumnNorms) {
2460 output.WriteRawTag(160, 2);
2461 output.WriteBool(InitializeDevexWithColumnNorms);
2462 }
2463 if (HasExploitSingletonColumnInInitialBasis) {
2464 output.WriteRawTag(168, 2);
2465 output.WriteBool(ExploitSingletonColumnInInitialBasis);
2466 }
2467 if (HasDualSmallPivotThreshold) {
2468 output.WriteRawTag(177, 2);
2469 output.WriteDouble(DualSmallPivotThreshold);
2470 }
2471 if (HasPreprocessorZeroTolerance) {
2472 output.WriteRawTag(185, 2);
2473 output.WriteDouble(PreprocessorZeroTolerance);
2474 }
2475 if (HasObjectiveLowerLimit) {
2476 output.WriteRawTag(193, 2);
2477 output.WriteDouble(ObjectiveLowerLimit);
2478 }
2479 if (HasObjectiveUpperLimit) {
2480 output.WriteRawTag(201, 2);
2481 output.WriteDouble(ObjectiveUpperLimit);
2482 }
2483 if (HasDegenerateMinistepFactor) {
2484 output.WriteRawTag(209, 2);
2485 output.WriteDouble(DegenerateMinistepFactor);
2486 }
2487 if (HasRandomSeed) {
2488 output.WriteRawTag(216, 2);
2489 output.WriteInt32(RandomSeed);
2490 }
2491 if (HasNumOmpThreads) {
2492 output.WriteRawTag(224, 2);
2493 output.WriteInt32(NumOmpThreads);
2494 }
2495 if (HasMaxDeterministicTime) {
2496 output.WriteRawTag(233, 2);
2497 output.WriteDouble(MaxDeterministicTime);
2498 }
2499 if (HasDropTolerance) {
2500 output.WriteRawTag(161, 3);
2501 output.WriteDouble(DropTolerance);
2502 }
2503 if (HasPerturbCostsInDualSimplex) {
2504 output.WriteRawTag(168, 3);
2505 output.WriteBool(PerturbCostsInDualSimplex);
2506 }
2507 if (HasRelativeCostPerturbation) {
2508 output.WriteRawTag(177, 3);
2509 output.WriteDouble(RelativeCostPerturbation);
2510 }
2511 if (HasRelativeMaxCostPerturbation) {
2512 output.WriteRawTag(185, 3);
2513 output.WriteDouble(RelativeMaxCostPerturbation);
2514 }
2515 if (HasMaxNumberOfReoptimizations) {
2516 output.WriteRawTag(193, 3);
2517 output.WriteDouble(MaxNumberOfReoptimizations);
2518 }
2519 if (HasScalingMethod) {
2520 output.WriteRawTag(200, 3);
2521 output.WriteEnum((int) ScalingMethod);
2522 }
2523 if (HasChangeStatusToImprecise) {
2524 output.WriteRawTag(208, 3);
2525 output.WriteBool(ChangeStatusToImprecise);
2526 }
2527 if (HasInitialConditionNumberThreshold) {
2528 output.WriteRawTag(217, 3);
2529 output.WriteDouble(InitialConditionNumberThreshold);
2530 }
2531 if (HasCostScaling) {
2532 output.WriteRawTag(224, 3);
2533 output.WriteEnum((int) CostScaling);
2534 }
2535 if (HasLogSearchProgress) {
2536 output.WriteRawTag(232, 3);
2537 output.WriteBool(LogSearchProgress);
2538 }
2539 if (HasUseDedicatedDualFeasibilityAlgorithm) {
2540 output.WriteRawTag(240, 3);
2541 output.WriteBool(UseDedicatedDualFeasibilityAlgorithm);
2542 }
2543 if (HasDynamicallyAdjustRefactorizationPeriod) {
2544 output.WriteRawTag(248, 3);
2545 output.WriteBool(DynamicallyAdjustRefactorizationPeriod);
2546 }
2547 if (HasCrossoverBoundSnappingDistance) {
2548 output.WriteRawTag(129, 4);
2549 output.WriteDouble(CrossoverBoundSnappingDistance);
2550 }
2551 if (HasPushToVertex) {
2552 output.WriteRawTag(136, 4);
2553 output.WriteBool(PushToVertex);
2554 }
2555 if (HasLogToStdout) {
2556 output.WriteRawTag(144, 4);
2557 output.WriteBool(LogToStdout);
2558 }
2559 if (HasUseImpliedFreePreprocessor) {
2560 output.WriteRawTag(152, 4);
2561 output.WriteBool(UseImpliedFreePreprocessor);
2562 }
2563 if (HasDualPricePrioritizeNorm) {
2564 output.WriteRawTag(168, 4);
2565 output.WriteBool(DualPricePrioritizeNorm);
2566 }
2567 if (HasMaxValidMagnitude) {
2568 output.WriteRawTag(177, 4);
2569 output.WriteDouble(MaxValidMagnitude);
2570 }
2571 if (HasDropMagnitude) {
2572 output.WriteRawTag(185, 4);
2573 output.WriteDouble(DropMagnitude);
2574 }
2575 if (HasUseAbslRandom) {
2576 output.WriteRawTag(192, 4);
2577 output.WriteBool(UseAbslRandom);
2578 }
2579 if (_unknownFields != null) {
2580 _unknownFields.WriteTo(output);
2581 }
2582 #endif
2583 }
2584
2585 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2586 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2587 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2588 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
2589 if (HasFeasibilityRule) {
2590 output.WriteRawTag(8);
2591 output.WriteEnum((int) FeasibilityRule);
2592 }
2593 if (HasOptimizationRule) {
2594 output.WriteRawTag(16);
2595 output.WriteEnum((int) OptimizationRule);
2596 }
2597 if (HasRefactorizationThreshold) {
2598 output.WriteRawTag(49);
2599 output.WriteDouble(RefactorizationThreshold);
2600 }
2601 if (HasRecomputeReducedCostsThreshold) {
2602 output.WriteRawTag(65);
2603 output.WriteDouble(RecomputeReducedCostsThreshold);
2604 }
2605 if (HasRecomputeEdgesNormThreshold) {
2606 output.WriteRawTag(73);
2607 output.WriteDouble(RecomputeEdgesNormThreshold);
2608 }
2609 if (HasPrimalFeasibilityTolerance) {
2610 output.WriteRawTag(81);
2611 output.WriteDouble(PrimalFeasibilityTolerance);
2612 }
2613 if (HasDualFeasibilityTolerance) {
2614 output.WriteRawTag(89);
2615 output.WriteDouble(DualFeasibilityTolerance);
2616 }
2617 if (HasRatioTestZeroThreshold) {
2618 output.WriteRawTag(97);
2619 output.WriteDouble(RatioTestZeroThreshold);
2620 }
2621 if (HasHarrisToleranceRatio) {
2622 output.WriteRawTag(105);
2623 output.WriteDouble(HarrisToleranceRatio);
2624 }
2625 if (HasSmallPivotThreshold) {
2626 output.WriteRawTag(113);
2627 output.WriteDouble(SmallPivotThreshold);
2628 }
2629 if (HasMinimumAcceptablePivot) {
2630 output.WriteRawTag(121);
2631 output.WriteDouble(MinimumAcceptablePivot);
2632 }
2633 if (HasUseScaling) {
2634 output.WriteRawTag(128, 1);
2635 output.WriteBool(UseScaling);
2636 }
2637 if (HasInitialBasis) {
2638 output.WriteRawTag(136, 1);
2639 output.WriteEnum((int) InitialBasis);
2640 }
2641 if (HasUseTransposedMatrix) {
2642 output.WriteRawTag(144, 1);
2643 output.WriteBool(UseTransposedMatrix);
2644 }
2645 if (HasBasisRefactorizationPeriod) {
2646 output.WriteRawTag(152, 1);
2647 output.WriteInt32(BasisRefactorizationPeriod);
2648 }
2649 if (HasSolveDualProblem) {
2650 output.WriteRawTag(160, 1);
2651 output.WriteEnum((int) SolveDualProblem);
2652 }
2653 if (HasDualizerThreshold) {
2654 output.WriteRawTag(169, 1);
2655 output.WriteDouble(DualizerThreshold);
2656 }
2657 if (HasSolutionFeasibilityTolerance) {
2658 output.WriteRawTag(177, 1);
2659 output.WriteDouble(SolutionFeasibilityTolerance);
2660 }
2661 if (HasProvideStrongOptimalGuarantee) {
2662 output.WriteRawTag(192, 1);
2663 output.WriteBool(ProvideStrongOptimalGuarantee);
2664 }
2665 if (HasLuFactorizationPivotThreshold) {
2666 output.WriteRawTag(201, 1);
2667 output.WriteDouble(LuFactorizationPivotThreshold);
2668 }
2669 if (HasMaxTimeInSeconds) {
2670 output.WriteRawTag(209, 1);
2671 output.WriteDouble(MaxTimeInSeconds);
2672 }
2673 if (HasMaxNumberOfIterations) {
2674 output.WriteRawTag(216, 1);
2675 output.WriteInt64(MaxNumberOfIterations);
2676 }
2677 if (HasMarkowitzZlatevParameter) {
2678 output.WriteRawTag(232, 1);
2679 output.WriteInt32(MarkowitzZlatevParameter);
2680 }
2681 if (HasMarkowitzSingularityThreshold) {
2682 output.WriteRawTag(241, 1);
2683 output.WriteDouble(MarkowitzSingularityThreshold);
2684 }
2685 if (HasUseDualSimplex) {
2686 output.WriteRawTag(248, 1);
2687 output.WriteBool(UseDualSimplex);
2688 }
2689 if (HasAllowSimplexAlgorithmChange) {
2690 output.WriteRawTag(128, 2);
2691 output.WriteBool(AllowSimplexAlgorithmChange);
2692 }
2693 if (HasDevexWeightsResetPeriod) {
2694 output.WriteRawTag(136, 2);
2695 output.WriteInt32(DevexWeightsResetPeriod);
2696 }
2697 if (HasUsePreprocessing) {
2698 output.WriteRawTag(144, 2);
2699 output.WriteBool(UsePreprocessing);
2700 }
2701 if (HasUseMiddleProductFormUpdate) {
2702 output.WriteRawTag(152, 2);
2703 output.WriteBool(UseMiddleProductFormUpdate);
2704 }
2705 if (HasInitializeDevexWithColumnNorms) {
2706 output.WriteRawTag(160, 2);
2707 output.WriteBool(InitializeDevexWithColumnNorms);
2708 }
2709 if (HasExploitSingletonColumnInInitialBasis) {
2710 output.WriteRawTag(168, 2);
2711 output.WriteBool(ExploitSingletonColumnInInitialBasis);
2712 }
2713 if (HasDualSmallPivotThreshold) {
2714 output.WriteRawTag(177, 2);
2715 output.WriteDouble(DualSmallPivotThreshold);
2716 }
2717 if (HasPreprocessorZeroTolerance) {
2718 output.WriteRawTag(185, 2);
2719 output.WriteDouble(PreprocessorZeroTolerance);
2720 }
2721 if (HasObjectiveLowerLimit) {
2722 output.WriteRawTag(193, 2);
2723 output.WriteDouble(ObjectiveLowerLimit);
2724 }
2725 if (HasObjectiveUpperLimit) {
2726 output.WriteRawTag(201, 2);
2727 output.WriteDouble(ObjectiveUpperLimit);
2728 }
2729 if (HasDegenerateMinistepFactor) {
2730 output.WriteRawTag(209, 2);
2731 output.WriteDouble(DegenerateMinistepFactor);
2732 }
2733 if (HasRandomSeed) {
2734 output.WriteRawTag(216, 2);
2735 output.WriteInt32(RandomSeed);
2736 }
2737 if (HasNumOmpThreads) {
2738 output.WriteRawTag(224, 2);
2739 output.WriteInt32(NumOmpThreads);
2740 }
2741 if (HasMaxDeterministicTime) {
2742 output.WriteRawTag(233, 2);
2743 output.WriteDouble(MaxDeterministicTime);
2744 }
2745 if (HasDropTolerance) {
2746 output.WriteRawTag(161, 3);
2747 output.WriteDouble(DropTolerance);
2748 }
2749 if (HasPerturbCostsInDualSimplex) {
2750 output.WriteRawTag(168, 3);
2751 output.WriteBool(PerturbCostsInDualSimplex);
2752 }
2753 if (HasRelativeCostPerturbation) {
2754 output.WriteRawTag(177, 3);
2755 output.WriteDouble(RelativeCostPerturbation);
2756 }
2757 if (HasRelativeMaxCostPerturbation) {
2758 output.WriteRawTag(185, 3);
2759 output.WriteDouble(RelativeMaxCostPerturbation);
2760 }
2761 if (HasMaxNumberOfReoptimizations) {
2762 output.WriteRawTag(193, 3);
2763 output.WriteDouble(MaxNumberOfReoptimizations);
2764 }
2765 if (HasScalingMethod) {
2766 output.WriteRawTag(200, 3);
2767 output.WriteEnum((int) ScalingMethod);
2768 }
2769 if (HasChangeStatusToImprecise) {
2770 output.WriteRawTag(208, 3);
2771 output.WriteBool(ChangeStatusToImprecise);
2772 }
2773 if (HasInitialConditionNumberThreshold) {
2774 output.WriteRawTag(217, 3);
2775 output.WriteDouble(InitialConditionNumberThreshold);
2776 }
2777 if (HasCostScaling) {
2778 output.WriteRawTag(224, 3);
2779 output.WriteEnum((int) CostScaling);
2780 }
2781 if (HasLogSearchProgress) {
2782 output.WriteRawTag(232, 3);
2783 output.WriteBool(LogSearchProgress);
2784 }
2785 if (HasUseDedicatedDualFeasibilityAlgorithm) {
2786 output.WriteRawTag(240, 3);
2787 output.WriteBool(UseDedicatedDualFeasibilityAlgorithm);
2788 }
2789 if (HasDynamicallyAdjustRefactorizationPeriod) {
2790 output.WriteRawTag(248, 3);
2791 output.WriteBool(DynamicallyAdjustRefactorizationPeriod);
2792 }
2793 if (HasCrossoverBoundSnappingDistance) {
2794 output.WriteRawTag(129, 4);
2795 output.WriteDouble(CrossoverBoundSnappingDistance);
2796 }
2797 if (HasPushToVertex) {
2798 output.WriteRawTag(136, 4);
2799 output.WriteBool(PushToVertex);
2800 }
2801 if (HasLogToStdout) {
2802 output.WriteRawTag(144, 4);
2803 output.WriteBool(LogToStdout);
2804 }
2805 if (HasUseImpliedFreePreprocessor) {
2806 output.WriteRawTag(152, 4);
2807 output.WriteBool(UseImpliedFreePreprocessor);
2808 }
2809 if (HasDualPricePrioritizeNorm) {
2810 output.WriteRawTag(168, 4);
2811 output.WriteBool(DualPricePrioritizeNorm);
2812 }
2813 if (HasMaxValidMagnitude) {
2814 output.WriteRawTag(177, 4);
2815 output.WriteDouble(MaxValidMagnitude);
2816 }
2817 if (HasDropMagnitude) {
2818 output.WriteRawTag(185, 4);
2819 output.WriteDouble(DropMagnitude);
2820 }
2821 if (HasUseAbslRandom) {
2822 output.WriteRawTag(192, 4);
2823 output.WriteBool(UseAbslRandom);
2824 }
2825 if (_unknownFields != null) {
2826 _unknownFields.WriteTo(ref output);
2827 }
2828 }
2829 #endif
2830
2831 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2832 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2833 public int CalculateSize() {
2834 int size = 0;
2835 if (HasScalingMethod) {
2836 size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) ScalingMethod);
2837 }
2838 if (HasFeasibilityRule) {
2839 size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) FeasibilityRule);
2840 }
2841 if (HasOptimizationRule) {
2842 size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) OptimizationRule);
2843 }
2844 if (HasRefactorizationThreshold) {
2845 size += 1 + 8;
2846 }
2847 if (HasRecomputeReducedCostsThreshold) {
2848 size += 1 + 8;
2849 }
2850 if (HasRecomputeEdgesNormThreshold) {
2851 size += 1 + 8;
2853 if (HasPrimalFeasibilityTolerance) {
2854 size += 1 + 8;
2855 }
2856 if (HasDualFeasibilityTolerance) {
2857 size += 1 + 8;
2858 }
2859 if (HasRatioTestZeroThreshold) {
2860 size += 1 + 8;
2861 }
2862 if (HasHarrisToleranceRatio) {
2863 size += 1 + 8;
2864 }
2865 if (HasSmallPivotThreshold) {
2866 size += 1 + 8;
2867 }
2868 if (HasMinimumAcceptablePivot) {
2869 size += 1 + 8;
2870 }
2871 if (HasDropTolerance) {
2872 size += 2 + 8;
2873 }
2874 if (HasUseScaling) {
2875 size += 2 + 1;
2876 }
2877 if (HasCostScaling) {
2878 size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) CostScaling);
2879 }
2880 if (HasInitialBasis) {
2881 size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) InitialBasis);
2882 }
2883 if (HasUseTransposedMatrix) {
2884 size += 2 + 1;
2885 }
2886 if (HasBasisRefactorizationPeriod) {
2887 size += 2 + pb::CodedOutputStream.ComputeInt32Size(BasisRefactorizationPeriod);
2888 }
2889 if (HasDynamicallyAdjustRefactorizationPeriod) {
2890 size += 2 + 1;
2891 }
2892 if (HasSolveDualProblem) {
2893 size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) SolveDualProblem);
2894 }
2895 if (HasDualizerThreshold) {
2896 size += 2 + 8;
2897 }
2898 if (HasSolutionFeasibilityTolerance) {
2899 size += 2 + 8;
2900 }
2901 if (HasProvideStrongOptimalGuarantee) {
2902 size += 2 + 1;
2903 }
2904 if (HasChangeStatusToImprecise) {
2905 size += 2 + 1;
2906 }
2907 if (HasMaxNumberOfReoptimizations) {
2908 size += 2 + 8;
2909 }
2910 if (HasLuFactorizationPivotThreshold) {
2911 size += 2 + 8;
2912 }
2913 if (HasMaxTimeInSeconds) {
2914 size += 2 + 8;
2915 }
2916 if (HasMaxDeterministicTime) {
2917 size += 2 + 8;
2918 }
2919 if (HasMaxNumberOfIterations) {
2920 size += 2 + pb::CodedOutputStream.ComputeInt64Size(MaxNumberOfIterations);
2921 }
2922 if (HasMarkowitzZlatevParameter) {
2923 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MarkowitzZlatevParameter);
2924 }
2925 if (HasMarkowitzSingularityThreshold) {
2926 size += 2 + 8;
2927 }
2928 if (HasUseDualSimplex) {
2929 size += 2 + 1;
2930 }
2931 if (HasAllowSimplexAlgorithmChange) {
2932 size += 2 + 1;
2933 }
2934 if (HasDevexWeightsResetPeriod) {
2935 size += 2 + pb::CodedOutputStream.ComputeInt32Size(DevexWeightsResetPeriod);
2936 }
2937 if (HasUsePreprocessing) {
2938 size += 2 + 1;
2939 }
2940 if (HasUseMiddleProductFormUpdate) {
2941 size += 2 + 1;
2942 }
2943 if (HasInitializeDevexWithColumnNorms) {
2944 size += 2 + 1;
2945 }
2946 if (HasExploitSingletonColumnInInitialBasis) {
2947 size += 2 + 1;
2948 }
2949 if (HasDualSmallPivotThreshold) {
2950 size += 2 + 8;
2951 }
2952 if (HasPreprocessorZeroTolerance) {
2953 size += 2 + 8;
2954 }
2955 if (HasObjectiveLowerLimit) {
2956 size += 2 + 8;
2957 }
2958 if (HasObjectiveUpperLimit) {
2959 size += 2 + 8;
2960 }
2961 if (HasDegenerateMinistepFactor) {
2962 size += 2 + 8;
2963 }
2964 if (HasRandomSeed) {
2965 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RandomSeed);
2966 }
2967 if (HasUseAbslRandom) {
2968 size += 2 + 1;
2969 }
2970 if (HasNumOmpThreads) {
2971 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumOmpThreads);
2972 }
2973 if (HasPerturbCostsInDualSimplex) {
2974 size += 2 + 1;
2975 }
2976 if (HasUseDedicatedDualFeasibilityAlgorithm) {
2977 size += 2 + 1;
2978 }
2979 if (HasRelativeCostPerturbation) {
2980 size += 2 + 8;
2981 }
2982 if (HasRelativeMaxCostPerturbation) {
2983 size += 2 + 8;
2984 }
2985 if (HasInitialConditionNumberThreshold) {
2986 size += 2 + 8;
2987 }
2988 if (HasLogSearchProgress) {
2989 size += 2 + 1;
2990 }
2991 if (HasLogToStdout) {
2992 size += 2 + 1;
2993 }
2994 if (HasCrossoverBoundSnappingDistance) {
2995 size += 2 + 8;
2996 }
2997 if (HasPushToVertex) {
2998 size += 2 + 1;
2999 }
3000 if (HasUseImpliedFreePreprocessor) {
3001 size += 2 + 1;
3002 }
3003 if (HasMaxValidMagnitude) {
3004 size += 2 + 8;
3005 }
3006 if (HasDropMagnitude) {
3007 size += 2 + 8;
3008 }
3009 if (HasDualPricePrioritizeNorm) {
3010 size += 2 + 1;
3011 }
3012 if (_unknownFields != null) {
3013 size += _unknownFields.CalculateSize();
3014 }
3015 return size;
3016 }
3017
3018 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3019 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
3020 public void MergeFrom(GlopParameters other) {
3021 if (other == null) {
3022 return;
3023 }
3024 if (other.HasScalingMethod) {
3025 ScalingMethod = other.ScalingMethod;
3026 }
3027 if (other.HasFeasibilityRule) {
3028 FeasibilityRule = other.FeasibilityRule;
3029 }
3030 if (other.HasOptimizationRule) {
3031 OptimizationRule = other.OptimizationRule;
3032 }
3033 if (other.HasRefactorizationThreshold) {
3034 RefactorizationThreshold = other.RefactorizationThreshold;
3035 }
3036 if (other.HasRecomputeReducedCostsThreshold) {
3037 RecomputeReducedCostsThreshold = other.RecomputeReducedCostsThreshold;
3038 }
3039 if (other.HasRecomputeEdgesNormThreshold) {
3040 RecomputeEdgesNormThreshold = other.RecomputeEdgesNormThreshold;
3041 }
3042 if (other.HasPrimalFeasibilityTolerance) {
3043 PrimalFeasibilityTolerance = other.PrimalFeasibilityTolerance;
3044 }
3045 if (other.HasDualFeasibilityTolerance) {
3046 DualFeasibilityTolerance = other.DualFeasibilityTolerance;
3047 }
3048 if (other.HasRatioTestZeroThreshold) {
3049 RatioTestZeroThreshold = other.RatioTestZeroThreshold;
3050 }
3051 if (other.HasHarrisToleranceRatio) {
3052 HarrisToleranceRatio = other.HarrisToleranceRatio;
3053 }
3054 if (other.HasSmallPivotThreshold) {
3055 SmallPivotThreshold = other.SmallPivotThreshold;
3056 }
3057 if (other.HasMinimumAcceptablePivot) {
3058 MinimumAcceptablePivot = other.MinimumAcceptablePivot;
3059 }
3060 if (other.HasDropTolerance) {
3061 DropTolerance = other.DropTolerance;
3062 }
3063 if (other.HasUseScaling) {
3064 UseScaling = other.UseScaling;
3065 }
3066 if (other.HasCostScaling) {
3067 CostScaling = other.CostScaling;
3068 }
3069 if (other.HasInitialBasis) {
3070 InitialBasis = other.InitialBasis;
3071 }
3072 if (other.HasUseTransposedMatrix) {
3073 UseTransposedMatrix = other.UseTransposedMatrix;
3074 }
3075 if (other.HasBasisRefactorizationPeriod) {
3076 BasisRefactorizationPeriod = other.BasisRefactorizationPeriod;
3077 }
3078 if (other.HasDynamicallyAdjustRefactorizationPeriod) {
3079 DynamicallyAdjustRefactorizationPeriod = other.DynamicallyAdjustRefactorizationPeriod;
3080 }
3081 if (other.HasSolveDualProblem) {
3082 SolveDualProblem = other.SolveDualProblem;
3083 }
3084 if (other.HasDualizerThreshold) {
3085 DualizerThreshold = other.DualizerThreshold;
3086 }
3087 if (other.HasSolutionFeasibilityTolerance) {
3088 SolutionFeasibilityTolerance = other.SolutionFeasibilityTolerance;
3089 }
3090 if (other.HasProvideStrongOptimalGuarantee) {
3091 ProvideStrongOptimalGuarantee = other.ProvideStrongOptimalGuarantee;
3092 }
3093 if (other.HasChangeStatusToImprecise) {
3094 ChangeStatusToImprecise = other.ChangeStatusToImprecise;
3095 }
3096 if (other.HasMaxNumberOfReoptimizations) {
3097 MaxNumberOfReoptimizations = other.MaxNumberOfReoptimizations;
3098 }
3099 if (other.HasLuFactorizationPivotThreshold) {
3100 LuFactorizationPivotThreshold = other.LuFactorizationPivotThreshold;
3101 }
3102 if (other.HasMaxTimeInSeconds) {
3103 MaxTimeInSeconds = other.MaxTimeInSeconds;
3104 }
3105 if (other.HasMaxDeterministicTime) {
3106 MaxDeterministicTime = other.MaxDeterministicTime;
3107 }
3108 if (other.HasMaxNumberOfIterations) {
3109 MaxNumberOfIterations = other.MaxNumberOfIterations;
3110 }
3111 if (other.HasMarkowitzZlatevParameter) {
3112 MarkowitzZlatevParameter = other.MarkowitzZlatevParameter;
3113 }
3114 if (other.HasMarkowitzSingularityThreshold) {
3115 MarkowitzSingularityThreshold = other.MarkowitzSingularityThreshold;
3116 }
3117 if (other.HasUseDualSimplex) {
3118 UseDualSimplex = other.UseDualSimplex;
3119 }
3120 if (other.HasAllowSimplexAlgorithmChange) {
3121 AllowSimplexAlgorithmChange = other.AllowSimplexAlgorithmChange;
3122 }
3123 if (other.HasDevexWeightsResetPeriod) {
3124 DevexWeightsResetPeriod = other.DevexWeightsResetPeriod;
3125 }
3126 if (other.HasUsePreprocessing) {
3127 UsePreprocessing = other.UsePreprocessing;
3128 }
3129 if (other.HasUseMiddleProductFormUpdate) {
3130 UseMiddleProductFormUpdate = other.UseMiddleProductFormUpdate;
3131 }
3132 if (other.HasInitializeDevexWithColumnNorms) {
3133 InitializeDevexWithColumnNorms = other.InitializeDevexWithColumnNorms;
3134 }
3135 if (other.HasExploitSingletonColumnInInitialBasis) {
3136 ExploitSingletonColumnInInitialBasis = other.ExploitSingletonColumnInInitialBasis;
3137 }
3138 if (other.HasDualSmallPivotThreshold) {
3139 DualSmallPivotThreshold = other.DualSmallPivotThreshold;
3140 }
3141 if (other.HasPreprocessorZeroTolerance) {
3142 PreprocessorZeroTolerance = other.PreprocessorZeroTolerance;
3143 }
3144 if (other.HasObjectiveLowerLimit) {
3145 ObjectiveLowerLimit = other.ObjectiveLowerLimit;
3146 }
3147 if (other.HasObjectiveUpperLimit) {
3148 ObjectiveUpperLimit = other.ObjectiveUpperLimit;
3149 }
3150 if (other.HasDegenerateMinistepFactor) {
3151 DegenerateMinistepFactor = other.DegenerateMinistepFactor;
3152 }
3153 if (other.HasRandomSeed) {
3154 RandomSeed = other.RandomSeed;
3155 }
3156 if (other.HasUseAbslRandom) {
3157 UseAbslRandom = other.UseAbslRandom;
3158 }
3159 if (other.HasNumOmpThreads) {
3160 NumOmpThreads = other.NumOmpThreads;
3161 }
3162 if (other.HasPerturbCostsInDualSimplex) {
3163 PerturbCostsInDualSimplex = other.PerturbCostsInDualSimplex;
3164 }
3165 if (other.HasUseDedicatedDualFeasibilityAlgorithm) {
3166 UseDedicatedDualFeasibilityAlgorithm = other.UseDedicatedDualFeasibilityAlgorithm;
3167 }
3168 if (other.HasRelativeCostPerturbation) {
3169 RelativeCostPerturbation = other.RelativeCostPerturbation;
3170 }
3171 if (other.HasRelativeMaxCostPerturbation) {
3172 RelativeMaxCostPerturbation = other.RelativeMaxCostPerturbation;
3173 }
3174 if (other.HasInitialConditionNumberThreshold) {
3175 InitialConditionNumberThreshold = other.InitialConditionNumberThreshold;
3176 }
3177 if (other.HasLogSearchProgress) {
3178 LogSearchProgress = other.LogSearchProgress;
3179 }
3180 if (other.HasLogToStdout) {
3181 LogToStdout = other.LogToStdout;
3182 }
3183 if (other.HasCrossoverBoundSnappingDistance) {
3184 CrossoverBoundSnappingDistance = other.CrossoverBoundSnappingDistance;
3185 }
3186 if (other.HasPushToVertex) {
3187 PushToVertex = other.PushToVertex;
3188 }
3189 if (other.HasUseImpliedFreePreprocessor) {
3190 UseImpliedFreePreprocessor = other.UseImpliedFreePreprocessor;
3191 }
3192 if (other.HasMaxValidMagnitude) {
3193 MaxValidMagnitude = other.MaxValidMagnitude;
3194 }
3195 if (other.HasDropMagnitude) {
3196 DropMagnitude = other.DropMagnitude;
3197 }
3198 if (other.HasDualPricePrioritizeNorm) {
3199 DualPricePrioritizeNorm = other.DualPricePrioritizeNorm;
3200 }
3201 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
3202 }
3203
3204 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3205 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
3206 public void MergeFrom(pb::CodedInputStream input) {
3207 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3208 input.ReadRawMessage(this);
3209 #else
3210 uint tag;
3211 while ((tag = input.ReadTag()) != 0) {
3212 if ((tag & 7) == 4) {
3213 // Abort on any end group tag.
3214 return;
3215 }
3216 switch(tag) {
3217 default:
3218 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
3219 break;
3220 case 8: {
3221 FeasibilityRule = (global::Google.OrTools.Glop.GlopParameters.Types.PricingRule) input.ReadEnum();
3222 break;
3223 }
3224 case 16: {
3225 OptimizationRule = (global::Google.OrTools.Glop.GlopParameters.Types.PricingRule) input.ReadEnum();
3226 break;
3227 }
3228 case 49: {
3229 RefactorizationThreshold = input.ReadDouble();
3230 break;
3231 }
3232 case 65: {
3233 RecomputeReducedCostsThreshold = input.ReadDouble();
3234 break;
3235 }
3236 case 73: {
3237 RecomputeEdgesNormThreshold = input.ReadDouble();
3238 break;
3239 }
3240 case 81: {
3241 PrimalFeasibilityTolerance = input.ReadDouble();
3242 break;
3243 }
3244 case 89: {
3245 DualFeasibilityTolerance = input.ReadDouble();
3246 break;
3247 }
3248 case 97: {
3249 RatioTestZeroThreshold = input.ReadDouble();
3250 break;
3251 }
3252 case 105: {
3253 HarrisToleranceRatio = input.ReadDouble();
3254 break;
3255 }
3256 case 113: {
3257 SmallPivotThreshold = input.ReadDouble();
3258 break;
3259 }
3260 case 121: {
3261 MinimumAcceptablePivot = input.ReadDouble();
3262 break;
3263 }
3264 case 128: {
3265 UseScaling = input.ReadBool();
3266 break;
3267 }
3268 case 136: {
3269 InitialBasis = (global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic) input.ReadEnum();
3270 break;
3271 }
3272 case 144: {
3273 UseTransposedMatrix = input.ReadBool();
3274 break;
3275 }
3276 case 152: {
3277 BasisRefactorizationPeriod = input.ReadInt32();
3278 break;
3279 }
3280 case 160: {
3281 SolveDualProblem = (global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior) input.ReadEnum();
3282 break;
3283 }
3284 case 169: {
3285 DualizerThreshold = input.ReadDouble();
3286 break;
3287 }
3288 case 177: {
3289 SolutionFeasibilityTolerance = input.ReadDouble();
3290 break;
3291 }
3292 case 192: {
3293 ProvideStrongOptimalGuarantee = input.ReadBool();
3294 break;
3295 }
3296 case 201: {
3297 LuFactorizationPivotThreshold = input.ReadDouble();
3298 break;
3299 }
3300 case 209: {
3301 MaxTimeInSeconds = input.ReadDouble();
3302 break;
3303 }
3304 case 216: {
3305 MaxNumberOfIterations = input.ReadInt64();
3306 break;
3307 }
3308 case 232: {
3309 MarkowitzZlatevParameter = input.ReadInt32();
3310 break;
3311 }
3312 case 241: {
3313 MarkowitzSingularityThreshold = input.ReadDouble();
3314 break;
3315 }
3316 case 248: {
3317 UseDualSimplex = input.ReadBool();
3318 break;
3319 }
3320 case 256: {
3321 AllowSimplexAlgorithmChange = input.ReadBool();
3322 break;
3323 }
3324 case 264: {
3325 DevexWeightsResetPeriod = input.ReadInt32();
3326 break;
3327 }
3328 case 272: {
3329 UsePreprocessing = input.ReadBool();
3330 break;
3331 }
3332 case 280: {
3333 UseMiddleProductFormUpdate = input.ReadBool();
3334 break;
3335 }
3336 case 288: {
3337 InitializeDevexWithColumnNorms = input.ReadBool();
3338 break;
3339 }
3340 case 296: {
3341 ExploitSingletonColumnInInitialBasis = input.ReadBool();
3342 break;
3343 }
3344 case 305: {
3345 DualSmallPivotThreshold = input.ReadDouble();
3346 break;
3347 }
3348 case 313: {
3349 PreprocessorZeroTolerance = input.ReadDouble();
3350 break;
3351 }
3352 case 321: {
3353 ObjectiveLowerLimit = input.ReadDouble();
3354 break;
3355 }
3356 case 329: {
3357 ObjectiveUpperLimit = input.ReadDouble();
3358 break;
3359 }
3360 case 337: {
3361 DegenerateMinistepFactor = input.ReadDouble();
3362 break;
3363 }
3364 case 344: {
3365 RandomSeed = input.ReadInt32();
3366 break;
3367 }
3368 case 352: {
3369 NumOmpThreads = input.ReadInt32();
3370 break;
3371 }
3372 case 361: {
3373 MaxDeterministicTime = input.ReadDouble();
3374 break;
3375 }
3376 case 417: {
3377 DropTolerance = input.ReadDouble();
3378 break;
3379 }
3380 case 424: {
3381 PerturbCostsInDualSimplex = input.ReadBool();
3382 break;
3383 }
3384 case 433: {
3385 RelativeCostPerturbation = input.ReadDouble();
3386 break;
3387 }
3388 case 441: {
3389 RelativeMaxCostPerturbation = input.ReadDouble();
3390 break;
3391 }
3392 case 449: {
3393 MaxNumberOfReoptimizations = input.ReadDouble();
3394 break;
3395 }
3396 case 456: {
3397 ScalingMethod = (global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm) input.ReadEnum();
3398 break;
3399 }
3400 case 464: {
3401 ChangeStatusToImprecise = input.ReadBool();
3402 break;
3403 }
3404 case 473: {
3405 InitialConditionNumberThreshold = input.ReadDouble();
3406 break;
3407 }
3408 case 480: {
3409 CostScaling = (global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm) input.ReadEnum();
3410 break;
3411 }
3412 case 488: {
3413 LogSearchProgress = input.ReadBool();
3414 break;
3415 }
3416 case 496: {
3417 UseDedicatedDualFeasibilityAlgorithm = input.ReadBool();
3418 break;
3419 }
3420 case 504: {
3421 DynamicallyAdjustRefactorizationPeriod = input.ReadBool();
3422 break;
3423 }
3424 case 513: {
3425 CrossoverBoundSnappingDistance = input.ReadDouble();
3426 break;
3427 }
3428 case 520: {
3429 PushToVertex = input.ReadBool();
3430 break;
3431 }
3432 case 528: {
3433 LogToStdout = input.ReadBool();
3434 break;
3435 }
3436 case 536: {
3437 UseImpliedFreePreprocessor = input.ReadBool();
3438 break;
3439 }
3440 case 552: {
3441 DualPricePrioritizeNorm = input.ReadBool();
3442 break;
3443 }
3444 case 561: {
3445 MaxValidMagnitude = input.ReadDouble();
3446 break;
3447 }
3448 case 569: {
3449 DropMagnitude = input.ReadDouble();
3450 break;
3451 }
3452 case 576: {
3453 UseAbslRandom = input.ReadBool();
3454 break;
3455 }
3456 }
3457 }
3458 #endif
3459 }
3460
3461 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3462 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3463 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
3464 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
3465 uint tag;
3466 while ((tag = input.ReadTag()) != 0) {
3467 if ((tag & 7) == 4) {
3468 // Abort on any end group tag.
3469 return;
3470 }
3471 switch(tag) {
3472 default:
3473 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
3474 break;
3475 case 8: {
3476 FeasibilityRule = (global::Google.OrTools.Glop.GlopParameters.Types.PricingRule) input.ReadEnum();
3477 break;
3478 }
3479 case 16: {
3480 OptimizationRule = (global::Google.OrTools.Glop.GlopParameters.Types.PricingRule) input.ReadEnum();
3481 break;
3482 }
3483 case 49: {
3484 RefactorizationThreshold = input.ReadDouble();
3485 break;
3486 }
3487 case 65: {
3488 RecomputeReducedCostsThreshold = input.ReadDouble();
3489 break;
3490 }
3491 case 73: {
3492 RecomputeEdgesNormThreshold = input.ReadDouble();
3493 break;
3494 }
3495 case 81: {
3496 PrimalFeasibilityTolerance = input.ReadDouble();
3497 break;
3498 }
3499 case 89: {
3500 DualFeasibilityTolerance = input.ReadDouble();
3501 break;
3502 }
3503 case 97: {
3504 RatioTestZeroThreshold = input.ReadDouble();
3505 break;
3506 }
3507 case 105: {
3508 HarrisToleranceRatio = input.ReadDouble();
3509 break;
3510 }
3511 case 113: {
3512 SmallPivotThreshold = input.ReadDouble();
3513 break;
3514 }
3515 case 121: {
3516 MinimumAcceptablePivot = input.ReadDouble();
3517 break;
3518 }
3519 case 128: {
3520 UseScaling = input.ReadBool();
3521 break;
3522 }
3523 case 136: {
3524 InitialBasis = (global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic) input.ReadEnum();
3525 break;
3526 }
3527 case 144: {
3528 UseTransposedMatrix = input.ReadBool();
3529 break;
3530 }
3531 case 152: {
3532 BasisRefactorizationPeriod = input.ReadInt32();
3533 break;
3534 }
3535 case 160: {
3536 SolveDualProblem = (global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior) input.ReadEnum();
3537 break;
3538 }
3539 case 169: {
3540 DualizerThreshold = input.ReadDouble();
3541 break;
3542 }
3543 case 177: {
3544 SolutionFeasibilityTolerance = input.ReadDouble();
3545 break;
3546 }
3547 case 192: {
3548 ProvideStrongOptimalGuarantee = input.ReadBool();
3549 break;
3550 }
3551 case 201: {
3552 LuFactorizationPivotThreshold = input.ReadDouble();
3553 break;
3554 }
3555 case 209: {
3556 MaxTimeInSeconds = input.ReadDouble();
3557 break;
3558 }
3559 case 216: {
3560 MaxNumberOfIterations = input.ReadInt64();
3561 break;
3562 }
3563 case 232: {
3564 MarkowitzZlatevParameter = input.ReadInt32();
3565 break;
3566 }
3567 case 241: {
3568 MarkowitzSingularityThreshold = input.ReadDouble();
3569 break;
3570 }
3571 case 248: {
3572 UseDualSimplex = input.ReadBool();
3573 break;
3574 }
3575 case 256: {
3576 AllowSimplexAlgorithmChange = input.ReadBool();
3577 break;
3578 }
3579 case 264: {
3580 DevexWeightsResetPeriod = input.ReadInt32();
3581 break;
3582 }
3583 case 272: {
3584 UsePreprocessing = input.ReadBool();
3585 break;
3586 }
3587 case 280: {
3588 UseMiddleProductFormUpdate = input.ReadBool();
3589 break;
3590 }
3591 case 288: {
3592 InitializeDevexWithColumnNorms = input.ReadBool();
3593 break;
3594 }
3595 case 296: {
3596 ExploitSingletonColumnInInitialBasis = input.ReadBool();
3597 break;
3598 }
3599 case 305: {
3600 DualSmallPivotThreshold = input.ReadDouble();
3601 break;
3602 }
3603 case 313: {
3604 PreprocessorZeroTolerance = input.ReadDouble();
3605 break;
3606 }
3607 case 321: {
3608 ObjectiveLowerLimit = input.ReadDouble();
3609 break;
3610 }
3611 case 329: {
3612 ObjectiveUpperLimit = input.ReadDouble();
3613 break;
3614 }
3615 case 337: {
3616 DegenerateMinistepFactor = input.ReadDouble();
3617 break;
3618 }
3619 case 344: {
3620 RandomSeed = input.ReadInt32();
3621 break;
3622 }
3623 case 352: {
3624 NumOmpThreads = input.ReadInt32();
3625 break;
3626 }
3627 case 361: {
3628 MaxDeterministicTime = input.ReadDouble();
3629 break;
3630 }
3631 case 417: {
3632 DropTolerance = input.ReadDouble();
3633 break;
3634 }
3635 case 424: {
3636 PerturbCostsInDualSimplex = input.ReadBool();
3637 break;
3638 }
3639 case 433: {
3640 RelativeCostPerturbation = input.ReadDouble();
3641 break;
3642 }
3643 case 441: {
3644 RelativeMaxCostPerturbation = input.ReadDouble();
3645 break;
3646 }
3647 case 449: {
3648 MaxNumberOfReoptimizations = input.ReadDouble();
3649 break;
3650 }
3651 case 456: {
3652 ScalingMethod = (global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm) input.ReadEnum();
3653 break;
3654 }
3655 case 464: {
3656 ChangeStatusToImprecise = input.ReadBool();
3657 break;
3658 }
3659 case 473: {
3660 InitialConditionNumberThreshold = input.ReadDouble();
3661 break;
3662 }
3663 case 480: {
3664 CostScaling = (global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm) input.ReadEnum();
3665 break;
3666 }
3667 case 488: {
3668 LogSearchProgress = input.ReadBool();
3669 break;
3670 }
3671 case 496: {
3672 UseDedicatedDualFeasibilityAlgorithm = input.ReadBool();
3673 break;
3674 }
3675 case 504: {
3676 DynamicallyAdjustRefactorizationPeriod = input.ReadBool();
3677 break;
3678 }
3679 case 513: {
3680 CrossoverBoundSnappingDistance = input.ReadDouble();
3681 break;
3682 }
3683 case 520: {
3684 PushToVertex = input.ReadBool();
3685 break;
3686 }
3687 case 528: {
3688 LogToStdout = input.ReadBool();
3689 break;
3690 }
3691 case 536: {
3692 UseImpliedFreePreprocessor = input.ReadBool();
3693 break;
3694 }
3695 case 552: {
3696 DualPricePrioritizeNorm = input.ReadBool();
3697 break;
3698 }
3699 case 561: {
3700 MaxValidMagnitude = input.ReadDouble();
3701 break;
3702 }
3703 case 569: {
3704 DropMagnitude = input.ReadDouble();
3705 break;
3706 }
3707 case 576: {
3708 UseAbslRandom = input.ReadBool();
3709 break;
3710 }
3711 }
3712 }
3713 }
3714 #endif
3715
3716 #region Nested types
3718 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3719 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
3720 public static partial class Types {
3728 public enum ScalingAlgorithm {
3729 [pbr::OriginalName("DEFAULT")] Default = 0,
3730 [pbr::OriginalName("EQUILIBRATION")] Equilibration = 1,
3731 [pbr::OriginalName("LINEAR_PROGRAM")] LinearProgram = 2,
3732 }
3733
3738 public enum SolverBehavior {
3739 [pbr::OriginalName("ALWAYS_DO")] AlwaysDo = 0,
3740 [pbr::OriginalName("NEVER_DO")] NeverDo = 1,
3741 [pbr::OriginalName("LET_SOLVER_DECIDE")] LetSolverDecide = 2,
3742 }
3743
3747 public enum PricingRule {
3752
3756 [pbr::OriginalName("DANTZIG")] Dantzig = 0,
3757 /// <summary>
3758 /// Normalize the reduced costs by the norm of the edges. Since computing
3759 /// norms at each step is too expensive, reduced costs and norms are
3760 /// updated iteratively from one iteration to the next.
3761 /// </summary>
3762 [pbr::OriginalName("STEEPEST_EDGE")] SteepestEdge = 1,
3766 /// </summary>
3767 [pbr::OriginalName("DEVEX")] Devex = 2,
3768 }
3769
3774 public enum InitialBasisHeuristic {
3778 [pbr::OriginalName("NONE")] None = 0,
3787 [pbr::OriginalName("BIXBY")] Bixby = 1,
3789
3794 /// </summary>
3795 [pbr::OriginalName("TRIANGULAR")] Triangular = 2,
3801 [pbr::OriginalName("MAROS")] Maros = 3,
3802 }
3803
3811 public enum CostScalingAlgorithm {
3815 [pbr::OriginalName("NO_COST_SCALING")] NoCostScaling = 0,
3821 [pbr::OriginalName("CONTAIN_ONE_COST_SCALING")] ContainOneCostScaling = 1,
3824
3825 [pbr::OriginalName("MEAN_COST_SCALING")] MeanCostScaling = 2,
3829 [pbr::OriginalName("MEDIAN_COST_SCALING")] MedianCostScaling = 3,
3830 }
3831
3833 #endregion
3834
3835 }
3837 #endregion
3838
3839}
3840
3841#endregion Designer generated code
global::Google.Protobuf pb
global::Google.Protobuf.Reflection pbr
global::System.Collections.Generic scg
global::Google.Protobuf.Collections pbc
Container for nested types declared in the GlopParameters message type.
SolverBehavior
Like a Boolean with an extra value to let the algorithm decide what is the best choice.
ScalingAlgorithm
Supported algorithms for scaling: EQUILIBRATION - progressive scaling by row and column norms until t...
InitialBasisHeuristic
Heuristics to use in the primal simplex to remove fixed slack variables from the initial basis.
@ Triangular
Replace the fixed columns while keeping the initial basis triangular. The heuristic to select which c...
@ None
Leave the fixed slack variables in the basis.
@ Maros
Use a version of Maros's triangular feasibility crash https://books.google.fr/books?...
@ Bixby
Use the heuristic described in: Robert E. Bixby, "Implementing the Simplex Method: The Initial Basis"...
CostScalingAlgorithm
This is only used if use_scaling is true. After the scaling is done, we also scale the objective by a...
@ ContainOneCostScaling
This is the most defensive option. It makes sure that [min_cost_magnitude, max_cost_magnitude] contai...
@ MeanCostScaling
Make the mean of the non-zero costs equals to one.
@ MedianCostScaling
Make the median of the non-zero costs equals to one.
PricingRule
General strategy used during pricing.
@ Dantzig
Strategy using only the reduced cost of a variable.
@ Devex
Normalize the reduced costs by an approximation of the norm of the edges. This should offer a good tr...
@ SteepestEdge
Normalize the reduced costs by the norm of the edges. Since computing norms at each step is too expen...
double DropMagnitude
Value in the input LP lower than this will be ignored. This is similar to drop_tolerance but more agg...
bool HasExploitSingletonColumnInInitialBasis
Gets whether the "exploit_singleton_column_in_initial_basis" field is set.
bool HasLogSearchProgress
Gets whether the "log_search_progress" field is set.
bool HasDropMagnitude
Gets whether the "drop_magnitude" field is set.
bool HasDualPricePrioritizeNorm
Gets whether the "dual_price_prioritize_norm" field is set.
double InitialConditionNumberThreshold
If our upper bound on the condition number of the initial basis (from our heurisitic or a warm start)...
double DualSmallPivotThreshold
Like small_pivot_threshold but for the dual simplex. This is needed because the dual algorithm does n...
double DegenerateMinistepFactor
During a degenerate iteration, the more conservative approach is to do a step of length zero (while s...
bool InitializeDevexWithColumnNorms
Whether we initialize devex weights to 1.0 or to the norms of the matrix columns.
bool HasObjectiveUpperLimit
Gets whether the "objective_upper_limit" field is set.
double MaxValidMagnitude
Any finite values in the input LP must be below this threshold, otherwise the model will be reported ...
void ClearCostScaling()
Clears the value of the "cost_scaling" field.
global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm CostScaling
double SmallPivotThreshold
When we choose the leaving variable, we want to avoid small pivot because they are the less precise a...
void ClearRefactorizationThreshold()
Clears the value of the "refactorization_threshold" field.
double DualizerThreshold
When solve_dual_problem is LET_SOLVER_DECIDE, take the dual if the number of constraints of the probl...
const int ObjectiveUpperLimitFieldNumber
Field number for the "objective_upper_limit" field.
bool HasUsePreprocessing
Gets whether the "use_preprocessing" field is set.
const int UseImpliedFreePreprocessorFieldNumber
Field number for the "use_implied_free_preprocessor" field.
global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior SolveDualProblem
Whether or not we solve the dual of the given problem. With a value of auto, the algorithm decide whi...
bool HasLogToStdout
Gets whether the "log_to_stdout" field is set.
const int PrimalFeasibilityToleranceFieldNumber
Field number for the "primal_feasibility_tolerance" field.
bool UseMiddleProductFormUpdate
Whether or not to use the middle product form update rather than the standard eta LU update....
void ClearRandomSeed()
Clears the value of the "random_seed" field.
const int DynamicallyAdjustRefactorizationPeriodFieldNumber
Field number for the "dynamically_adjust_refactorization_period" field.
const int PushToVertexFieldNumber
Field number for the "push_to_vertex" field.
global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic InitialBasis
What heuristic is used to try to replace the fixed slack columns in the initial basis of the primal s...
void ClearScalingMethod()
Clears the value of the "scaling_method" field.
bool HasObjectiveLowerLimit
Gets whether the "objective_lower_limit" field is set.
bool UseDualSimplex
Whether or not we use the dual simplex algorithm instead of the primal.
bool HasMaxValidMagnitude
Gets whether the "max_valid_magnitude" field is set.
bool UseScaling
Whether or not we scale the matrix A so that the maximum coefficient on each line and each column is ...
const int InitialBasisFieldNumber
Field number for the "initial_basis" field.
const int UseMiddleProductFormUpdateFieldNumber
Field number for the "use_middle_product_form_update" field.
void ClearInitialConditionNumberThreshold()
Clears the value of the "initial_condition_number_threshold" field.
bool UseTransposedMatrix
Whether or not we keep a transposed version of the matrix A to speed-up the pricing at the cost of ex...
bool ChangeStatusToImprecise
If true, the internal API will change the return status to imprecise if the solution does not respect...
bool UseDedicatedDualFeasibilityAlgorithm
We have two possible dual phase I algorithms. Both work on an LP that minimize the sum of dual infeas...
bool HasMaxDeterministicTime
Gets whether the "max_deterministic_time" field is set.
double PreprocessorZeroTolerance
A floating point tolerance used by the preprocessors. This is used for things like detecting if two c...
bool HasFeasibilityRule
Gets whether the "feasibility_rule" field is set.
void ClearSmallPivotThreshold()
Clears the value of the "small_pivot_threshold" field.
void ClearDegenerateMinistepFactor()
Clears the value of the "degenerate_ministep_factor" field.
void ClearLogSearchProgress()
Clears the value of the "log_search_progress" field.
double RefactorizationThreshold
We estimate the factorization accuracy of B during each pivot by using the fact that we can compute t...
bool HasNumOmpThreads
Gets whether the "num_omp_threads" field is set.
bool HasDegenerateMinistepFactor
Gets whether the "degenerate_ministep_factor" field is set.
bool DynamicallyAdjustRefactorizationPeriod
If this is true, then basis_refactorization_period becomes a lower bound on the number of iterations ...
bool HasDevexWeightsResetPeriod
Gets whether the "devex_weights_reset_period" field is set.
bool HasPushToVertex
Gets whether the "push_to_vertex" field is set.
double MarkowitzSingularityThreshold
If a pivot magnitude is smaller than this during the Markowitz LU factorization, then the matrix is a...
double MaxTimeInSeconds
Maximum time allowed in seconds to solve a problem.
void ClearFeasibilityRule()
Clears the value of the "feasibility_rule" field.
void ClearDynamicallyAdjustRefactorizationPeriod()
Clears the value of the "dynamically_adjust_refactorization_period" field.
static pbr::MessageDescriptor Descriptor
const int ExploitSingletonColumnInInitialBasisFieldNumber
Field number for the "exploit_singleton_column_in_initial_basis" field.
bool UseImpliedFreePreprocessor
If presolve runs, include the pass that detects implied free variables.
bool HasDualSmallPivotThreshold
Gets whether the "dual_small_pivot_threshold" field is set.
const int DropToleranceFieldNumber
Field number for the "drop_tolerance" field.
bool HasPreprocessorZeroTolerance
Gets whether the "preprocessor_zero_tolerance" field is set.
void ClearHarrisToleranceRatio()
Clears the value of the "harris_tolerance_ratio" field.
void ClearSolutionFeasibilityTolerance()
Clears the value of the "solution_feasibility_tolerance" field.
const int UsePreprocessingFieldNumber
Field number for the "use_preprocessing" field.
double RecomputeReducedCostsThreshold
We estimate the accuracy of the iteratively computed reduced costs. If it falls below this threshold,...
bool HasDynamicallyAdjustRefactorizationPeriod
Gets whether the "dynamically_adjust_refactorization_period" field is set.
double HarrisToleranceRatio
This impacts the ratio test and indicates by how much we allow a basic variable value that we move to...
double MinimumAcceptablePivot
We never follow a basis change with a pivot under this threshold.
bool HasOptimizationRule
Gets whether the "optimization_rule" field is set.
const int PreprocessorZeroToleranceFieldNumber
Field number for the "preprocessor_zero_tolerance" field.
bool PerturbCostsInDualSimplex
When this is true, then the costs are randomly perturbed before the dual simplex is even started....
void ClearLogToStdout()
Clears the value of the "log_to_stdout" field.
bool HasCrossoverBoundSnappingDistance
Gets whether the "crossover_bound_snapping_distance" field is set.
bool HasMaxTimeInSeconds
Gets whether the "max_time_in_seconds" field is set.
void ClearDropTolerance()
Clears the value of the "drop_tolerance" field.
bool HasDualizerThreshold
Gets whether the "dualizer_threshold" field is set.
bool PushToVertex
If the optimization phases finishes with super-basic variables (i.e., variables that either 1) have b...
void ClearBasisRefactorizationPeriod()
Clears the value of the "basis_refactorization_period" field.
const int UseScalingFieldNumber
Field number for the "use_scaling" field.
const int RefactorizationThresholdFieldNumber
Field number for the "refactorization_threshold" field.
const int UseTransposedMatrixFieldNumber
Field number for the "use_transposed_matrix" field.
bool HasMaxNumberOfReoptimizations
Gets whether the "max_number_of_reoptimizations" field is set.
bool HasAllowSimplexAlgorithmChange
Gets whether the "allow_simplex_algorithm_change" field is set.
bool HasRandomSeed
Gets whether the "random_seed" field is set.
const int MaxNumberOfIterationsFieldNumber
Field number for the "max_number_of_iterations" field.
void ClearSolveDualProblem()
Clears the value of the "solve_dual_problem" field.
void ClearRecomputeReducedCostsThreshold()
Clears the value of the "recompute_reduced_costs_threshold" field.
const int RatioTestZeroThresholdFieldNumber
Field number for the "ratio_test_zero_threshold" field.
double DropTolerance
In order to increase the sparsity of the manipulated vectors, floating point values with a magnitude ...
bool HasMaxNumberOfIterations
Gets whether the "max_number_of_iterations" field is set.
bool HasUseAbslRandom
Gets whether the "use_absl_random" field is set.
void ClearUseAbslRandom()
Clears the value of the "use_absl_random" field.
const int MarkowitzZlatevParameterFieldNumber
Field number for the "markowitz_zlatev_parameter" field.
const int RecomputeEdgesNormThresholdFieldNumber
Field number for the "recompute_edges_norm_threshold" field.
bool HasInitialConditionNumberThreshold
Gets whether the "initial_condition_number_threshold" field is set.
const int MarkowitzSingularityThresholdFieldNumber
Field number for the "markowitz_singularity_threshold" field.
bool HasUseDedicatedDualFeasibilityAlgorithm
Gets whether the "use_dedicated_dual_feasibility_algorithm" field is set.
double RelativeCostPerturbation
The magnitude of the cost perturbation is given by RandomIn(1.0, 2.0) * ( relative_cost_perturbation ...
const int DegenerateMinistepFactorFieldNumber
Field number for the "degenerate_ministep_factor" field.
const int MinimumAcceptablePivotFieldNumber
Field number for the "minimum_acceptable_pivot" field.
double DualFeasibilityTolerance
Variables whose reduced costs have an absolute value smaller than this tolerance are not considered a...
const int UseDualSimplexFieldNumber
Field number for the "use_dual_simplex" field.
void ClearNumOmpThreads()
Clears the value of the "num_omp_threads" field.
void ClearUseDedicatedDualFeasibilityAlgorithm()
Clears the value of the "use_dedicated_dual_feasibility_algorithm" field.
double MaxDeterministicTime
Maximum deterministic time allowed to solve a problem. The deterministic time is more or less correla...
bool HasRecomputeReducedCostsThreshold
Gets whether the "recompute_reduced_costs_threshold" field is set.
void ClearRecomputeEdgesNormThreshold()
Clears the value of the "recompute_edges_norm_threshold" field.
void ClearDualFeasibilityTolerance()
Clears the value of the "dual_feasibility_tolerance" field.
bool HasRelativeMaxCostPerturbation
Gets whether the "relative_max_cost_perturbation" field is set.
int NumOmpThreads
Number of threads in the OMP parallel sections. If left to 1, the code will not create any OMP thread...
const int SmallPivotThresholdFieldNumber
Field number for the "small_pivot_threshold" field.
const int ScalingMethodFieldNumber
Field number for the "scaling_method" field.
double RatioTestZeroThreshold
During the primal simplex (resp. dual simplex), the coefficients of the direction (resp....
bool ProvideStrongOptimalGuarantee
If true, then when the solver returns a solution with an OPTIMAL status, we can guarantee that:
bool HasRefactorizationThreshold
Gets whether the "refactorization_threshold" field is set.
const int InitializeDevexWithColumnNormsFieldNumber
Field number for the "initialize_devex_with_column_norms" field.
bool ExploitSingletonColumnInInitialBasis
Whether or not we exploit the singleton columns already present in the problem when we create the ini...
override bool Equals(object other)
GlopParameters(GlopParameters other)
const int BasisRefactorizationPeriodFieldNumber
Field number for the "basis_refactorization_period" field.
const int DropMagnitudeFieldNumber
Field number for the "drop_magnitude" field.
int MarkowitzZlatevParameter
How many columns do we look at in the Markowitz pivoting rule to find a good pivot....
bool HasMarkowitzZlatevParameter
Gets whether the "markowitz_zlatev_parameter" field is set.
const int SolveDualProblemFieldNumber
Field number for the "solve_dual_problem" field.
bool HasUseDualSimplex
Gets whether the "use_dual_simplex" field is set.
int BasisRefactorizationPeriod
Number of iterations between two basis refactorizations. Note that various conditions in the algorith...
const int DualPricePrioritizeNormFieldNumber
Field number for the "dual_price_prioritize_norm" field.
void ClearRelativeCostPerturbation()
Clears the value of the "relative_cost_perturbation" field.
bool HasLuFactorizationPivotThreshold
Gets whether the "lu_factorization_pivot_threshold" field is set.
double SolutionFeasibilityTolerance
When the problem status is OPTIMAL, we check the optimality using this relative tolerance and change ...
void ClearDualizerThreshold()
Clears the value of the "dualizer_threshold" field.
void ClearPerturbCostsInDualSimplex()
Clears the value of the "perturb_costs_in_dual_simplex" field.
const int HarrisToleranceRatioFieldNumber
Field number for the "harris_tolerance_ratio" field.
global::Google.OrTools.Glop.GlopParameters.Types.PricingRule FeasibilityRule
PricingRule to use during the feasibility phase.
double LuFactorizationPivotThreshold
Threshold for LU-factorization: for stability reasons, the magnitude of the chosen pivot at a given s...
const int ObjectiveLowerLimitFieldNumber
Field number for the "objective_lower_limit" field.
bool HasRelativeCostPerturbation
Gets whether the "relative_cost_perturbation" field is set.
void ClearUseTransposedMatrix()
Clears the value of the "use_transposed_matrix" field.
bool LogToStdout
If true, logs will be displayed to stdout instead of using Google log info.
bool HasBasisRefactorizationPeriod
Gets whether the "basis_refactorization_period" field is set.
const int SolutionFeasibilityToleranceFieldNumber
Field number for the "solution_feasibility_tolerance" field.
bool HasRecomputeEdgesNormThreshold
Gets whether the "recompute_edges_norm_threshold" field is set.
const int RecomputeReducedCostsThresholdFieldNumber
Field number for the "recompute_reduced_costs_threshold" field.
const int CostScalingFieldNumber
Field number for the "cost_scaling" field.
void ClearRelativeMaxCostPerturbation()
Clears the value of the "relative_max_cost_perturbation" field.
bool UsePreprocessing
Whether or not we use advanced preprocessing techniques.
double PrimalFeasibilityTolerance
This tolerance indicates by how much we allow the variable values to go out of bounds and still consi...
void ClearRatioTestZeroThreshold()
Clears the value of the "ratio_test_zero_threshold" field.
static pb::MessageParser< GlopParameters > Parser
double ObjectiveLowerLimit
The solver will stop as soon as it has proven that the objective is smaller than objective_lower_limi...
const int MaxValidMagnitudeFieldNumber
Field number for the "max_valid_magnitude" field.
bool HasPerturbCostsInDualSimplex
Gets whether the "perturb_costs_in_dual_simplex" field is set.
bool HasScalingMethod
Gets whether the "scaling_method" field is set.
double MaxNumberOfReoptimizations
When the solution of phase II is imprecise, we re-run the phase II with the opposite algorithm from t...
double CrossoverBoundSnappingDistance
If the starting basis contains FREE variable with bounds, we will move any such variable to their clo...
global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm ScalingMethod
int RandomSeed
At the beginning of each solve, the random number generator used in some part of the solver is reinit...
bool HasInitializeDevexWithColumnNorms
Gets whether the "initialize_devex_with_column_norms" field is set.
const int DualSmallPivotThresholdFieldNumber
Field number for the "dual_small_pivot_threshold" field.
int DevexWeightsResetPeriod
Devex weights will be reset to 1.0 after that number of updates.
void ClearMinimumAcceptablePivot()
Clears the value of the "minimum_acceptable_pivot" field.
bool AllowSimplexAlgorithmChange
During incremental solve, let the solver decide if it use the primal or dual simplex algorithm depend...
long MaxNumberOfIterations
Maximum number of simplex iterations to solve a problem. A value of -1 means no limit.
bool HasProvideStrongOptimalGuarantee
Gets whether the "provide_strong_optimal_guarantee" field is set.
bool HasSolveDualProblem
Gets whether the "solve_dual_problem" field is set.
bool HasChangeStatusToImprecise
Gets whether the "change_status_to_imprecise" field is set.
bool HasMarkowitzSingularityThreshold
Gets whether the "markowitz_singularity_threshold" field is set.
bool HasUseMiddleProductFormUpdate
Gets whether the "use_middle_product_form_update" field is set.
const int AllowSimplexAlgorithmChangeFieldNumber
Field number for the "allow_simplex_algorithm_change" field.
global::Google.OrTools.Glop.GlopParameters.Types.PricingRule OptimizationRule
PricingRule to use during the optimization phase.
bool HasUseImpliedFreePreprocessor
Gets whether the "use_implied_free_preprocessor" field is set.
void ClearUseScaling()
Clears the value of the "use_scaling" field.
const int FeasibilityRuleFieldNumber
Field number for the "feasibility_rule" field.
const int OptimizationRuleFieldNumber
Field number for the "optimization_rule" field.
void ClearInitialBasis()
Clears the value of the "initial_basis" field.
bool DualPricePrioritizeNorm
On some problem like stp3d or pds-100 this makes a huge difference in speed and number of iterations ...
const int DualizerThresholdFieldNumber
Field number for the "dualizer_threshold" field.
void ClearOptimizationRule()
Clears the value of the "optimization_rule" field.
bool HasSolutionFeasibilityTolerance
Gets whether the "solution_feasibility_tolerance" field is set.
bool LogSearchProgress
If true, logs the progress of a solve to LOG(INFO). Note that the same messages can also be turned on...
const int DevexWeightsResetPeriodFieldNumber
Field number for the "devex_weights_reset_period" field.
bool UseAbslRandom
Whether to use absl.BitGen instead of MTRandom.
Holder for reflection information generated from ortools/glop/parameters.proto.
static pbr::FileDescriptor Descriptor
File descriptor for ortools/glop/parameters.proto.