Google OR-Tools v9.11
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;
12namespace Google.OrTools.Glop {
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 "ZXNlYXJjaC5nbG9wItAYCg5HbG9wUGFyYW1ldGVycxJgCg5zY2FsaW5nX21l",
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 "ZmFjdG9yGCogASgBOgQwLjAxEhYKC3JhbmRvbV9zZWVkGCsgASgFOgExEhoK",
77 "D251bV9vbXBfdGhyZWFkcxgsIAEoBToBMRIsCh1wZXJ0dXJiX2Nvc3RzX2lu",
78 "X2R1YWxfc2ltcGxleBg1IAEoCDoFZmFsc2USNgoodXNlX2RlZGljYXRlZF9k",
79 "dWFsX2ZlYXNpYmlsaXR5X2FsZ29yaXRobRg+IAEoCDoEdHJ1ZRIpChpyZWxh",
80 "dGl2ZV9jb3N0X3BlcnR1cmJhdGlvbhg2IAEoAToFMWUtMDUSLQoecmVsYXRp",
81 "dmVfbWF4X2Nvc3RfcGVydHVyYmF0aW9uGDcgASgBOgUxZS0wNxIxCiJpbml0",
82 "aWFsX2NvbmRpdGlvbl9udW1iZXJfdGhyZXNob2xkGDsgASgBOgUxZSs1MBIi",
83 "ChNsb2dfc2VhcmNoX3Byb2dyZXNzGD0gASgIOgVmYWxzZRIbCg1sb2dfdG9f",
84 "c3Rkb3V0GEIgASgIOgR0cnVlEi4KIWNyb3Nzb3Zlcl9ib3VuZF9zbmFwcGlu",
85 "Z19kaXN0YW5jZRhAIAEoAToDaW5mEhwKDnB1c2hfdG9fdmVydGV4GEEgASgI",
86 "OgR0cnVlEisKHXVzZV9pbXBsaWVkX2ZyZWVfcHJlcHJvY2Vzc29yGEMgASgI",
87 "OgR0cnVlEiIKE21heF92YWxpZF9tYWduaXR1ZGUYRiABKAE6BTFlKzMwEh0K",
88 "DmRyb3BfbWFnbml0dWRlGEcgASgBOgUxZS0zMBIpChpkdWFsX3ByaWNlX3By",
89 "aW9yaXRpemVfbm9ybRhFIAEoCDoFZmFsc2UiRgoQU2NhbGluZ0FsZ29yaXRo",
90 "bRILCgdERUZBVUxUEAASEQoNRVFVSUxJQlJBVElPThABEhIKDkxJTkVBUl9Q",
91 "Uk9HUkFNEAIiRAoOU29sdmVyQmVoYXZpb3ISDQoJQUxXQVlTX0RPEAASDAoI",
92 "TkVWRVJfRE8QARIVChFMRVRfU09MVkVSX0RFQ0lERRACIjgKC1ByaWNpbmdS",
93 "dWxlEgsKB0RBTlRaSUcQABIRCg1TVEVFUEVTVF9FREdFEAESCQoFREVWRVgQ",
94 "AiJHChVJbml0aWFsQmFzaXNIZXVyaXN0aWMSCAoETk9ORRAAEgkKBUJJWEJZ",
95 "EAESDgoKVFJJQU5HVUxBUhACEgkKBU1BUk9TEAMieQoUQ29zdFNjYWxpbmdB",
96 "bGdvcml0aG0SEwoPTk9fQ09TVF9TQ0FMSU5HEAASHAoYQ09OVEFJTl9PTkVf",
97 "Q09TVF9TQ0FMSU5HEAESFQoRTUVBTl9DT1NUX1NDQUxJTkcQAhIXChNNRURJ",
98 "QU5fQ09TVF9TQ0FMSU5HEANCMQoXY29tLmdvb2dsZS5vcnRvb2xzLmdsb3BQ",
99 "AaoCE0dvb2dsZS5PclRvb2xzLkdsb3A="));
100 descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
101 new pbr::FileDescriptor[] { },
102 new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
103 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", "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)
104 }));
105 }
106 #endregion
107
108 }
109 #region Messages
113 [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")]
114 public sealed partial class GlopParameters : pb::IMessage<GlopParameters>
115 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
116 , pb::IBufferMessage
117 #endif
118 {
119 private static readonly pb::MessageParser<GlopParameters> _parser = new pb::MessageParser<GlopParameters>(() => new GlopParameters());
120 private pb::UnknownFieldSet _unknownFields;
121 private int _hasBits0;
122 private int _hasBits1;
123 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
124 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
125 public static pb::MessageParser<GlopParameters> Parser { get { return _parser; } }
126
127 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
128 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
129 public static pbr::MessageDescriptor Descriptor {
130 get { return global::Google.OrTools.Glop.ParametersReflection.Descriptor.MessageTypes[0]; }
131 }
132
133 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
134 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
135 pbr::MessageDescriptor pb::IMessage.Descriptor {
136 get { return Descriptor; }
137 }
138
139 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
140 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
141 public GlopParameters() {
142 OnConstruction();
143 }
144
145 partial void OnConstruction();
146
147 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
148 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
149 public GlopParameters(GlopParameters other) : this() {
150 _hasBits0 = other._hasBits0;
151 _hasBits1 = other._hasBits1;
152 scalingMethod_ = other.scalingMethod_;
153 feasibilityRule_ = other.feasibilityRule_;
154 optimizationRule_ = other.optimizationRule_;
155 refactorizationThreshold_ = other.refactorizationThreshold_;
156 recomputeReducedCostsThreshold_ = other.recomputeReducedCostsThreshold_;
157 recomputeEdgesNormThreshold_ = other.recomputeEdgesNormThreshold_;
158 primalFeasibilityTolerance_ = other.primalFeasibilityTolerance_;
159 dualFeasibilityTolerance_ = other.dualFeasibilityTolerance_;
160 ratioTestZeroThreshold_ = other.ratioTestZeroThreshold_;
161 harrisToleranceRatio_ = other.harrisToleranceRatio_;
162 smallPivotThreshold_ = other.smallPivotThreshold_;
163 minimumAcceptablePivot_ = other.minimumAcceptablePivot_;
164 dropTolerance_ = other.dropTolerance_;
165 useScaling_ = other.useScaling_;
166 costScaling_ = other.costScaling_;
167 initialBasis_ = other.initialBasis_;
168 useTransposedMatrix_ = other.useTransposedMatrix_;
169 basisRefactorizationPeriod_ = other.basisRefactorizationPeriod_;
170 dynamicallyAdjustRefactorizationPeriod_ = other.dynamicallyAdjustRefactorizationPeriod_;
171 solveDualProblem_ = other.solveDualProblem_;
172 dualizerThreshold_ = other.dualizerThreshold_;
173 solutionFeasibilityTolerance_ = other.solutionFeasibilityTolerance_;
174 provideStrongOptimalGuarantee_ = other.provideStrongOptimalGuarantee_;
175 changeStatusToImprecise_ = other.changeStatusToImprecise_;
176 maxNumberOfReoptimizations_ = other.maxNumberOfReoptimizations_;
177 luFactorizationPivotThreshold_ = other.luFactorizationPivotThreshold_;
178 maxTimeInSeconds_ = other.maxTimeInSeconds_;
179 maxDeterministicTime_ = other.maxDeterministicTime_;
180 maxNumberOfIterations_ = other.maxNumberOfIterations_;
181 markowitzZlatevParameter_ = other.markowitzZlatevParameter_;
182 markowitzSingularityThreshold_ = other.markowitzSingularityThreshold_;
183 useDualSimplex_ = other.useDualSimplex_;
184 allowSimplexAlgorithmChange_ = other.allowSimplexAlgorithmChange_;
185 devexWeightsResetPeriod_ = other.devexWeightsResetPeriod_;
186 usePreprocessing_ = other.usePreprocessing_;
187 useMiddleProductFormUpdate_ = other.useMiddleProductFormUpdate_;
188 initializeDevexWithColumnNorms_ = other.initializeDevexWithColumnNorms_;
189 exploitSingletonColumnInInitialBasis_ = other.exploitSingletonColumnInInitialBasis_;
190 dualSmallPivotThreshold_ = other.dualSmallPivotThreshold_;
191 preprocessorZeroTolerance_ = other.preprocessorZeroTolerance_;
192 objectiveLowerLimit_ = other.objectiveLowerLimit_;
193 objectiveUpperLimit_ = other.objectiveUpperLimit_;
194 degenerateMinistepFactor_ = other.degenerateMinistepFactor_;
195 randomSeed_ = other.randomSeed_;
196 numOmpThreads_ = other.numOmpThreads_;
197 perturbCostsInDualSimplex_ = other.perturbCostsInDualSimplex_;
198 useDedicatedDualFeasibilityAlgorithm_ = other.useDedicatedDualFeasibilityAlgorithm_;
199 relativeCostPerturbation_ = other.relativeCostPerturbation_;
200 relativeMaxCostPerturbation_ = other.relativeMaxCostPerturbation_;
201 initialConditionNumberThreshold_ = other.initialConditionNumberThreshold_;
202 logSearchProgress_ = other.logSearchProgress_;
203 logToStdout_ = other.logToStdout_;
204 crossoverBoundSnappingDistance_ = other.crossoverBoundSnappingDistance_;
205 pushToVertex_ = other.pushToVertex_;
206 useImpliedFreePreprocessor_ = other.useImpliedFreePreprocessor_;
207 maxValidMagnitude_ = other.maxValidMagnitude_;
208 dropMagnitude_ = other.dropMagnitude_;
209 dualPricePrioritizeNorm_ = other.dualPricePrioritizeNorm_;
210 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
211 }
212
213 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
214 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
215 public GlopParameters Clone() {
216 return new GlopParameters(this);
217 }
218
220 public const int ScalingMethodFieldNumber = 57;
221 private readonly static global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm ScalingMethodDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm.Equilibration;
222
223 private global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm scalingMethod_;
224 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
225 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
226 public global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm ScalingMethod {
227 get { if ((_hasBits1 & 4096) != 0) { return scalingMethod_; } else { return ScalingMethodDefaultValue; } }
228 set {
229 _hasBits1 |= 4096;
230 scalingMethod_ = value;
231 }
232 }
234 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
235 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
236 public bool HasScalingMethod {
237 get { return (_hasBits1 & 4096) != 0; }
238 }
240 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
241 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
242 public void ClearScalingMethod() {
243 _hasBits1 &= ~4096;
244 }
245
247 public const int FeasibilityRuleFieldNumber = 1;
248 private readonly static global::Google.OrTools.Glop.GlopParameters.Types.PricingRule FeasibilityRuleDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.PricingRule.SteepestEdge;
249
250 private global::Google.OrTools.Glop.GlopParameters.Types.PricingRule feasibilityRule_;
254 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
255 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
256 public global::Google.OrTools.Glop.GlopParameters.Types.PricingRule FeasibilityRule {
257 get { if ((_hasBits0 & 1) != 0) { return feasibilityRule_; } else { return FeasibilityRuleDefaultValue; } }
258 set {
259 _hasBits0 |= 1;
260 feasibilityRule_ = value;
261 }
262 }
264 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
265 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
266 public bool HasFeasibilityRule {
267 get { return (_hasBits0 & 1) != 0; }
268 }
270 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
271 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
272 public void ClearFeasibilityRule() {
273 _hasBits0 &= ~1;
274 }
275
277 public const int OptimizationRuleFieldNumber = 2;
278 private readonly static global::Google.OrTools.Glop.GlopParameters.Types.PricingRule OptimizationRuleDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.PricingRule.SteepestEdge;
279
280 private global::Google.OrTools.Glop.GlopParameters.Types.PricingRule optimizationRule_;
284 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
285 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
286 public global::Google.OrTools.Glop.GlopParameters.Types.PricingRule OptimizationRule {
287 get { if ((_hasBits0 & 2) != 0) { return optimizationRule_; } else { return OptimizationRuleDefaultValue; } }
288 set {
289 _hasBits0 |= 2;
290 optimizationRule_ = value;
291 }
292 }
294 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
295 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
296 public bool HasOptimizationRule {
297 get { return (_hasBits0 & 2) != 0; }
298 }
300 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
301 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
302 public void ClearOptimizationRule() {
303 _hasBits0 &= ~2;
304 }
305
307 public const int RefactorizationThresholdFieldNumber = 6;
308 private readonly static double RefactorizationThresholdDefaultValue = 1e-09D;
309
310 private double refactorizationThreshold_;
319 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
320 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
321 public double RefactorizationThreshold {
322 get { if ((_hasBits0 & 4) != 0) { return refactorizationThreshold_; } else { return RefactorizationThresholdDefaultValue; } }
323 set {
324 _hasBits0 |= 4;
325 refactorizationThreshold_ = value;
326 }
327 }
329 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
330 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
331 public bool HasRefactorizationThreshold {
332 get { return (_hasBits0 & 4) != 0; }
333 }
335 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
336 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
337 public void ClearRefactorizationThreshold() {
338 _hasBits0 &= ~4;
339 }
340
342 public const int RecomputeReducedCostsThresholdFieldNumber = 8;
343 private readonly static double RecomputeReducedCostsThresholdDefaultValue = 1e-08D;
344
345 private double recomputeReducedCostsThreshold_;
353 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
354 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
355 public double RecomputeReducedCostsThreshold {
356 get { if ((_hasBits0 & 8) != 0) { return recomputeReducedCostsThreshold_; } else { return RecomputeReducedCostsThresholdDefaultValue; } }
357 set {
358 _hasBits0 |= 8;
359 recomputeReducedCostsThreshold_ = value;
360 }
361 }
363 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
364 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
365 public bool HasRecomputeReducedCostsThreshold {
366 get { return (_hasBits0 & 8) != 0; }
367 }
369 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
370 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
371 public void ClearRecomputeReducedCostsThreshold() {
372 _hasBits0 &= ~8;
373 }
374
376 public const int RecomputeEdgesNormThresholdFieldNumber = 9;
377 private readonly static double RecomputeEdgesNormThresholdDefaultValue = 100D;
378
379 private double recomputeEdgesNormThreshold_;
387 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
388 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
389 public double RecomputeEdgesNormThreshold {
390 get { if ((_hasBits0 & 16) != 0) { return recomputeEdgesNormThreshold_; } else { return RecomputeEdgesNormThresholdDefaultValue; } }
391 set {
392 _hasBits0 |= 16;
393 recomputeEdgesNormThreshold_ = value;
394 }
395 }
397 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
398 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
399 public bool HasRecomputeEdgesNormThreshold {
400 get { return (_hasBits0 & 16) != 0; }
401 }
403 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
404 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
405 public void ClearRecomputeEdgesNormThreshold() {
406 _hasBits0 &= ~16;
407 }
408
410 public const int PrimalFeasibilityToleranceFieldNumber = 10;
411 private readonly static double PrimalFeasibilityToleranceDefaultValue = 1e-08D;
412
413 private double primalFeasibilityTolerance_;
423 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
424 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
425 public double PrimalFeasibilityTolerance {
426 get { if ((_hasBits0 & 32) != 0) { return primalFeasibilityTolerance_; } else { return PrimalFeasibilityToleranceDefaultValue; } }
427 set {
428 _hasBits0 |= 32;
429 primalFeasibilityTolerance_ = value;
430 }
431 }
433 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
434 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
435 public bool HasPrimalFeasibilityTolerance {
436 get { return (_hasBits0 & 32) != 0; }
437 }
439 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
440 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
441 public void ClearPrimalFeasibilityTolerance() {
442 _hasBits0 &= ~32;
443 }
444
446 public const int DualFeasibilityToleranceFieldNumber = 11;
447 private readonly static double DualFeasibilityToleranceDefaultValue = 1e-08D;
448
449 private double dualFeasibilityTolerance_;
462 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
463 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
464 public double DualFeasibilityTolerance {
465 get { if ((_hasBits0 & 64) != 0) { return dualFeasibilityTolerance_; } else { return DualFeasibilityToleranceDefaultValue; } }
466 set {
467 _hasBits0 |= 64;
468 dualFeasibilityTolerance_ = value;
469 }
470 }
472 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
473 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
474 public bool HasDualFeasibilityTolerance {
475 get { return (_hasBits0 & 64) != 0; }
476 }
478 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
479 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
480 public void ClearDualFeasibilityTolerance() {
481 _hasBits0 &= ~64;
482 }
483
485 public const int RatioTestZeroThresholdFieldNumber = 12;
486 private readonly static double RatioTestZeroThresholdDefaultValue = 1e-09D;
487
488 private double ratioTestZeroThreshold_;
498 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
499 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
500 public double RatioTestZeroThreshold {
501 get { if ((_hasBits0 & 128) != 0) { return ratioTestZeroThreshold_; } else { return RatioTestZeroThresholdDefaultValue; } }
502 set {
503 _hasBits0 |= 128;
504 ratioTestZeroThreshold_ = value;
505 }
506 }
508 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
509 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
510 public bool HasRatioTestZeroThreshold {
511 get { return (_hasBits0 & 128) != 0; }
512 }
514 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
515 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
516 public void ClearRatioTestZeroThreshold() {
517 _hasBits0 &= ~128;
518 }
519
521 public const int HarrisToleranceRatioFieldNumber = 13;
522 private readonly static double HarrisToleranceRatioDefaultValue = 0.5D;
523
524 private double harrisToleranceRatio_;
538 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
539 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
540 public double HarrisToleranceRatio {
541 get { if ((_hasBits0 & 256) != 0) { return harrisToleranceRatio_; } else { return HarrisToleranceRatioDefaultValue; } }
542 set {
543 _hasBits0 |= 256;
544 harrisToleranceRatio_ = value;
545 }
546 }
548 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
549 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
550 public bool HasHarrisToleranceRatio {
551 get { return (_hasBits0 & 256) != 0; }
552 }
554 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
555 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
556 public void ClearHarrisToleranceRatio() {
557 _hasBits0 &= ~256;
558 }
559
561 public const int SmallPivotThresholdFieldNumber = 14;
562 private readonly static double SmallPivotThresholdDefaultValue = 1e-06D;
563
564 private double smallPivotThreshold_;
571 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
572 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
573 public double SmallPivotThreshold {
574 get { if ((_hasBits0 & 512) != 0) { return smallPivotThreshold_; } else { return SmallPivotThresholdDefaultValue; } }
575 set {
576 _hasBits0 |= 512;
577 smallPivotThreshold_ = value;
578 }
579 }
581 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
582 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
583 public bool HasSmallPivotThreshold {
584 get { return (_hasBits0 & 512) != 0; }
585 }
587 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
588 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
589 public void ClearSmallPivotThreshold() {
590 _hasBits0 &= ~512;
591 }
592
594 public const int MinimumAcceptablePivotFieldNumber = 15;
595 private readonly static double MinimumAcceptablePivotDefaultValue = 1e-06D;
596
597 private double minimumAcceptablePivot_;
601 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
602 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
603 public double MinimumAcceptablePivot {
604 get { if ((_hasBits0 & 1024) != 0) { return minimumAcceptablePivot_; } else { return MinimumAcceptablePivotDefaultValue; } }
605 set {
606 _hasBits0 |= 1024;
607 minimumAcceptablePivot_ = value;
608 }
609 }
611 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
612 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
613 public bool HasMinimumAcceptablePivot {
614 get { return (_hasBits0 & 1024) != 0; }
615 }
617 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
618 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
619 public void ClearMinimumAcceptablePivot() {
620 _hasBits0 &= ~1024;
621 }
622
624 public const int DropToleranceFieldNumber = 52;
625 private readonly static double DropToleranceDefaultValue = 1e-14D;
626
627 private double dropTolerance_;
633 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
634 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
635 public double DropTolerance {
636 get { if ((_hasBits1 & 128) != 0) { return dropTolerance_; } else { return DropToleranceDefaultValue; } }
637 set {
638 _hasBits1 |= 128;
639 dropTolerance_ = value;
640 }
641 }
643 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
644 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
645 public bool HasDropTolerance {
646 get { return (_hasBits1 & 128) != 0; }
647 }
649 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
650 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
651 public void ClearDropTolerance() {
652 _hasBits1 &= ~128;
653 }
654
656 public const int UseScalingFieldNumber = 16;
657 private readonly static bool UseScalingDefaultValue = true;
658
659 private bool useScaling_;
664 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
665 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
666 public bool UseScaling {
667 get { if ((_hasBits0 & 2048) != 0) { return useScaling_; } else { return UseScalingDefaultValue; } }
668 set {
669 _hasBits0 |= 2048;
670 useScaling_ = value;
671 }
672 }
674 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
675 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
676 public bool HasUseScaling {
677 get { return (_hasBits0 & 2048) != 0; }
678 }
680 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
681 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
682 public void ClearUseScaling() {
683 _hasBits0 &= ~2048;
684 }
685
687 public const int CostScalingFieldNumber = 60;
688 private readonly static global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm CostScalingDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm.ContainOneCostScaling;
689
690 private global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm costScaling_;
691 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
692 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
693 public global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm CostScaling {
694 get { if ((_hasBits1 & 32768) != 0) { return costScaling_; } else { return CostScalingDefaultValue; } }
695 set {
696 _hasBits1 |= 32768;
697 costScaling_ = value;
698 }
699 }
701 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
702 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
703 public bool HasCostScaling {
704 get { return (_hasBits1 & 32768) != 0; }
705 }
707 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
708 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
709 public void ClearCostScaling() {
710 _hasBits1 &= ~32768;
711 }
712
714 public const int InitialBasisFieldNumber = 17;
715 private readonly static global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic InitialBasisDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic.Triangular;
716
717 private global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic initialBasis_;
722 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
723 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
724 public global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic InitialBasis {
725 get { if ((_hasBits0 & 4096) != 0) { return initialBasis_; } else { return InitialBasisDefaultValue; } }
726 set {
727 _hasBits0 |= 4096;
728 initialBasis_ = value;
729 }
730 }
732 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
733 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
734 public bool HasInitialBasis {
735 get { return (_hasBits0 & 4096) != 0; }
736 }
738 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
739 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
740 public void ClearInitialBasis() {
741 _hasBits0 &= ~4096;
742 }
743
745 public const int UseTransposedMatrixFieldNumber = 18;
746 private readonly static bool UseTransposedMatrixDefaultValue = true;
747
748 private bool useTransposedMatrix_;
754 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
755 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
756 public bool UseTransposedMatrix {
757 get { if ((_hasBits0 & 8192) != 0) { return useTransposedMatrix_; } else { return UseTransposedMatrixDefaultValue; } }
758 set {
759 _hasBits0 |= 8192;
760 useTransposedMatrix_ = value;
761 }
762 }
764 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
765 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
766 public bool HasUseTransposedMatrix {
767 get { return (_hasBits0 & 8192) != 0; }
768 }
770 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
771 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
772 public void ClearUseTransposedMatrix() {
773 _hasBits0 &= ~8192;
774 }
775
777 public const int BasisRefactorizationPeriodFieldNumber = 19;
778 private readonly static int BasisRefactorizationPeriodDefaultValue = 64;
779
780 private int basisRefactorizationPeriod_;
786 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
787 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
788 public int BasisRefactorizationPeriod {
789 get { if ((_hasBits0 & 16384) != 0) { return basisRefactorizationPeriod_; } else { return BasisRefactorizationPeriodDefaultValue; } }
790 set {
791 _hasBits0 |= 16384;
792 basisRefactorizationPeriod_ = value;
793 }
794 }
796 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
797 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
798 public bool HasBasisRefactorizationPeriod {
799 get { return (_hasBits0 & 16384) != 0; }
800 }
802 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
803 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
804 public void ClearBasisRefactorizationPeriod() {
805 _hasBits0 &= ~16384;
806 }
807
809 public const int DynamicallyAdjustRefactorizationPeriodFieldNumber = 63;
810 private readonly static bool DynamicallyAdjustRefactorizationPeriodDefaultValue = true;
811
812 private bool dynamicallyAdjustRefactorizationPeriod_;
820 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
821 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
822 public bool DynamicallyAdjustRefactorizationPeriod {
823 get { if ((_hasBits1 & 262144) != 0) { return dynamicallyAdjustRefactorizationPeriod_; } else { return DynamicallyAdjustRefactorizationPeriodDefaultValue; } }
824 set {
825 _hasBits1 |= 262144;
826 dynamicallyAdjustRefactorizationPeriod_ = value;
827 }
828 }
830 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
831 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
832 public bool HasDynamicallyAdjustRefactorizationPeriod {
833 get { return (_hasBits1 & 262144) != 0; }
834 }
836 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
837 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
838 public void ClearDynamicallyAdjustRefactorizationPeriod() {
839 _hasBits1 &= ~262144;
840 }
841
843 public const int SolveDualProblemFieldNumber = 20;
844 private readonly static global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior SolveDualProblemDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior.LetSolverDecide;
845
846 private global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior solveDualProblem_;
852 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
853 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
854 public global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior SolveDualProblem {
855 get { if ((_hasBits0 & 32768) != 0) { return solveDualProblem_; } else { return SolveDualProblemDefaultValue; } }
856 set {
857 _hasBits0 |= 32768;
858 solveDualProblem_ = value;
859 }
860 }
862 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
863 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
864 public bool HasSolveDualProblem {
865 get { return (_hasBits0 & 32768) != 0; }
866 }
868 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
869 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
870 public void ClearSolveDualProblem() {
871 _hasBits0 &= ~32768;
872 }
873
875 public const int DualizerThresholdFieldNumber = 21;
876 private readonly static double DualizerThresholdDefaultValue = 1.5D;
877
878 private double dualizerThreshold_;
884 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
885 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
886 public double DualizerThreshold {
887 get { if ((_hasBits0 & 65536) != 0) { return dualizerThreshold_; } else { return DualizerThresholdDefaultValue; } }
888 set {
889 _hasBits0 |= 65536;
890 dualizerThreshold_ = value;
891 }
892 }
894 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
895 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
896 public bool HasDualizerThreshold {
897 get { return (_hasBits0 & 65536) != 0; }
898 }
900 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
901 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
902 public void ClearDualizerThreshold() {
903 _hasBits0 &= ~65536;
904 }
905
907 public const int SolutionFeasibilityToleranceFieldNumber = 22;
908 private readonly static double SolutionFeasibilityToleranceDefaultValue = 1e-06D;
909
910 private double solutionFeasibilityTolerance_;
921 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
922 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
923 public double SolutionFeasibilityTolerance {
924 get { if ((_hasBits0 & 131072) != 0) { return solutionFeasibilityTolerance_; } else { return SolutionFeasibilityToleranceDefaultValue; } }
925 set {
926 _hasBits0 |= 131072;
927 solutionFeasibilityTolerance_ = value;
928 }
929 }
931 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
932 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
933 public bool HasSolutionFeasibilityTolerance {
934 get { return (_hasBits0 & 131072) != 0; }
935 }
937 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
938 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
939 public void ClearSolutionFeasibilityTolerance() {
940 _hasBits0 &= ~131072;
941 }
942
944 public const int ProvideStrongOptimalGuaranteeFieldNumber = 24;
945 private readonly static bool ProvideStrongOptimalGuaranteeDefaultValue = true;
946
947 private bool provideStrongOptimalGuarantee_;
968 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
969 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
970 public bool ProvideStrongOptimalGuarantee {
971 get { if ((_hasBits0 & 262144) != 0) { return provideStrongOptimalGuarantee_; } else { return ProvideStrongOptimalGuaranteeDefaultValue; } }
972 set {
973 _hasBits0 |= 262144;
974 provideStrongOptimalGuarantee_ = value;
975 }
976 }
978 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
979 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
980 public bool HasProvideStrongOptimalGuarantee {
981 get { return (_hasBits0 & 262144) != 0; }
982 }
984 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
985 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
986 public void ClearProvideStrongOptimalGuarantee() {
987 _hasBits0 &= ~262144;
988 }
989
991 public const int ChangeStatusToImpreciseFieldNumber = 58;
992 private readonly static bool ChangeStatusToImpreciseDefaultValue = true;
993
994 private bool changeStatusToImprecise_;
999 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1000 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1001 public bool ChangeStatusToImprecise {
1002 get { if ((_hasBits1 & 8192) != 0) { return changeStatusToImprecise_; } else { return ChangeStatusToImpreciseDefaultValue; } }
1003 set {
1004 _hasBits1 |= 8192;
1005 changeStatusToImprecise_ = value;
1006 }
1007 }
1009 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1010 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1011 public bool HasChangeStatusToImprecise {
1012 get { return (_hasBits1 & 8192) != 0; }
1013 }
1015 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1016 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1017 public void ClearChangeStatusToImprecise() {
1018 _hasBits1 &= ~8192;
1019 }
1020
1022 public const int MaxNumberOfReoptimizationsFieldNumber = 56;
1023 private readonly static double MaxNumberOfReoptimizationsDefaultValue = 40D;
1024
1025 private double maxNumberOfReoptimizations_;
1032 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1033 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1034 public double MaxNumberOfReoptimizations {
1035 get { if ((_hasBits1 & 2048) != 0) { return maxNumberOfReoptimizations_; } else { return MaxNumberOfReoptimizationsDefaultValue; } }
1036 set {
1037 _hasBits1 |= 2048;
1038 maxNumberOfReoptimizations_ = value;
1039 }
1040 }
1042 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1043 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1044 public bool HasMaxNumberOfReoptimizations {
1045 get { return (_hasBits1 & 2048) != 0; }
1046 }
1048 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1049 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1050 public void ClearMaxNumberOfReoptimizations() {
1051 _hasBits1 &= ~2048;
1052 }
1053
1055 public const int LuFactorizationPivotThresholdFieldNumber = 25;
1056 private readonly static double LuFactorizationPivotThresholdDefaultValue = 0.01D;
1057
1058 private double luFactorizationPivotThreshold_;
1065 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1066 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1067 public double LuFactorizationPivotThreshold {
1068 get { if ((_hasBits0 & 524288) != 0) { return luFactorizationPivotThreshold_; } else { return LuFactorizationPivotThresholdDefaultValue; } }
1069 set {
1070 _hasBits0 |= 524288;
1071 luFactorizationPivotThreshold_ = value;
1072 }
1073 }
1075 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1076 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1077 public bool HasLuFactorizationPivotThreshold {
1078 get { return (_hasBits0 & 524288) != 0; }
1079 }
1081 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1082 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1083 public void ClearLuFactorizationPivotThreshold() {
1084 _hasBits0 &= ~524288;
1085 }
1086
1088 public const int MaxTimeInSecondsFieldNumber = 26;
1089 private readonly static double MaxTimeInSecondsDefaultValue = double.PositiveInfinity;
1090
1091 private double maxTimeInSeconds_;
1095 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1096 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1097 public double MaxTimeInSeconds {
1098 get { if ((_hasBits0 & 1048576) != 0) { return maxTimeInSeconds_; } else { return MaxTimeInSecondsDefaultValue; } }
1099 set {
1100 _hasBits0 |= 1048576;
1101 maxTimeInSeconds_ = value;
1102 }
1103 }
1105 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1106 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1107 public bool HasMaxTimeInSeconds {
1108 get { return (_hasBits0 & 1048576) != 0; }
1109 }
1111 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1112 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1113 public void ClearMaxTimeInSeconds() {
1114 _hasBits0 &= ~1048576;
1115 }
1116
1118 public const int MaxDeterministicTimeFieldNumber = 45;
1119 private readonly static double MaxDeterministicTimeDefaultValue = double.PositiveInfinity;
1120
1121 private double maxDeterministicTime_;
1129 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1130 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1131 public double MaxDeterministicTime {
1132 get { if ((_hasBits1 & 64) != 0) { return maxDeterministicTime_; } else { return MaxDeterministicTimeDefaultValue; } }
1133 set {
1134 _hasBits1 |= 64;
1135 maxDeterministicTime_ = value;
1136 }
1137 }
1139 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1140 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1141 public bool HasMaxDeterministicTime {
1142 get { return (_hasBits1 & 64) != 0; }
1143 }
1145 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1146 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1147 public void ClearMaxDeterministicTime() {
1148 _hasBits1 &= ~64;
1149 }
1150
1152 public const int MaxNumberOfIterationsFieldNumber = 27;
1153 private readonly static long MaxNumberOfIterationsDefaultValue = -1L;
1154
1155 private long maxNumberOfIterations_;
1160 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1161 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1162 public long MaxNumberOfIterations {
1163 get { if ((_hasBits0 & 2097152) != 0) { return maxNumberOfIterations_; } else { return MaxNumberOfIterationsDefaultValue; } }
1164 set {
1165 _hasBits0 |= 2097152;
1166 maxNumberOfIterations_ = value;
1167 }
1168 }
1170 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1171 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1172 public bool HasMaxNumberOfIterations {
1173 get { return (_hasBits0 & 2097152) != 0; }
1174 }
1176 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1177 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1178 public void ClearMaxNumberOfIterations() {
1179 _hasBits0 &= ~2097152;
1180 }
1181
1183 public const int MarkowitzZlatevParameterFieldNumber = 29;
1184 private readonly static int MarkowitzZlatevParameterDefaultValue = 3;
1185
1186 private int markowitzZlatevParameter_;
1191 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1192 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1193 public int MarkowitzZlatevParameter {
1194 get { if ((_hasBits0 & 4194304) != 0) { return markowitzZlatevParameter_; } else { return MarkowitzZlatevParameterDefaultValue; } }
1195 set {
1196 _hasBits0 |= 4194304;
1197 markowitzZlatevParameter_ = value;
1198 }
1199 }
1201 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1202 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1203 public bool HasMarkowitzZlatevParameter {
1204 get { return (_hasBits0 & 4194304) != 0; }
1205 }
1207 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1208 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1209 public void ClearMarkowitzZlatevParameter() {
1210 _hasBits0 &= ~4194304;
1211 }
1212
1214 public const int MarkowitzSingularityThresholdFieldNumber = 30;
1215 private readonly static double MarkowitzSingularityThresholdDefaultValue = 1e-15D;
1216
1217 private double markowitzSingularityThreshold_;
1224 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1225 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1226 public double MarkowitzSingularityThreshold {
1227 get { if ((_hasBits0 & 8388608) != 0) { return markowitzSingularityThreshold_; } else { return MarkowitzSingularityThresholdDefaultValue; } }
1228 set {
1229 _hasBits0 |= 8388608;
1230 markowitzSingularityThreshold_ = value;
1231 }
1232 }
1234 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1235 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1236 public bool HasMarkowitzSingularityThreshold {
1237 get { return (_hasBits0 & 8388608) != 0; }
1238 }
1240 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1241 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1242 public void ClearMarkowitzSingularityThreshold() {
1243 _hasBits0 &= ~8388608;
1244 }
1245
1247 public const int UseDualSimplexFieldNumber = 31;
1248 private readonly static bool UseDualSimplexDefaultValue = false;
1249
1250 private bool useDualSimplex_;
1254 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1255 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1256 public bool UseDualSimplex {
1257 get { if ((_hasBits0 & 16777216) != 0) { return useDualSimplex_; } else { return UseDualSimplexDefaultValue; } }
1258 set {
1259 _hasBits0 |= 16777216;
1260 useDualSimplex_ = value;
1261 }
1262 }
1264 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1265 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1266 public bool HasUseDualSimplex {
1267 get { return (_hasBits0 & 16777216) != 0; }
1268 }
1270 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1271 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1272 public void ClearUseDualSimplex() {
1273 _hasBits0 &= ~16777216;
1274 }
1275
1277 public const int AllowSimplexAlgorithmChangeFieldNumber = 32;
1278 private readonly static bool AllowSimplexAlgorithmChangeDefaultValue = false;
1279
1280 private bool allowSimplexAlgorithmChange_;
1287 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1288 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1289 public bool AllowSimplexAlgorithmChange {
1290 get { if ((_hasBits0 & 33554432) != 0) { return allowSimplexAlgorithmChange_; } else { return AllowSimplexAlgorithmChangeDefaultValue; } }
1291 set {
1292 _hasBits0 |= 33554432;
1293 allowSimplexAlgorithmChange_ = value;
1294 }
1295 }
1297 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1298 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1299 public bool HasAllowSimplexAlgorithmChange {
1300 get { return (_hasBits0 & 33554432) != 0; }
1301 }
1303 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1304 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1305 public void ClearAllowSimplexAlgorithmChange() {
1306 _hasBits0 &= ~33554432;
1307 }
1308
1310 public const int DevexWeightsResetPeriodFieldNumber = 33;
1311 private readonly static int DevexWeightsResetPeriodDefaultValue = 150;
1312
1313 private int devexWeightsResetPeriod_;
1317 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1318 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1319 public int DevexWeightsResetPeriod {
1320 get { if ((_hasBits0 & 67108864) != 0) { return devexWeightsResetPeriod_; } else { return DevexWeightsResetPeriodDefaultValue; } }
1321 set {
1322 _hasBits0 |= 67108864;
1323 devexWeightsResetPeriod_ = value;
1324 }
1325 }
1327 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1328 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1329 public bool HasDevexWeightsResetPeriod {
1330 get { return (_hasBits0 & 67108864) != 0; }
1331 }
1333 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1334 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1335 public void ClearDevexWeightsResetPeriod() {
1336 _hasBits0 &= ~67108864;
1337 }
1338
1340 public const int UsePreprocessingFieldNumber = 34;
1341 private readonly static bool UsePreprocessingDefaultValue = true;
1342
1343 private bool usePreprocessing_;
1347 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1348 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1349 public bool UsePreprocessing {
1350 get { if ((_hasBits0 & 134217728) != 0) { return usePreprocessing_; } else { return UsePreprocessingDefaultValue; } }
1351 set {
1352 _hasBits0 |= 134217728;
1353 usePreprocessing_ = value;
1354 }
1355 }
1357 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1358 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1359 public bool HasUsePreprocessing {
1360 get { return (_hasBits0 & 134217728) != 0; }
1361 }
1363 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1364 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1365 public void ClearUsePreprocessing() {
1366 _hasBits0 &= ~134217728;
1367 }
1368
1370 public const int UseMiddleProductFormUpdateFieldNumber = 35;
1371 private readonly static bool UseMiddleProductFormUpdateDefaultValue = true;
1372
1373 private bool useMiddleProductFormUpdate_;
1383 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1384 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1385 public bool UseMiddleProductFormUpdate {
1386 get { if ((_hasBits0 & 268435456) != 0) { return useMiddleProductFormUpdate_; } else { return UseMiddleProductFormUpdateDefaultValue; } }
1387 set {
1388 _hasBits0 |= 268435456;
1389 useMiddleProductFormUpdate_ = value;
1390 }
1391 }
1393 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1394 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1395 public bool HasUseMiddleProductFormUpdate {
1396 get { return (_hasBits0 & 268435456) != 0; }
1397 }
1399 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1400 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1401 public void ClearUseMiddleProductFormUpdate() {
1402 _hasBits0 &= ~268435456;
1403 }
1404
1406 public const int InitializeDevexWithColumnNormsFieldNumber = 36;
1407 private readonly static bool InitializeDevexWithColumnNormsDefaultValue = true;
1408
1409 private bool initializeDevexWithColumnNorms_;
1414 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1415 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1416 public bool InitializeDevexWithColumnNorms {
1417 get { if ((_hasBits0 & 536870912) != 0) { return initializeDevexWithColumnNorms_; } else { return InitializeDevexWithColumnNormsDefaultValue; } }
1418 set {
1419 _hasBits0 |= 536870912;
1420 initializeDevexWithColumnNorms_ = value;
1421 }
1422 }
1424 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1425 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1426 public bool HasInitializeDevexWithColumnNorms {
1427 get { return (_hasBits0 & 536870912) != 0; }
1428 }
1430 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1431 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1432 public void ClearInitializeDevexWithColumnNorms() {
1433 _hasBits0 &= ~536870912;
1434 }
1435
1437 public const int ExploitSingletonColumnInInitialBasisFieldNumber = 37;
1438 private readonly static bool ExploitSingletonColumnInInitialBasisDefaultValue = true;
1439
1440 private bool exploitSingletonColumnInInitialBasis_;
1445 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1446 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1447 public bool ExploitSingletonColumnInInitialBasis {
1448 get { if ((_hasBits0 & 1073741824) != 0) { return exploitSingletonColumnInInitialBasis_; } else { return ExploitSingletonColumnInInitialBasisDefaultValue; } }
1449 set {
1450 _hasBits0 |= 1073741824;
1451 exploitSingletonColumnInInitialBasis_ = value;
1452 }
1453 }
1455 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1456 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1457 public bool HasExploitSingletonColumnInInitialBasis {
1458 get { return (_hasBits0 & 1073741824) != 0; }
1459 }
1461 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1462 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1463 public void ClearExploitSingletonColumnInInitialBasis() {
1464 _hasBits0 &= ~1073741824;
1465 }
1466
1468 public const int DualSmallPivotThresholdFieldNumber = 38;
1469 private readonly static double DualSmallPivotThresholdDefaultValue = 0.0001D;
1470
1471 private double dualSmallPivotThreshold_;
1477 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1478 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1479 public double DualSmallPivotThreshold {
1480 get { if ((_hasBits0 & -2147483648) != 0) { return dualSmallPivotThreshold_; } else { return DualSmallPivotThresholdDefaultValue; } }
1481 set {
1482 _hasBits0 |= -2147483648;
1483 dualSmallPivotThreshold_ = value;
1484 }
1485 }
1487 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1488 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1489 public bool HasDualSmallPivotThreshold {
1490 get { return (_hasBits0 & -2147483648) != 0; }
1491 }
1493 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1494 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1495 public void ClearDualSmallPivotThreshold() {
1496 _hasBits0 &= ~-2147483648;
1497 }
1498
1500 public const int PreprocessorZeroToleranceFieldNumber = 39;
1501 private readonly static double PreprocessorZeroToleranceDefaultValue = 1e-09D;
1502
1503 private double preprocessorZeroTolerance_;
1512 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1513 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1514 public double PreprocessorZeroTolerance {
1515 get { if ((_hasBits1 & 1) != 0) { return preprocessorZeroTolerance_; } else { return PreprocessorZeroToleranceDefaultValue; } }
1516 set {
1517 _hasBits1 |= 1;
1518 preprocessorZeroTolerance_ = value;
1519 }
1520 }
1522 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1523 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1524 public bool HasPreprocessorZeroTolerance {
1525 get { return (_hasBits1 & 1) != 0; }
1526 }
1528 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1529 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1530 public void ClearPreprocessorZeroTolerance() {
1531 _hasBits1 &= ~1;
1532 }
1533
1535 public const int ObjectiveLowerLimitFieldNumber = 40;
1536 private readonly static double ObjectiveLowerLimitDefaultValue = double.NegativeInfinity;
1537
1538 private double objectiveLowerLimit_;
1550 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1551 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1552 public double ObjectiveLowerLimit {
1553 get { if ((_hasBits1 & 2) != 0) { return objectiveLowerLimit_; } else { return ObjectiveLowerLimitDefaultValue; } }
1554 set {
1555 _hasBits1 |= 2;
1556 objectiveLowerLimit_ = value;
1557 }
1558 }
1560 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1561 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1562 public bool HasObjectiveLowerLimit {
1563 get { return (_hasBits1 & 2) != 0; }
1564 }
1566 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1567 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1568 public void ClearObjectiveLowerLimit() {
1569 _hasBits1 &= ~2;
1570 }
1571
1573 public const int ObjectiveUpperLimitFieldNumber = 41;
1574 private readonly static double ObjectiveUpperLimitDefaultValue = double.PositiveInfinity;
1575
1576 private double objectiveUpperLimit_;
1577 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1578 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1579 public double ObjectiveUpperLimit {
1580 get { if ((_hasBits1 & 4) != 0) { return objectiveUpperLimit_; } else { return ObjectiveUpperLimitDefaultValue; } }
1581 set {
1582 _hasBits1 |= 4;
1583 objectiveUpperLimit_ = value;
1584 }
1585 }
1587 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1588 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1589 public bool HasObjectiveUpperLimit {
1590 get { return (_hasBits1 & 4) != 0; }
1591 }
1593 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1594 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1595 public void ClearObjectiveUpperLimit() {
1596 _hasBits1 &= ~4;
1597 }
1598
1600 public const int DegenerateMinistepFactorFieldNumber = 42;
1601 private readonly static double DegenerateMinistepFactorDefaultValue = 0.01D;
1602
1603 private double degenerateMinistepFactor_;
1624 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1625 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1626 public double DegenerateMinistepFactor {
1627 get { if ((_hasBits1 & 8) != 0) { return degenerateMinistepFactor_; } else { return DegenerateMinistepFactorDefaultValue; } }
1628 set {
1629 _hasBits1 |= 8;
1630 degenerateMinistepFactor_ = value;
1631 }
1632 }
1634 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1635 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1636 public bool HasDegenerateMinistepFactor {
1637 get { return (_hasBits1 & 8) != 0; }
1638 }
1640 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1641 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1642 public void ClearDegenerateMinistepFactor() {
1643 _hasBits1 &= ~8;
1644 }
1645
1647 public const int RandomSeedFieldNumber = 43;
1648 private readonly static int RandomSeedDefaultValue = 1;
1649
1650 private int randomSeed_;
1668 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1669 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1670 public int RandomSeed {
1671 get { if ((_hasBits1 & 16) != 0) { return randomSeed_; } else { return RandomSeedDefaultValue; } }
1672 set {
1673 _hasBits1 |= 16;
1674 randomSeed_ = value;
1675 }
1676 }
1678 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1679 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1680 public bool HasRandomSeed {
1681 get { return (_hasBits1 & 16) != 0; }
1682 }
1684 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1685 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1686 public void ClearRandomSeed() {
1687 _hasBits1 &= ~16;
1688 }
1689
1691 public const int NumOmpThreadsFieldNumber = 44;
1692 private readonly static int NumOmpThreadsDefaultValue = 1;
1693
1694 private int numOmpThreads_;
1699 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1700 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1701 public int NumOmpThreads {
1702 get { if ((_hasBits1 & 32) != 0) { return numOmpThreads_; } else { return NumOmpThreadsDefaultValue; } }
1703 set {
1704 _hasBits1 |= 32;
1705 numOmpThreads_ = value;
1706 }
1707 }
1709 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1710 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1711 public bool HasNumOmpThreads {
1712 get { return (_hasBits1 & 32) != 0; }
1713 }
1715 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1716 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1717 public void ClearNumOmpThreads() {
1718 _hasBits1 &= ~32;
1719 }
1720
1722 public const int PerturbCostsInDualSimplexFieldNumber = 53;
1723 private readonly static bool PerturbCostsInDualSimplexDefaultValue = false;
1724
1725 private bool perturbCostsInDualSimplex_;
1732 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1733 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1734 public bool PerturbCostsInDualSimplex {
1735 get { if ((_hasBits1 & 256) != 0) { return perturbCostsInDualSimplex_; } else { return PerturbCostsInDualSimplexDefaultValue; } }
1736 set {
1737 _hasBits1 |= 256;
1738 perturbCostsInDualSimplex_ = value;
1739 }
1740 }
1742 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1743 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1744 public bool HasPerturbCostsInDualSimplex {
1745 get { return (_hasBits1 & 256) != 0; }
1746 }
1748 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1749 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1750 public void ClearPerturbCostsInDualSimplex() {
1751 _hasBits1 &= ~256;
1752 }
1753
1755 public const int UseDedicatedDualFeasibilityAlgorithmFieldNumber = 62;
1756 private readonly static bool UseDedicatedDualFeasibilityAlgorithmDefaultValue = true;
1757
1758 private bool useDedicatedDualFeasibilityAlgorithm_;
1769 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1770 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1771 public bool UseDedicatedDualFeasibilityAlgorithm {
1772 get { if ((_hasBits1 & 131072) != 0) { return useDedicatedDualFeasibilityAlgorithm_; } else { return UseDedicatedDualFeasibilityAlgorithmDefaultValue; } }
1773 set {
1774 _hasBits1 |= 131072;
1775 useDedicatedDualFeasibilityAlgorithm_ = value;
1776 }
1777 }
1779 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1780 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1781 public bool HasUseDedicatedDualFeasibilityAlgorithm {
1782 get { return (_hasBits1 & 131072) != 0; }
1783 }
1785 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1786 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1787 public void ClearUseDedicatedDualFeasibilityAlgorithm() {
1788 _hasBits1 &= ~131072;
1789 }
1790
1792 public const int RelativeCostPerturbationFieldNumber = 54;
1793 private readonly static double RelativeCostPerturbationDefaultValue = 1e-05D;
1794
1795 private double relativeCostPerturbation_;
1802 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1803 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1804 public double RelativeCostPerturbation {
1805 get { if ((_hasBits1 & 512) != 0) { return relativeCostPerturbation_; } else { return RelativeCostPerturbationDefaultValue; } }
1806 set {
1807 _hasBits1 |= 512;
1808 relativeCostPerturbation_ = value;
1809 }
1810 }
1812 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1813 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1814 public bool HasRelativeCostPerturbation {
1815 get { return (_hasBits1 & 512) != 0; }
1816 }
1818 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1819 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1820 public void ClearRelativeCostPerturbation() {
1821 _hasBits1 &= ~512;
1822 }
1823
1825 public const int RelativeMaxCostPerturbationFieldNumber = 55;
1826 private readonly static double RelativeMaxCostPerturbationDefaultValue = 1e-07D;
1827
1828 private double relativeMaxCostPerturbation_;
1829 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1830 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1831 public double RelativeMaxCostPerturbation {
1832 get { if ((_hasBits1 & 1024) != 0) { return relativeMaxCostPerturbation_; } else { return RelativeMaxCostPerturbationDefaultValue; } }
1833 set {
1834 _hasBits1 |= 1024;
1835 relativeMaxCostPerturbation_ = value;
1836 }
1837 }
1839 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1840 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1841 public bool HasRelativeMaxCostPerturbation {
1842 get { return (_hasBits1 & 1024) != 0; }
1843 }
1845 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1846 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1847 public void ClearRelativeMaxCostPerturbation() {
1848 _hasBits1 &= ~1024;
1849 }
1850
1852 public const int InitialConditionNumberThresholdFieldNumber = 59;
1853 private readonly static double InitialConditionNumberThresholdDefaultValue = 1e+50D;
1854
1855 private double initialConditionNumberThreshold_;
1861 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1862 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1863 public double InitialConditionNumberThreshold {
1864 get { if ((_hasBits1 & 16384) != 0) { return initialConditionNumberThreshold_; } else { return InitialConditionNumberThresholdDefaultValue; } }
1865 set {
1866 _hasBits1 |= 16384;
1867 initialConditionNumberThreshold_ = value;
1868 }
1869 }
1871 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1872 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1873 public bool HasInitialConditionNumberThreshold {
1874 get { return (_hasBits1 & 16384) != 0; }
1875 }
1877 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1878 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1879 public void ClearInitialConditionNumberThreshold() {
1880 _hasBits1 &= ~16384;
1881 }
1882
1884 public const int LogSearchProgressFieldNumber = 61;
1885 private readonly static bool LogSearchProgressDefaultValue = false;
1886
1887 private bool logSearchProgress_;
1893 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1894 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1895 public bool LogSearchProgress {
1896 get { if ((_hasBits1 & 65536) != 0) { return logSearchProgress_; } else { return LogSearchProgressDefaultValue; } }
1897 set {
1898 _hasBits1 |= 65536;
1899 logSearchProgress_ = value;
1900 }
1901 }
1903 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1904 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1905 public bool HasLogSearchProgress {
1906 get { return (_hasBits1 & 65536) != 0; }
1907 }
1909 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1910 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1911 public void ClearLogSearchProgress() {
1912 _hasBits1 &= ~65536;
1913 }
1914
1916 public const int LogToStdoutFieldNumber = 66;
1917 private readonly static bool LogToStdoutDefaultValue = true;
1918
1919 private bool logToStdout_;
1923 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1924 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1925 public bool LogToStdout {
1926 get { if ((_hasBits1 & 2097152) != 0) { return logToStdout_; } else { return LogToStdoutDefaultValue; } }
1927 set {
1928 _hasBits1 |= 2097152;
1929 logToStdout_ = value;
1930 }
1931 }
1933 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1934 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1935 public bool HasLogToStdout {
1936 get { return (_hasBits1 & 2097152) != 0; }
1937 }
1939 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1940 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1941 public void ClearLogToStdout() {
1942 _hasBits1 &= ~2097152;
1943 }
1944
1946 public const int CrossoverBoundSnappingDistanceFieldNumber = 64;
1947 private readonly static double CrossoverBoundSnappingDistanceDefaultValue = double.PositiveInfinity;
1948
1949 private double crossoverBoundSnappingDistance_;
1967 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1968 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1969 public double CrossoverBoundSnappingDistance {
1970 get { if ((_hasBits1 & 524288) != 0) { return crossoverBoundSnappingDistance_; } else { return CrossoverBoundSnappingDistanceDefaultValue; } }
1971 set {
1972 _hasBits1 |= 524288;
1973 crossoverBoundSnappingDistance_ = value;
1974 }
1975 }
1977 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1978 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1979 public bool HasCrossoverBoundSnappingDistance {
1980 get { return (_hasBits1 & 524288) != 0; }
1981 }
1983 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1984 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
1985 public void ClearCrossoverBoundSnappingDistance() {
1986 _hasBits1 &= ~524288;
1987 }
1988
1990 public const int PushToVertexFieldNumber = 65;
1991 private readonly static bool PushToVertexDefaultValue = true;
1992
1993 private bool pushToVertex_;
2002 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2003 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2004 public bool PushToVertex {
2005 get { if ((_hasBits1 & 1048576) != 0) { return pushToVertex_; } else { return PushToVertexDefaultValue; } }
2006 set {
2007 _hasBits1 |= 1048576;
2008 pushToVertex_ = value;
2009 }
2010 }
2012 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2013 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2014 public bool HasPushToVertex {
2015 get { return (_hasBits1 & 1048576) != 0; }
2016 }
2018 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2019 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2020 public void ClearPushToVertex() {
2021 _hasBits1 &= ~1048576;
2022 }
2023
2025 public const int UseImpliedFreePreprocessorFieldNumber = 67;
2026 private readonly static bool UseImpliedFreePreprocessorDefaultValue = true;
2027
2028 private bool useImpliedFreePreprocessor_;
2032 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2033 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2034 public bool UseImpliedFreePreprocessor {
2035 get { if ((_hasBits1 & 4194304) != 0) { return useImpliedFreePreprocessor_; } else { return UseImpliedFreePreprocessorDefaultValue; } }
2036 set {
2037 _hasBits1 |= 4194304;
2038 useImpliedFreePreprocessor_ = value;
2039 }
2040 }
2042 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2043 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2044 public bool HasUseImpliedFreePreprocessor {
2045 get { return (_hasBits1 & 4194304) != 0; }
2046 }
2048 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2049 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2050 public void ClearUseImpliedFreePreprocessor() {
2051 _hasBits1 &= ~4194304;
2052 }
2053
2055 public const int MaxValidMagnitudeFieldNumber = 70;
2056 private readonly static double MaxValidMagnitudeDefaultValue = 1e+30D;
2057
2058 private double maxValidMagnitude_;
2067 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2068 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2069 public double MaxValidMagnitude {
2070 get { if ((_hasBits1 & 16777216) != 0) { return maxValidMagnitude_; } else { return MaxValidMagnitudeDefaultValue; } }
2071 set {
2072 _hasBits1 |= 16777216;
2073 maxValidMagnitude_ = value;
2074 }
2075 }
2077 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2078 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2079 public bool HasMaxValidMagnitude {
2080 get { return (_hasBits1 & 16777216) != 0; }
2081 }
2083 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2084 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2085 public void ClearMaxValidMagnitude() {
2086 _hasBits1 &= ~16777216;
2087 }
2088
2090 public const int DropMagnitudeFieldNumber = 71;
2091 private readonly static double DropMagnitudeDefaultValue = 1e-30D;
2092
2093 private double dropMagnitude_;
2100 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2101 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2102 public double DropMagnitude {
2103 get { if ((_hasBits1 & 33554432) != 0) { return dropMagnitude_; } else { return DropMagnitudeDefaultValue; } }
2104 set {
2105 _hasBits1 |= 33554432;
2106 dropMagnitude_ = value;
2107 }
2108 }
2110 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2111 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2112 public bool HasDropMagnitude {
2113 get { return (_hasBits1 & 33554432) != 0; }
2114 }
2116 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2117 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2118 public void ClearDropMagnitude() {
2119 _hasBits1 &= ~33554432;
2120 }
2121
2123 public const int DualPricePrioritizeNormFieldNumber = 69;
2124 private readonly static bool DualPricePrioritizeNormDefaultValue = false;
2125
2126 private bool dualPricePrioritizeNorm_;
2131 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2132 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2133 public bool DualPricePrioritizeNorm {
2134 get { if ((_hasBits1 & 8388608) != 0) { return dualPricePrioritizeNorm_; } else { return DualPricePrioritizeNormDefaultValue; } }
2135 set {
2136 _hasBits1 |= 8388608;
2137 dualPricePrioritizeNorm_ = value;
2138 }
2139 }
2141 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2142 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2143 public bool HasDualPricePrioritizeNorm {
2144 get { return (_hasBits1 & 8388608) != 0; }
2145 }
2147 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2148 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2149 public void ClearDualPricePrioritizeNorm() {
2150 _hasBits1 &= ~8388608;
2151 }
2152
2153 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2154 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2155 public override bool Equals(object other) {
2156 return Equals(other as GlopParameters);
2157 }
2158
2159 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2160 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2161 public bool Equals(GlopParameters other) {
2162 if (ReferenceEquals(other, null)) {
2163 return false;
2164 }
2165 if (ReferenceEquals(other, this)) {
2166 return true;
2167 }
2168 if (ScalingMethod != other.ScalingMethod) return false;
2169 if (FeasibilityRule != other.FeasibilityRule) return false;
2170 if (OptimizationRule != other.OptimizationRule) return false;
2171 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RefactorizationThreshold, other.RefactorizationThreshold)) return false;
2172 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RecomputeReducedCostsThreshold, other.RecomputeReducedCostsThreshold)) return false;
2173 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RecomputeEdgesNormThreshold, other.RecomputeEdgesNormThreshold)) return false;
2174 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(PrimalFeasibilityTolerance, other.PrimalFeasibilityTolerance)) return false;
2175 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DualFeasibilityTolerance, other.DualFeasibilityTolerance)) return false;
2176 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RatioTestZeroThreshold, other.RatioTestZeroThreshold)) return false;
2177 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(HarrisToleranceRatio, other.HarrisToleranceRatio)) return false;
2178 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(SmallPivotThreshold, other.SmallPivotThreshold)) return false;
2179 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MinimumAcceptablePivot, other.MinimumAcceptablePivot)) return false;
2180 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DropTolerance, other.DropTolerance)) return false;
2181 if (UseScaling != other.UseScaling) return false;
2182 if (CostScaling != other.CostScaling) return false;
2183 if (InitialBasis != other.InitialBasis) return false;
2184 if (UseTransposedMatrix != other.UseTransposedMatrix) return false;
2185 if (BasisRefactorizationPeriod != other.BasisRefactorizationPeriod) return false;
2186 if (DynamicallyAdjustRefactorizationPeriod != other.DynamicallyAdjustRefactorizationPeriod) return false;
2187 if (SolveDualProblem != other.SolveDualProblem) return false;
2188 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DualizerThreshold, other.DualizerThreshold)) return false;
2189 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(SolutionFeasibilityTolerance, other.SolutionFeasibilityTolerance)) return false;
2190 if (ProvideStrongOptimalGuarantee != other.ProvideStrongOptimalGuarantee) return false;
2191 if (ChangeStatusToImprecise != other.ChangeStatusToImprecise) return false;
2192 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MaxNumberOfReoptimizations, other.MaxNumberOfReoptimizations)) return false;
2193 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(LuFactorizationPivotThreshold, other.LuFactorizationPivotThreshold)) return false;
2194 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MaxTimeInSeconds, other.MaxTimeInSeconds)) return false;
2195 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MaxDeterministicTime, other.MaxDeterministicTime)) return false;
2196 if (MaxNumberOfIterations != other.MaxNumberOfIterations) return false;
2197 if (MarkowitzZlatevParameter != other.MarkowitzZlatevParameter) return false;
2198 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MarkowitzSingularityThreshold, other.MarkowitzSingularityThreshold)) return false;
2199 if (UseDualSimplex != other.UseDualSimplex) return false;
2200 if (AllowSimplexAlgorithmChange != other.AllowSimplexAlgorithmChange) return false;
2201 if (DevexWeightsResetPeriod != other.DevexWeightsResetPeriod) return false;
2202 if (UsePreprocessing != other.UsePreprocessing) return false;
2203 if (UseMiddleProductFormUpdate != other.UseMiddleProductFormUpdate) return false;
2204 if (InitializeDevexWithColumnNorms != other.InitializeDevexWithColumnNorms) return false;
2205 if (ExploitSingletonColumnInInitialBasis != other.ExploitSingletonColumnInInitialBasis) return false;
2206 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DualSmallPivotThreshold, other.DualSmallPivotThreshold)) return false;
2207 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(PreprocessorZeroTolerance, other.PreprocessorZeroTolerance)) return false;
2208 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ObjectiveLowerLimit, other.ObjectiveLowerLimit)) return false;
2209 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ObjectiveUpperLimit, other.ObjectiveUpperLimit)) return false;
2210 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DegenerateMinistepFactor, other.DegenerateMinistepFactor)) return false;
2211 if (RandomSeed != other.RandomSeed) return false;
2212 if (NumOmpThreads != other.NumOmpThreads) return false;
2213 if (PerturbCostsInDualSimplex != other.PerturbCostsInDualSimplex) return false;
2214 if (UseDedicatedDualFeasibilityAlgorithm != other.UseDedicatedDualFeasibilityAlgorithm) return false;
2215 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RelativeCostPerturbation, other.RelativeCostPerturbation)) return false;
2216 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RelativeMaxCostPerturbation, other.RelativeMaxCostPerturbation)) return false;
2217 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(InitialConditionNumberThreshold, other.InitialConditionNumberThreshold)) return false;
2218 if (LogSearchProgress != other.LogSearchProgress) return false;
2219 if (LogToStdout != other.LogToStdout) return false;
2220 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(CrossoverBoundSnappingDistance, other.CrossoverBoundSnappingDistance)) return false;
2221 if (PushToVertex != other.PushToVertex) return false;
2222 if (UseImpliedFreePreprocessor != other.UseImpliedFreePreprocessor) return false;
2223 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MaxValidMagnitude, other.MaxValidMagnitude)) return false;
2224 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DropMagnitude, other.DropMagnitude)) return false;
2225 if (DualPricePrioritizeNorm != other.DualPricePrioritizeNorm) return false;
2226 return Equals(_unknownFields, other._unknownFields);
2227 }
2228
2229 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2230 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2231 public override int GetHashCode() {
2232 int hash = 1;
2233 if (HasScalingMethod) hash ^= ScalingMethod.GetHashCode();
2234 if (HasFeasibilityRule) hash ^= FeasibilityRule.GetHashCode();
2235 if (HasOptimizationRule) hash ^= OptimizationRule.GetHashCode();
2236 if (HasRefactorizationThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RefactorizationThreshold);
2237 if (HasRecomputeReducedCostsThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RecomputeReducedCostsThreshold);
2238 if (HasRecomputeEdgesNormThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RecomputeEdgesNormThreshold);
2239 if (HasPrimalFeasibilityTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PrimalFeasibilityTolerance);
2240 if (HasDualFeasibilityTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DualFeasibilityTolerance);
2241 if (HasRatioTestZeroThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RatioTestZeroThreshold);
2242 if (HasHarrisToleranceRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(HarrisToleranceRatio);
2243 if (HasSmallPivotThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(SmallPivotThreshold);
2244 if (HasMinimumAcceptablePivot) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MinimumAcceptablePivot);
2245 if (HasDropTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DropTolerance);
2246 if (HasUseScaling) hash ^= UseScaling.GetHashCode();
2247 if (HasCostScaling) hash ^= CostScaling.GetHashCode();
2248 if (HasInitialBasis) hash ^= InitialBasis.GetHashCode();
2249 if (HasUseTransposedMatrix) hash ^= UseTransposedMatrix.GetHashCode();
2250 if (HasBasisRefactorizationPeriod) hash ^= BasisRefactorizationPeriod.GetHashCode();
2251 if (HasDynamicallyAdjustRefactorizationPeriod) hash ^= DynamicallyAdjustRefactorizationPeriod.GetHashCode();
2252 if (HasSolveDualProblem) hash ^= SolveDualProblem.GetHashCode();
2253 if (HasDualizerThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DualizerThreshold);
2254 if (HasSolutionFeasibilityTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(SolutionFeasibilityTolerance);
2255 if (HasProvideStrongOptimalGuarantee) hash ^= ProvideStrongOptimalGuarantee.GetHashCode();
2256 if (HasChangeStatusToImprecise) hash ^= ChangeStatusToImprecise.GetHashCode();
2257 if (HasMaxNumberOfReoptimizations) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxNumberOfReoptimizations);
2258 if (HasLuFactorizationPivotThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(LuFactorizationPivotThreshold);
2259 if (HasMaxTimeInSeconds) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxTimeInSeconds);
2260 if (HasMaxDeterministicTime) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxDeterministicTime);
2261 if (HasMaxNumberOfIterations) hash ^= MaxNumberOfIterations.GetHashCode();
2262 if (HasMarkowitzZlatevParameter) hash ^= MarkowitzZlatevParameter.GetHashCode();
2263 if (HasMarkowitzSingularityThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MarkowitzSingularityThreshold);
2264 if (HasUseDualSimplex) hash ^= UseDualSimplex.GetHashCode();
2265 if (HasAllowSimplexAlgorithmChange) hash ^= AllowSimplexAlgorithmChange.GetHashCode();
2266 if (HasDevexWeightsResetPeriod) hash ^= DevexWeightsResetPeriod.GetHashCode();
2267 if (HasUsePreprocessing) hash ^= UsePreprocessing.GetHashCode();
2268 if (HasUseMiddleProductFormUpdate) hash ^= UseMiddleProductFormUpdate.GetHashCode();
2269 if (HasInitializeDevexWithColumnNorms) hash ^= InitializeDevexWithColumnNorms.GetHashCode();
2270 if (HasExploitSingletonColumnInInitialBasis) hash ^= ExploitSingletonColumnInInitialBasis.GetHashCode();
2271 if (HasDualSmallPivotThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DualSmallPivotThreshold);
2272 if (HasPreprocessorZeroTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PreprocessorZeroTolerance);
2273 if (HasObjectiveLowerLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ObjectiveLowerLimit);
2274 if (HasObjectiveUpperLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ObjectiveUpperLimit);
2275 if (HasDegenerateMinistepFactor) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DegenerateMinistepFactor);
2276 if (HasRandomSeed) hash ^= RandomSeed.GetHashCode();
2277 if (HasNumOmpThreads) hash ^= NumOmpThreads.GetHashCode();
2278 if (HasPerturbCostsInDualSimplex) hash ^= PerturbCostsInDualSimplex.GetHashCode();
2279 if (HasUseDedicatedDualFeasibilityAlgorithm) hash ^= UseDedicatedDualFeasibilityAlgorithm.GetHashCode();
2280 if (HasRelativeCostPerturbation) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RelativeCostPerturbation);
2281 if (HasRelativeMaxCostPerturbation) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RelativeMaxCostPerturbation);
2282 if (HasInitialConditionNumberThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(InitialConditionNumberThreshold);
2283 if (HasLogSearchProgress) hash ^= LogSearchProgress.GetHashCode();
2284 if (HasLogToStdout) hash ^= LogToStdout.GetHashCode();
2285 if (HasCrossoverBoundSnappingDistance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(CrossoverBoundSnappingDistance);
2286 if (HasPushToVertex) hash ^= PushToVertex.GetHashCode();
2287 if (HasUseImpliedFreePreprocessor) hash ^= UseImpliedFreePreprocessor.GetHashCode();
2288 if (HasMaxValidMagnitude) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxValidMagnitude);
2289 if (HasDropMagnitude) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DropMagnitude);
2290 if (HasDualPricePrioritizeNorm) hash ^= DualPricePrioritizeNorm.GetHashCode();
2291 if (_unknownFields != null) {
2292 hash ^= _unknownFields.GetHashCode();
2293 }
2294 return hash;
2295 }
2296
2297 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2298 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2299 public override string ToString() {
2300 return pb::JsonFormatter.ToDiagnosticString(this);
2301 }
2302
2303 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2304 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2305 public void WriteTo(pb::CodedOutputStream output) {
2306 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2307 output.WriteRawMessage(this);
2308 #else
2309 if (HasFeasibilityRule) {
2310 output.WriteRawTag(8);
2311 output.WriteEnum((int) FeasibilityRule);
2312 }
2313 if (HasOptimizationRule) {
2314 output.WriteRawTag(16);
2315 output.WriteEnum((int) OptimizationRule);
2316 }
2317 if (HasRefactorizationThreshold) {
2318 output.WriteRawTag(49);
2319 output.WriteDouble(RefactorizationThreshold);
2320 }
2321 if (HasRecomputeReducedCostsThreshold) {
2322 output.WriteRawTag(65);
2323 output.WriteDouble(RecomputeReducedCostsThreshold);
2324 }
2325 if (HasRecomputeEdgesNormThreshold) {
2326 output.WriteRawTag(73);
2327 output.WriteDouble(RecomputeEdgesNormThreshold);
2328 }
2329 if (HasPrimalFeasibilityTolerance) {
2330 output.WriteRawTag(81);
2331 output.WriteDouble(PrimalFeasibilityTolerance);
2332 }
2333 if (HasDualFeasibilityTolerance) {
2334 output.WriteRawTag(89);
2335 output.WriteDouble(DualFeasibilityTolerance);
2336 }
2337 if (HasRatioTestZeroThreshold) {
2338 output.WriteRawTag(97);
2339 output.WriteDouble(RatioTestZeroThreshold);
2340 }
2341 if (HasHarrisToleranceRatio) {
2342 output.WriteRawTag(105);
2343 output.WriteDouble(HarrisToleranceRatio);
2344 }
2345 if (HasSmallPivotThreshold) {
2346 output.WriteRawTag(113);
2347 output.WriteDouble(SmallPivotThreshold);
2348 }
2349 if (HasMinimumAcceptablePivot) {
2350 output.WriteRawTag(121);
2351 output.WriteDouble(MinimumAcceptablePivot);
2352 }
2353 if (HasUseScaling) {
2354 output.WriteRawTag(128, 1);
2355 output.WriteBool(UseScaling);
2356 }
2357 if (HasInitialBasis) {
2358 output.WriteRawTag(136, 1);
2359 output.WriteEnum((int) InitialBasis);
2360 }
2361 if (HasUseTransposedMatrix) {
2362 output.WriteRawTag(144, 1);
2363 output.WriteBool(UseTransposedMatrix);
2364 }
2365 if (HasBasisRefactorizationPeriod) {
2366 output.WriteRawTag(152, 1);
2367 output.WriteInt32(BasisRefactorizationPeriod);
2368 }
2369 if (HasSolveDualProblem) {
2370 output.WriteRawTag(160, 1);
2371 output.WriteEnum((int) SolveDualProblem);
2372 }
2373 if (HasDualizerThreshold) {
2374 output.WriteRawTag(169, 1);
2375 output.WriteDouble(DualizerThreshold);
2376 }
2377 if (HasSolutionFeasibilityTolerance) {
2378 output.WriteRawTag(177, 1);
2379 output.WriteDouble(SolutionFeasibilityTolerance);
2380 }
2381 if (HasProvideStrongOptimalGuarantee) {
2382 output.WriteRawTag(192, 1);
2383 output.WriteBool(ProvideStrongOptimalGuarantee);
2384 }
2385 if (HasLuFactorizationPivotThreshold) {
2386 output.WriteRawTag(201, 1);
2387 output.WriteDouble(LuFactorizationPivotThreshold);
2388 }
2389 if (HasMaxTimeInSeconds) {
2390 output.WriteRawTag(209, 1);
2391 output.WriteDouble(MaxTimeInSeconds);
2392 }
2393 if (HasMaxNumberOfIterations) {
2394 output.WriteRawTag(216, 1);
2395 output.WriteInt64(MaxNumberOfIterations);
2396 }
2397 if (HasMarkowitzZlatevParameter) {
2398 output.WriteRawTag(232, 1);
2399 output.WriteInt32(MarkowitzZlatevParameter);
2400 }
2401 if (HasMarkowitzSingularityThreshold) {
2402 output.WriteRawTag(241, 1);
2403 output.WriteDouble(MarkowitzSingularityThreshold);
2404 }
2405 if (HasUseDualSimplex) {
2406 output.WriteRawTag(248, 1);
2407 output.WriteBool(UseDualSimplex);
2408 }
2409 if (HasAllowSimplexAlgorithmChange) {
2410 output.WriteRawTag(128, 2);
2411 output.WriteBool(AllowSimplexAlgorithmChange);
2412 }
2413 if (HasDevexWeightsResetPeriod) {
2414 output.WriteRawTag(136, 2);
2415 output.WriteInt32(DevexWeightsResetPeriod);
2416 }
2417 if (HasUsePreprocessing) {
2418 output.WriteRawTag(144, 2);
2419 output.WriteBool(UsePreprocessing);
2420 }
2421 if (HasUseMiddleProductFormUpdate) {
2422 output.WriteRawTag(152, 2);
2423 output.WriteBool(UseMiddleProductFormUpdate);
2424 }
2425 if (HasInitializeDevexWithColumnNorms) {
2426 output.WriteRawTag(160, 2);
2427 output.WriteBool(InitializeDevexWithColumnNorms);
2428 }
2429 if (HasExploitSingletonColumnInInitialBasis) {
2430 output.WriteRawTag(168, 2);
2431 output.WriteBool(ExploitSingletonColumnInInitialBasis);
2432 }
2433 if (HasDualSmallPivotThreshold) {
2434 output.WriteRawTag(177, 2);
2435 output.WriteDouble(DualSmallPivotThreshold);
2436 }
2437 if (HasPreprocessorZeroTolerance) {
2438 output.WriteRawTag(185, 2);
2439 output.WriteDouble(PreprocessorZeroTolerance);
2440 }
2441 if (HasObjectiveLowerLimit) {
2442 output.WriteRawTag(193, 2);
2443 output.WriteDouble(ObjectiveLowerLimit);
2444 }
2445 if (HasObjectiveUpperLimit) {
2446 output.WriteRawTag(201, 2);
2447 output.WriteDouble(ObjectiveUpperLimit);
2448 }
2449 if (HasDegenerateMinistepFactor) {
2450 output.WriteRawTag(209, 2);
2451 output.WriteDouble(DegenerateMinistepFactor);
2452 }
2453 if (HasRandomSeed) {
2454 output.WriteRawTag(216, 2);
2455 output.WriteInt32(RandomSeed);
2456 }
2457 if (HasNumOmpThreads) {
2458 output.WriteRawTag(224, 2);
2459 output.WriteInt32(NumOmpThreads);
2460 }
2461 if (HasMaxDeterministicTime) {
2462 output.WriteRawTag(233, 2);
2463 output.WriteDouble(MaxDeterministicTime);
2464 }
2465 if (HasDropTolerance) {
2466 output.WriteRawTag(161, 3);
2467 output.WriteDouble(DropTolerance);
2468 }
2469 if (HasPerturbCostsInDualSimplex) {
2470 output.WriteRawTag(168, 3);
2471 output.WriteBool(PerturbCostsInDualSimplex);
2472 }
2473 if (HasRelativeCostPerturbation) {
2474 output.WriteRawTag(177, 3);
2475 output.WriteDouble(RelativeCostPerturbation);
2476 }
2477 if (HasRelativeMaxCostPerturbation) {
2478 output.WriteRawTag(185, 3);
2479 output.WriteDouble(RelativeMaxCostPerturbation);
2480 }
2481 if (HasMaxNumberOfReoptimizations) {
2482 output.WriteRawTag(193, 3);
2483 output.WriteDouble(MaxNumberOfReoptimizations);
2484 }
2485 if (HasScalingMethod) {
2486 output.WriteRawTag(200, 3);
2487 output.WriteEnum((int) ScalingMethod);
2488 }
2489 if (HasChangeStatusToImprecise) {
2490 output.WriteRawTag(208, 3);
2491 output.WriteBool(ChangeStatusToImprecise);
2492 }
2493 if (HasInitialConditionNumberThreshold) {
2494 output.WriteRawTag(217, 3);
2495 output.WriteDouble(InitialConditionNumberThreshold);
2496 }
2497 if (HasCostScaling) {
2498 output.WriteRawTag(224, 3);
2499 output.WriteEnum((int) CostScaling);
2500 }
2501 if (HasLogSearchProgress) {
2502 output.WriteRawTag(232, 3);
2503 output.WriteBool(LogSearchProgress);
2504 }
2505 if (HasUseDedicatedDualFeasibilityAlgorithm) {
2506 output.WriteRawTag(240, 3);
2507 output.WriteBool(UseDedicatedDualFeasibilityAlgorithm);
2508 }
2509 if (HasDynamicallyAdjustRefactorizationPeriod) {
2510 output.WriteRawTag(248, 3);
2511 output.WriteBool(DynamicallyAdjustRefactorizationPeriod);
2512 }
2513 if (HasCrossoverBoundSnappingDistance) {
2514 output.WriteRawTag(129, 4);
2515 output.WriteDouble(CrossoverBoundSnappingDistance);
2516 }
2517 if (HasPushToVertex) {
2518 output.WriteRawTag(136, 4);
2519 output.WriteBool(PushToVertex);
2520 }
2521 if (HasLogToStdout) {
2522 output.WriteRawTag(144, 4);
2523 output.WriteBool(LogToStdout);
2524 }
2525 if (HasUseImpliedFreePreprocessor) {
2526 output.WriteRawTag(152, 4);
2527 output.WriteBool(UseImpliedFreePreprocessor);
2528 }
2529 if (HasDualPricePrioritizeNorm) {
2530 output.WriteRawTag(168, 4);
2531 output.WriteBool(DualPricePrioritizeNorm);
2532 }
2533 if (HasMaxValidMagnitude) {
2534 output.WriteRawTag(177, 4);
2535 output.WriteDouble(MaxValidMagnitude);
2536 }
2537 if (HasDropMagnitude) {
2538 output.WriteRawTag(185, 4);
2539 output.WriteDouble(DropMagnitude);
2540 }
2541 if (_unknownFields != null) {
2542 _unknownFields.WriteTo(output);
2543 }
2544 #endif
2545 }
2546
2547 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2548 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2549 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2550 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
2551 if (HasFeasibilityRule) {
2552 output.WriteRawTag(8);
2553 output.WriteEnum((int) FeasibilityRule);
2554 }
2555 if (HasOptimizationRule) {
2556 output.WriteRawTag(16);
2557 output.WriteEnum((int) OptimizationRule);
2558 }
2559 if (HasRefactorizationThreshold) {
2560 output.WriteRawTag(49);
2561 output.WriteDouble(RefactorizationThreshold);
2562 }
2563 if (HasRecomputeReducedCostsThreshold) {
2564 output.WriteRawTag(65);
2565 output.WriteDouble(RecomputeReducedCostsThreshold);
2566 }
2567 if (HasRecomputeEdgesNormThreshold) {
2568 output.WriteRawTag(73);
2569 output.WriteDouble(RecomputeEdgesNormThreshold);
2570 }
2571 if (HasPrimalFeasibilityTolerance) {
2572 output.WriteRawTag(81);
2573 output.WriteDouble(PrimalFeasibilityTolerance);
2574 }
2575 if (HasDualFeasibilityTolerance) {
2576 output.WriteRawTag(89);
2577 output.WriteDouble(DualFeasibilityTolerance);
2578 }
2579 if (HasRatioTestZeroThreshold) {
2580 output.WriteRawTag(97);
2581 output.WriteDouble(RatioTestZeroThreshold);
2582 }
2583 if (HasHarrisToleranceRatio) {
2584 output.WriteRawTag(105);
2585 output.WriteDouble(HarrisToleranceRatio);
2586 }
2587 if (HasSmallPivotThreshold) {
2588 output.WriteRawTag(113);
2589 output.WriteDouble(SmallPivotThreshold);
2590 }
2591 if (HasMinimumAcceptablePivot) {
2592 output.WriteRawTag(121);
2593 output.WriteDouble(MinimumAcceptablePivot);
2594 }
2595 if (HasUseScaling) {
2596 output.WriteRawTag(128, 1);
2597 output.WriteBool(UseScaling);
2598 }
2599 if (HasInitialBasis) {
2600 output.WriteRawTag(136, 1);
2601 output.WriteEnum((int) InitialBasis);
2602 }
2603 if (HasUseTransposedMatrix) {
2604 output.WriteRawTag(144, 1);
2605 output.WriteBool(UseTransposedMatrix);
2606 }
2607 if (HasBasisRefactorizationPeriod) {
2608 output.WriteRawTag(152, 1);
2609 output.WriteInt32(BasisRefactorizationPeriod);
2610 }
2611 if (HasSolveDualProblem) {
2612 output.WriteRawTag(160, 1);
2613 output.WriteEnum((int) SolveDualProblem);
2614 }
2615 if (HasDualizerThreshold) {
2616 output.WriteRawTag(169, 1);
2617 output.WriteDouble(DualizerThreshold);
2618 }
2619 if (HasSolutionFeasibilityTolerance) {
2620 output.WriteRawTag(177, 1);
2621 output.WriteDouble(SolutionFeasibilityTolerance);
2622 }
2623 if (HasProvideStrongOptimalGuarantee) {
2624 output.WriteRawTag(192, 1);
2625 output.WriteBool(ProvideStrongOptimalGuarantee);
2626 }
2627 if (HasLuFactorizationPivotThreshold) {
2628 output.WriteRawTag(201, 1);
2629 output.WriteDouble(LuFactorizationPivotThreshold);
2630 }
2631 if (HasMaxTimeInSeconds) {
2632 output.WriteRawTag(209, 1);
2633 output.WriteDouble(MaxTimeInSeconds);
2634 }
2635 if (HasMaxNumberOfIterations) {
2636 output.WriteRawTag(216, 1);
2637 output.WriteInt64(MaxNumberOfIterations);
2638 }
2639 if (HasMarkowitzZlatevParameter) {
2640 output.WriteRawTag(232, 1);
2641 output.WriteInt32(MarkowitzZlatevParameter);
2642 }
2643 if (HasMarkowitzSingularityThreshold) {
2644 output.WriteRawTag(241, 1);
2645 output.WriteDouble(MarkowitzSingularityThreshold);
2646 }
2647 if (HasUseDualSimplex) {
2648 output.WriteRawTag(248, 1);
2649 output.WriteBool(UseDualSimplex);
2650 }
2651 if (HasAllowSimplexAlgorithmChange) {
2652 output.WriteRawTag(128, 2);
2653 output.WriteBool(AllowSimplexAlgorithmChange);
2654 }
2655 if (HasDevexWeightsResetPeriod) {
2656 output.WriteRawTag(136, 2);
2657 output.WriteInt32(DevexWeightsResetPeriod);
2658 }
2659 if (HasUsePreprocessing) {
2660 output.WriteRawTag(144, 2);
2661 output.WriteBool(UsePreprocessing);
2662 }
2663 if (HasUseMiddleProductFormUpdate) {
2664 output.WriteRawTag(152, 2);
2665 output.WriteBool(UseMiddleProductFormUpdate);
2666 }
2667 if (HasInitializeDevexWithColumnNorms) {
2668 output.WriteRawTag(160, 2);
2669 output.WriteBool(InitializeDevexWithColumnNorms);
2670 }
2671 if (HasExploitSingletonColumnInInitialBasis) {
2672 output.WriteRawTag(168, 2);
2673 output.WriteBool(ExploitSingletonColumnInInitialBasis);
2674 }
2675 if (HasDualSmallPivotThreshold) {
2676 output.WriteRawTag(177, 2);
2677 output.WriteDouble(DualSmallPivotThreshold);
2678 }
2679 if (HasPreprocessorZeroTolerance) {
2680 output.WriteRawTag(185, 2);
2681 output.WriteDouble(PreprocessorZeroTolerance);
2682 }
2683 if (HasObjectiveLowerLimit) {
2684 output.WriteRawTag(193, 2);
2685 output.WriteDouble(ObjectiveLowerLimit);
2686 }
2687 if (HasObjectiveUpperLimit) {
2688 output.WriteRawTag(201, 2);
2689 output.WriteDouble(ObjectiveUpperLimit);
2690 }
2691 if (HasDegenerateMinistepFactor) {
2692 output.WriteRawTag(209, 2);
2693 output.WriteDouble(DegenerateMinistepFactor);
2694 }
2695 if (HasRandomSeed) {
2696 output.WriteRawTag(216, 2);
2697 output.WriteInt32(RandomSeed);
2698 }
2699 if (HasNumOmpThreads) {
2700 output.WriteRawTag(224, 2);
2701 output.WriteInt32(NumOmpThreads);
2702 }
2703 if (HasMaxDeterministicTime) {
2704 output.WriteRawTag(233, 2);
2705 output.WriteDouble(MaxDeterministicTime);
2706 }
2707 if (HasDropTolerance) {
2708 output.WriteRawTag(161, 3);
2709 output.WriteDouble(DropTolerance);
2710 }
2711 if (HasPerturbCostsInDualSimplex) {
2712 output.WriteRawTag(168, 3);
2713 output.WriteBool(PerturbCostsInDualSimplex);
2714 }
2715 if (HasRelativeCostPerturbation) {
2716 output.WriteRawTag(177, 3);
2717 output.WriteDouble(RelativeCostPerturbation);
2718 }
2719 if (HasRelativeMaxCostPerturbation) {
2720 output.WriteRawTag(185, 3);
2721 output.WriteDouble(RelativeMaxCostPerturbation);
2722 }
2723 if (HasMaxNumberOfReoptimizations) {
2724 output.WriteRawTag(193, 3);
2725 output.WriteDouble(MaxNumberOfReoptimizations);
2726 }
2727 if (HasScalingMethod) {
2728 output.WriteRawTag(200, 3);
2729 output.WriteEnum((int) ScalingMethod);
2730 }
2731 if (HasChangeStatusToImprecise) {
2732 output.WriteRawTag(208, 3);
2733 output.WriteBool(ChangeStatusToImprecise);
2734 }
2735 if (HasInitialConditionNumberThreshold) {
2736 output.WriteRawTag(217, 3);
2737 output.WriteDouble(InitialConditionNumberThreshold);
2738 }
2739 if (HasCostScaling) {
2740 output.WriteRawTag(224, 3);
2741 output.WriteEnum((int) CostScaling);
2742 }
2743 if (HasLogSearchProgress) {
2744 output.WriteRawTag(232, 3);
2745 output.WriteBool(LogSearchProgress);
2746 }
2747 if (HasUseDedicatedDualFeasibilityAlgorithm) {
2748 output.WriteRawTag(240, 3);
2749 output.WriteBool(UseDedicatedDualFeasibilityAlgorithm);
2750 }
2751 if (HasDynamicallyAdjustRefactorizationPeriod) {
2752 output.WriteRawTag(248, 3);
2753 output.WriteBool(DynamicallyAdjustRefactorizationPeriod);
2754 }
2755 if (HasCrossoverBoundSnappingDistance) {
2756 output.WriteRawTag(129, 4);
2757 output.WriteDouble(CrossoverBoundSnappingDistance);
2758 }
2759 if (HasPushToVertex) {
2760 output.WriteRawTag(136, 4);
2761 output.WriteBool(PushToVertex);
2762 }
2763 if (HasLogToStdout) {
2764 output.WriteRawTag(144, 4);
2765 output.WriteBool(LogToStdout);
2766 }
2767 if (HasUseImpliedFreePreprocessor) {
2768 output.WriteRawTag(152, 4);
2769 output.WriteBool(UseImpliedFreePreprocessor);
2770 }
2771 if (HasDualPricePrioritizeNorm) {
2772 output.WriteRawTag(168, 4);
2773 output.WriteBool(DualPricePrioritizeNorm);
2774 }
2775 if (HasMaxValidMagnitude) {
2776 output.WriteRawTag(177, 4);
2777 output.WriteDouble(MaxValidMagnitude);
2778 }
2779 if (HasDropMagnitude) {
2780 output.WriteRawTag(185, 4);
2781 output.WriteDouble(DropMagnitude);
2782 }
2783 if (_unknownFields != null) {
2784 _unknownFields.WriteTo(ref output);
2785 }
2786 }
2787 #endif
2788
2789 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2790 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2791 public int CalculateSize() {
2792 int size = 0;
2793 if (HasScalingMethod) {
2794 size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) ScalingMethod);
2795 }
2796 if (HasFeasibilityRule) {
2797 size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) FeasibilityRule);
2798 }
2799 if (HasOptimizationRule) {
2800 size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) OptimizationRule);
2801 }
2802 if (HasRefactorizationThreshold) {
2803 size += 1 + 8;
2804 }
2805 if (HasRecomputeReducedCostsThreshold) {
2806 size += 1 + 8;
2807 }
2808 if (HasRecomputeEdgesNormThreshold) {
2809 size += 1 + 8;
2810 }
2811 if (HasPrimalFeasibilityTolerance) {
2812 size += 1 + 8;
2813 }
2814 if (HasDualFeasibilityTolerance) {
2815 size += 1 + 8;
2816 }
2817 if (HasRatioTestZeroThreshold) {
2818 size += 1 + 8;
2819 }
2820 if (HasHarrisToleranceRatio) {
2821 size += 1 + 8;
2822 }
2823 if (HasSmallPivotThreshold) {
2824 size += 1 + 8;
2825 }
2826 if (HasMinimumAcceptablePivot) {
2827 size += 1 + 8;
2828 }
2829 if (HasDropTolerance) {
2830 size += 2 + 8;
2831 }
2832 if (HasUseScaling) {
2833 size += 2 + 1;
2834 }
2835 if (HasCostScaling) {
2836 size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) CostScaling);
2837 }
2838 if (HasInitialBasis) {
2839 size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) InitialBasis);
2840 }
2841 if (HasUseTransposedMatrix) {
2842 size += 2 + 1;
2843 }
2844 if (HasBasisRefactorizationPeriod) {
2845 size += 2 + pb::CodedOutputStream.ComputeInt32Size(BasisRefactorizationPeriod);
2846 }
2847 if (HasDynamicallyAdjustRefactorizationPeriod) {
2848 size += 2 + 1;
2849 }
2850 if (HasSolveDualProblem) {
2851 size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) SolveDualProblem);
2852 }
2853 if (HasDualizerThreshold) {
2854 size += 2 + 8;
2855 }
2856 if (HasSolutionFeasibilityTolerance) {
2857 size += 2 + 8;
2858 }
2859 if (HasProvideStrongOptimalGuarantee) {
2860 size += 2 + 1;
2861 }
2862 if (HasChangeStatusToImprecise) {
2863 size += 2 + 1;
2864 }
2865 if (HasMaxNumberOfReoptimizations) {
2866 size += 2 + 8;
2867 }
2868 if (HasLuFactorizationPivotThreshold) {
2869 size += 2 + 8;
2870 }
2871 if (HasMaxTimeInSeconds) {
2872 size += 2 + 8;
2873 }
2874 if (HasMaxDeterministicTime) {
2875 size += 2 + 8;
2876 }
2877 if (HasMaxNumberOfIterations) {
2878 size += 2 + pb::CodedOutputStream.ComputeInt64Size(MaxNumberOfIterations);
2879 }
2880 if (HasMarkowitzZlatevParameter) {
2881 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MarkowitzZlatevParameter);
2882 }
2883 if (HasMarkowitzSingularityThreshold) {
2884 size += 2 + 8;
2885 }
2886 if (HasUseDualSimplex) {
2887 size += 2 + 1;
2888 }
2889 if (HasAllowSimplexAlgorithmChange) {
2890 size += 2 + 1;
2891 }
2892 if (HasDevexWeightsResetPeriod) {
2893 size += 2 + pb::CodedOutputStream.ComputeInt32Size(DevexWeightsResetPeriod);
2894 }
2895 if (HasUsePreprocessing) {
2896 size += 2 + 1;
2897 }
2898 if (HasUseMiddleProductFormUpdate) {
2899 size += 2 + 1;
2900 }
2901 if (HasInitializeDevexWithColumnNorms) {
2902 size += 2 + 1;
2903 }
2904 if (HasExploitSingletonColumnInInitialBasis) {
2905 size += 2 + 1;
2906 }
2907 if (HasDualSmallPivotThreshold) {
2908 size += 2 + 8;
2909 }
2910 if (HasPreprocessorZeroTolerance) {
2911 size += 2 + 8;
2912 }
2913 if (HasObjectiveLowerLimit) {
2914 size += 2 + 8;
2915 }
2916 if (HasObjectiveUpperLimit) {
2917 size += 2 + 8;
2918 }
2919 if (HasDegenerateMinistepFactor) {
2920 size += 2 + 8;
2921 }
2922 if (HasRandomSeed) {
2923 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RandomSeed);
2924 }
2925 if (HasNumOmpThreads) {
2926 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumOmpThreads);
2927 }
2928 if (HasPerturbCostsInDualSimplex) {
2929 size += 2 + 1;
2930 }
2931 if (HasUseDedicatedDualFeasibilityAlgorithm) {
2932 size += 2 + 1;
2933 }
2934 if (HasRelativeCostPerturbation) {
2935 size += 2 + 8;
2936 }
2937 if (HasRelativeMaxCostPerturbation) {
2938 size += 2 + 8;
2939 }
2940 if (HasInitialConditionNumberThreshold) {
2941 size += 2 + 8;
2942 }
2943 if (HasLogSearchProgress) {
2944 size += 2 + 1;
2945 }
2946 if (HasLogToStdout) {
2947 size += 2 + 1;
2948 }
2949 if (HasCrossoverBoundSnappingDistance) {
2950 size += 2 + 8;
2951 }
2952 if (HasPushToVertex) {
2953 size += 2 + 1;
2954 }
2955 if (HasUseImpliedFreePreprocessor) {
2956 size += 2 + 1;
2957 }
2958 if (HasMaxValidMagnitude) {
2959 size += 2 + 8;
2960 }
2961 if (HasDropMagnitude) {
2962 size += 2 + 8;
2963 }
2964 if (HasDualPricePrioritizeNorm) {
2965 size += 2 + 1;
2966 }
2967 if (_unknownFields != null) {
2968 size += _unknownFields.CalculateSize();
2969 }
2970 return size;
2971 }
2972
2973 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2974 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
2975 public void MergeFrom(GlopParameters other) {
2976 if (other == null) {
2977 return;
2978 }
2979 if (other.HasScalingMethod) {
2980 ScalingMethod = other.ScalingMethod;
2981 }
2982 if (other.HasFeasibilityRule) {
2983 FeasibilityRule = other.FeasibilityRule;
2984 }
2985 if (other.HasOptimizationRule) {
2986 OptimizationRule = other.OptimizationRule;
2987 }
2988 if (other.HasRefactorizationThreshold) {
2989 RefactorizationThreshold = other.RefactorizationThreshold;
2990 }
2991 if (other.HasRecomputeReducedCostsThreshold) {
2992 RecomputeReducedCostsThreshold = other.RecomputeReducedCostsThreshold;
2993 }
2994 if (other.HasRecomputeEdgesNormThreshold) {
2995 RecomputeEdgesNormThreshold = other.RecomputeEdgesNormThreshold;
2996 }
2997 if (other.HasPrimalFeasibilityTolerance) {
2998 PrimalFeasibilityTolerance = other.PrimalFeasibilityTolerance;
2999 }
3000 if (other.HasDualFeasibilityTolerance) {
3001 DualFeasibilityTolerance = other.DualFeasibilityTolerance;
3002 }
3003 if (other.HasRatioTestZeroThreshold) {
3004 RatioTestZeroThreshold = other.RatioTestZeroThreshold;
3005 }
3006 if (other.HasHarrisToleranceRatio) {
3007 HarrisToleranceRatio = other.HarrisToleranceRatio;
3008 }
3009 if (other.HasSmallPivotThreshold) {
3010 SmallPivotThreshold = other.SmallPivotThreshold;
3011 }
3012 if (other.HasMinimumAcceptablePivot) {
3013 MinimumAcceptablePivot = other.MinimumAcceptablePivot;
3014 }
3015 if (other.HasDropTolerance) {
3016 DropTolerance = other.DropTolerance;
3017 }
3018 if (other.HasUseScaling) {
3019 UseScaling = other.UseScaling;
3020 }
3021 if (other.HasCostScaling) {
3022 CostScaling = other.CostScaling;
3023 }
3024 if (other.HasInitialBasis) {
3025 InitialBasis = other.InitialBasis;
3026 }
3027 if (other.HasUseTransposedMatrix) {
3028 UseTransposedMatrix = other.UseTransposedMatrix;
3029 }
3030 if (other.HasBasisRefactorizationPeriod) {
3031 BasisRefactorizationPeriod = other.BasisRefactorizationPeriod;
3032 }
3033 if (other.HasDynamicallyAdjustRefactorizationPeriod) {
3034 DynamicallyAdjustRefactorizationPeriod = other.DynamicallyAdjustRefactorizationPeriod;
3035 }
3036 if (other.HasSolveDualProblem) {
3037 SolveDualProblem = other.SolveDualProblem;
3038 }
3039 if (other.HasDualizerThreshold) {
3040 DualizerThreshold = other.DualizerThreshold;
3041 }
3042 if (other.HasSolutionFeasibilityTolerance) {
3043 SolutionFeasibilityTolerance = other.SolutionFeasibilityTolerance;
3044 }
3045 if (other.HasProvideStrongOptimalGuarantee) {
3046 ProvideStrongOptimalGuarantee = other.ProvideStrongOptimalGuarantee;
3047 }
3048 if (other.HasChangeStatusToImprecise) {
3049 ChangeStatusToImprecise = other.ChangeStatusToImprecise;
3050 }
3051 if (other.HasMaxNumberOfReoptimizations) {
3052 MaxNumberOfReoptimizations = other.MaxNumberOfReoptimizations;
3053 }
3054 if (other.HasLuFactorizationPivotThreshold) {
3055 LuFactorizationPivotThreshold = other.LuFactorizationPivotThreshold;
3056 }
3057 if (other.HasMaxTimeInSeconds) {
3058 MaxTimeInSeconds = other.MaxTimeInSeconds;
3059 }
3060 if (other.HasMaxDeterministicTime) {
3061 MaxDeterministicTime = other.MaxDeterministicTime;
3062 }
3063 if (other.HasMaxNumberOfIterations) {
3064 MaxNumberOfIterations = other.MaxNumberOfIterations;
3065 }
3066 if (other.HasMarkowitzZlatevParameter) {
3067 MarkowitzZlatevParameter = other.MarkowitzZlatevParameter;
3068 }
3069 if (other.HasMarkowitzSingularityThreshold) {
3070 MarkowitzSingularityThreshold = other.MarkowitzSingularityThreshold;
3071 }
3072 if (other.HasUseDualSimplex) {
3073 UseDualSimplex = other.UseDualSimplex;
3074 }
3075 if (other.HasAllowSimplexAlgorithmChange) {
3076 AllowSimplexAlgorithmChange = other.AllowSimplexAlgorithmChange;
3077 }
3078 if (other.HasDevexWeightsResetPeriod) {
3079 DevexWeightsResetPeriod = other.DevexWeightsResetPeriod;
3080 }
3081 if (other.HasUsePreprocessing) {
3082 UsePreprocessing = other.UsePreprocessing;
3083 }
3084 if (other.HasUseMiddleProductFormUpdate) {
3085 UseMiddleProductFormUpdate = other.UseMiddleProductFormUpdate;
3086 }
3087 if (other.HasInitializeDevexWithColumnNorms) {
3088 InitializeDevexWithColumnNorms = other.InitializeDevexWithColumnNorms;
3089 }
3090 if (other.HasExploitSingletonColumnInInitialBasis) {
3091 ExploitSingletonColumnInInitialBasis = other.ExploitSingletonColumnInInitialBasis;
3092 }
3093 if (other.HasDualSmallPivotThreshold) {
3094 DualSmallPivotThreshold = other.DualSmallPivotThreshold;
3095 }
3096 if (other.HasPreprocessorZeroTolerance) {
3097 PreprocessorZeroTolerance = other.PreprocessorZeroTolerance;
3098 }
3099 if (other.HasObjectiveLowerLimit) {
3100 ObjectiveLowerLimit = other.ObjectiveLowerLimit;
3101 }
3102 if (other.HasObjectiveUpperLimit) {
3103 ObjectiveUpperLimit = other.ObjectiveUpperLimit;
3104 }
3105 if (other.HasDegenerateMinistepFactor) {
3106 DegenerateMinistepFactor = other.DegenerateMinistepFactor;
3107 }
3108 if (other.HasRandomSeed) {
3109 RandomSeed = other.RandomSeed;
3110 }
3111 if (other.HasNumOmpThreads) {
3112 NumOmpThreads = other.NumOmpThreads;
3113 }
3114 if (other.HasPerturbCostsInDualSimplex) {
3115 PerturbCostsInDualSimplex = other.PerturbCostsInDualSimplex;
3116 }
3117 if (other.HasUseDedicatedDualFeasibilityAlgorithm) {
3118 UseDedicatedDualFeasibilityAlgorithm = other.UseDedicatedDualFeasibilityAlgorithm;
3119 }
3120 if (other.HasRelativeCostPerturbation) {
3121 RelativeCostPerturbation = other.RelativeCostPerturbation;
3122 }
3123 if (other.HasRelativeMaxCostPerturbation) {
3124 RelativeMaxCostPerturbation = other.RelativeMaxCostPerturbation;
3125 }
3126 if (other.HasInitialConditionNumberThreshold) {
3127 InitialConditionNumberThreshold = other.InitialConditionNumberThreshold;
3128 }
3129 if (other.HasLogSearchProgress) {
3130 LogSearchProgress = other.LogSearchProgress;
3131 }
3132 if (other.HasLogToStdout) {
3133 LogToStdout = other.LogToStdout;
3134 }
3135 if (other.HasCrossoverBoundSnappingDistance) {
3136 CrossoverBoundSnappingDistance = other.CrossoverBoundSnappingDistance;
3137 }
3138 if (other.HasPushToVertex) {
3139 PushToVertex = other.PushToVertex;
3140 }
3141 if (other.HasUseImpliedFreePreprocessor) {
3142 UseImpliedFreePreprocessor = other.UseImpliedFreePreprocessor;
3143 }
3144 if (other.HasMaxValidMagnitude) {
3145 MaxValidMagnitude = other.MaxValidMagnitude;
3146 }
3147 if (other.HasDropMagnitude) {
3148 DropMagnitude = other.DropMagnitude;
3149 }
3150 if (other.HasDualPricePrioritizeNorm) {
3151 DualPricePrioritizeNorm = other.DualPricePrioritizeNorm;
3152 }
3153 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
3154 }
3155
3156 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3157 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
3158 public void MergeFrom(pb::CodedInputStream input) {
3159 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3160 input.ReadRawMessage(this);
3161 #else
3162 uint tag;
3163 while ((tag = input.ReadTag()) != 0) {
3164 switch(tag) {
3165 default:
3166 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
3167 break;
3168 case 8: {
3169 FeasibilityRule = (global::Google.OrTools.Glop.GlopParameters.Types.PricingRule) input.ReadEnum();
3170 break;
3171 }
3172 case 16: {
3173 OptimizationRule = (global::Google.OrTools.Glop.GlopParameters.Types.PricingRule) input.ReadEnum();
3174 break;
3175 }
3176 case 49: {
3177 RefactorizationThreshold = input.ReadDouble();
3178 break;
3179 }
3180 case 65: {
3181 RecomputeReducedCostsThreshold = input.ReadDouble();
3182 break;
3183 }
3184 case 73: {
3185 RecomputeEdgesNormThreshold = input.ReadDouble();
3186 break;
3187 }
3188 case 81: {
3189 PrimalFeasibilityTolerance = input.ReadDouble();
3190 break;
3191 }
3192 case 89: {
3193 DualFeasibilityTolerance = input.ReadDouble();
3194 break;
3195 }
3196 case 97: {
3197 RatioTestZeroThreshold = input.ReadDouble();
3198 break;
3199 }
3200 case 105: {
3201 HarrisToleranceRatio = input.ReadDouble();
3202 break;
3203 }
3204 case 113: {
3205 SmallPivotThreshold = input.ReadDouble();
3206 break;
3207 }
3208 case 121: {
3209 MinimumAcceptablePivot = input.ReadDouble();
3210 break;
3211 }
3212 case 128: {
3213 UseScaling = input.ReadBool();
3214 break;
3215 }
3216 case 136: {
3217 InitialBasis = (global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic) input.ReadEnum();
3218 break;
3219 }
3220 case 144: {
3221 UseTransposedMatrix = input.ReadBool();
3222 break;
3223 }
3224 case 152: {
3225 BasisRefactorizationPeriod = input.ReadInt32();
3226 break;
3227 }
3228 case 160: {
3229 SolveDualProblem = (global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior) input.ReadEnum();
3230 break;
3231 }
3232 case 169: {
3233 DualizerThreshold = input.ReadDouble();
3234 break;
3235 }
3236 case 177: {
3237 SolutionFeasibilityTolerance = input.ReadDouble();
3238 break;
3239 }
3240 case 192: {
3241 ProvideStrongOptimalGuarantee = input.ReadBool();
3242 break;
3243 }
3244 case 201: {
3245 LuFactorizationPivotThreshold = input.ReadDouble();
3246 break;
3247 }
3248 case 209: {
3249 MaxTimeInSeconds = input.ReadDouble();
3250 break;
3251 }
3252 case 216: {
3253 MaxNumberOfIterations = input.ReadInt64();
3254 break;
3255 }
3256 case 232: {
3257 MarkowitzZlatevParameter = input.ReadInt32();
3258 break;
3259 }
3260 case 241: {
3261 MarkowitzSingularityThreshold = input.ReadDouble();
3262 break;
3263 }
3264 case 248: {
3265 UseDualSimplex = input.ReadBool();
3266 break;
3267 }
3268 case 256: {
3269 AllowSimplexAlgorithmChange = input.ReadBool();
3270 break;
3271 }
3272 case 264: {
3273 DevexWeightsResetPeriod = input.ReadInt32();
3274 break;
3275 }
3276 case 272: {
3277 UsePreprocessing = input.ReadBool();
3278 break;
3279 }
3280 case 280: {
3281 UseMiddleProductFormUpdate = input.ReadBool();
3282 break;
3283 }
3284 case 288: {
3285 InitializeDevexWithColumnNorms = input.ReadBool();
3286 break;
3287 }
3288 case 296: {
3289 ExploitSingletonColumnInInitialBasis = input.ReadBool();
3290 break;
3291 }
3292 case 305: {
3293 DualSmallPivotThreshold = input.ReadDouble();
3294 break;
3295 }
3296 case 313: {
3297 PreprocessorZeroTolerance = input.ReadDouble();
3298 break;
3299 }
3300 case 321: {
3301 ObjectiveLowerLimit = input.ReadDouble();
3302 break;
3303 }
3304 case 329: {
3305 ObjectiveUpperLimit = input.ReadDouble();
3306 break;
3307 }
3308 case 337: {
3309 DegenerateMinistepFactor = input.ReadDouble();
3310 break;
3311 }
3312 case 344: {
3313 RandomSeed = input.ReadInt32();
3314 break;
3315 }
3316 case 352: {
3317 NumOmpThreads = input.ReadInt32();
3318 break;
3319 }
3320 case 361: {
3321 MaxDeterministicTime = input.ReadDouble();
3322 break;
3323 }
3324 case 417: {
3325 DropTolerance = input.ReadDouble();
3326 break;
3327 }
3328 case 424: {
3329 PerturbCostsInDualSimplex = input.ReadBool();
3330 break;
3331 }
3332 case 433: {
3333 RelativeCostPerturbation = input.ReadDouble();
3334 break;
3335 }
3336 case 441: {
3337 RelativeMaxCostPerturbation = input.ReadDouble();
3338 break;
3339 }
3340 case 449: {
3341 MaxNumberOfReoptimizations = input.ReadDouble();
3342 break;
3343 }
3344 case 456: {
3345 ScalingMethod = (global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm) input.ReadEnum();
3346 break;
3347 }
3348 case 464: {
3349 ChangeStatusToImprecise = input.ReadBool();
3350 break;
3351 }
3352 case 473: {
3353 InitialConditionNumberThreshold = input.ReadDouble();
3354 break;
3355 }
3356 case 480: {
3357 CostScaling = (global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm) input.ReadEnum();
3358 break;
3359 }
3360 case 488: {
3361 LogSearchProgress = input.ReadBool();
3362 break;
3363 }
3364 case 496: {
3365 UseDedicatedDualFeasibilityAlgorithm = input.ReadBool();
3366 break;
3367 }
3368 case 504: {
3369 DynamicallyAdjustRefactorizationPeriod = input.ReadBool();
3370 break;
3371 }
3372 case 513: {
3373 CrossoverBoundSnappingDistance = input.ReadDouble();
3374 break;
3375 }
3376 case 520: {
3377 PushToVertex = input.ReadBool();
3378 break;
3379 }
3380 case 528: {
3381 LogToStdout = input.ReadBool();
3382 break;
3383 }
3384 case 536: {
3385 UseImpliedFreePreprocessor = input.ReadBool();
3386 break;
3387 }
3388 case 552: {
3389 DualPricePrioritizeNorm = input.ReadBool();
3390 break;
3391 }
3392 case 561: {
3393 MaxValidMagnitude = input.ReadDouble();
3394 break;
3395 }
3396 case 569: {
3397 DropMagnitude = input.ReadDouble();
3398 break;
3399 }
3400 }
3401 }
3402 #endif
3403 }
3404
3405 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3406 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3407 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
3408 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
3409 uint tag;
3410 while ((tag = input.ReadTag()) != 0) {
3411 switch(tag) {
3412 default:
3413 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
3414 break;
3415 case 8: {
3416 FeasibilityRule = (global::Google.OrTools.Glop.GlopParameters.Types.PricingRule) input.ReadEnum();
3417 break;
3418 }
3419 case 16: {
3420 OptimizationRule = (global::Google.OrTools.Glop.GlopParameters.Types.PricingRule) input.ReadEnum();
3421 break;
3422 }
3423 case 49: {
3424 RefactorizationThreshold = input.ReadDouble();
3425 break;
3426 }
3427 case 65: {
3428 RecomputeReducedCostsThreshold = input.ReadDouble();
3429 break;
3430 }
3431 case 73: {
3432 RecomputeEdgesNormThreshold = input.ReadDouble();
3433 break;
3434 }
3435 case 81: {
3436 PrimalFeasibilityTolerance = input.ReadDouble();
3437 break;
3438 }
3439 case 89: {
3440 DualFeasibilityTolerance = input.ReadDouble();
3441 break;
3442 }
3443 case 97: {
3444 RatioTestZeroThreshold = input.ReadDouble();
3445 break;
3446 }
3447 case 105: {
3448 HarrisToleranceRatio = input.ReadDouble();
3449 break;
3450 }
3451 case 113: {
3452 SmallPivotThreshold = input.ReadDouble();
3453 break;
3454 }
3455 case 121: {
3456 MinimumAcceptablePivot = input.ReadDouble();
3457 break;
3458 }
3459 case 128: {
3460 UseScaling = input.ReadBool();
3461 break;
3462 }
3463 case 136: {
3464 InitialBasis = (global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic) input.ReadEnum();
3465 break;
3466 }
3467 case 144: {
3468 UseTransposedMatrix = input.ReadBool();
3469 break;
3470 }
3471 case 152: {
3472 BasisRefactorizationPeriod = input.ReadInt32();
3473 break;
3474 }
3475 case 160: {
3476 SolveDualProblem = (global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior) input.ReadEnum();
3477 break;
3478 }
3479 case 169: {
3480 DualizerThreshold = input.ReadDouble();
3481 break;
3482 }
3483 case 177: {
3484 SolutionFeasibilityTolerance = input.ReadDouble();
3485 break;
3486 }
3487 case 192: {
3488 ProvideStrongOptimalGuarantee = input.ReadBool();
3489 break;
3490 }
3491 case 201: {
3492 LuFactorizationPivotThreshold = input.ReadDouble();
3493 break;
3494 }
3495 case 209: {
3496 MaxTimeInSeconds = input.ReadDouble();
3497 break;
3498 }
3499 case 216: {
3500 MaxNumberOfIterations = input.ReadInt64();
3501 break;
3502 }
3503 case 232: {
3504 MarkowitzZlatevParameter = input.ReadInt32();
3505 break;
3506 }
3507 case 241: {
3508 MarkowitzSingularityThreshold = input.ReadDouble();
3509 break;
3510 }
3511 case 248: {
3512 UseDualSimplex = input.ReadBool();
3513 break;
3514 }
3515 case 256: {
3516 AllowSimplexAlgorithmChange = input.ReadBool();
3517 break;
3518 }
3519 case 264: {
3520 DevexWeightsResetPeriod = input.ReadInt32();
3521 break;
3522 }
3523 case 272: {
3524 UsePreprocessing = input.ReadBool();
3525 break;
3526 }
3527 case 280: {
3528 UseMiddleProductFormUpdate = input.ReadBool();
3529 break;
3530 }
3531 case 288: {
3532 InitializeDevexWithColumnNorms = input.ReadBool();
3533 break;
3534 }
3535 case 296: {
3536 ExploitSingletonColumnInInitialBasis = input.ReadBool();
3537 break;
3538 }
3539 case 305: {
3540 DualSmallPivotThreshold = input.ReadDouble();
3541 break;
3542 }
3543 case 313: {
3544 PreprocessorZeroTolerance = input.ReadDouble();
3545 break;
3546 }
3547 case 321: {
3548 ObjectiveLowerLimit = input.ReadDouble();
3549 break;
3550 }
3551 case 329: {
3552 ObjectiveUpperLimit = input.ReadDouble();
3553 break;
3554 }
3555 case 337: {
3556 DegenerateMinistepFactor = input.ReadDouble();
3557 break;
3558 }
3559 case 344: {
3560 RandomSeed = input.ReadInt32();
3561 break;
3562 }
3563 case 352: {
3564 NumOmpThreads = input.ReadInt32();
3565 break;
3566 }
3567 case 361: {
3568 MaxDeterministicTime = input.ReadDouble();
3569 break;
3570 }
3571 case 417: {
3572 DropTolerance = input.ReadDouble();
3573 break;
3574 }
3575 case 424: {
3576 PerturbCostsInDualSimplex = input.ReadBool();
3577 break;
3578 }
3579 case 433: {
3580 RelativeCostPerturbation = input.ReadDouble();
3581 break;
3582 }
3583 case 441: {
3584 RelativeMaxCostPerturbation = input.ReadDouble();
3585 break;
3586 }
3587 case 449: {
3588 MaxNumberOfReoptimizations = input.ReadDouble();
3589 break;
3590 }
3591 case 456: {
3592 ScalingMethod = (global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm) input.ReadEnum();
3593 break;
3594 }
3595 case 464: {
3596 ChangeStatusToImprecise = input.ReadBool();
3597 break;
3598 }
3599 case 473: {
3600 InitialConditionNumberThreshold = input.ReadDouble();
3601 break;
3602 }
3603 case 480: {
3604 CostScaling = (global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm) input.ReadEnum();
3605 break;
3606 }
3607 case 488: {
3608 LogSearchProgress = input.ReadBool();
3609 break;
3610 }
3611 case 496: {
3612 UseDedicatedDualFeasibilityAlgorithm = input.ReadBool();
3613 break;
3614 }
3615 case 504: {
3616 DynamicallyAdjustRefactorizationPeriod = input.ReadBool();
3617 break;
3618 }
3619 case 513: {
3620 CrossoverBoundSnappingDistance = input.ReadDouble();
3621 break;
3622 }
3623 case 520: {
3624 PushToVertex = input.ReadBool();
3625 break;
3626 }
3627 case 528: {
3628 LogToStdout = input.ReadBool();
3629 break;
3630 }
3631 case 536: {
3632 UseImpliedFreePreprocessor = input.ReadBool();
3633 break;
3634 }
3635 case 552: {
3636 DualPricePrioritizeNorm = input.ReadBool();
3637 break;
3638 }
3639 case 561: {
3640 MaxValidMagnitude = input.ReadDouble();
3641 break;
3642 }
3643 case 569: {
3644 DropMagnitude = input.ReadDouble();
3645 break;
3646 }
3647 }
3648 }
3649 }
3650 #endif
3651
3652 #region Nested types
3654 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3655 [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
3656 public static partial class Types {
3664 public enum ScalingAlgorithm {
3665 [pbr::OriginalName("DEFAULT")] Default = 0,
3666 [pbr::OriginalName("EQUILIBRATION")] Equilibration = 1,
3667 [pbr::OriginalName("LINEAR_PROGRAM")] LinearProgram = 2,
3668 }
3669
3674 public enum SolverBehavior {
3675 [pbr::OriginalName("ALWAYS_DO")] AlwaysDo = 0,
3676 [pbr::OriginalName("NEVER_DO")] NeverDo = 1,
3677 [pbr::OriginalName("LET_SOLVER_DECIDE")] LetSolverDecide = 2,
3678 }
3679
3683 public enum PricingRule {
3692 [pbr::OriginalName("DANTZIG")] Dantzig = 0,
3698 [pbr::OriginalName("STEEPEST_EDGE")] SteepestEdge = 1,
3703 [pbr::OriginalName("DEVEX")] Devex = 2,
3704 }
3705
3710 public enum InitialBasisHeuristic {
3714 [pbr::OriginalName("NONE")] None = 0,
3723 [pbr::OriginalName("BIXBY")] Bixby = 1,
3731 [pbr::OriginalName("TRIANGULAR")] Triangular = 2,
3737 [pbr::OriginalName("MAROS")] Maros = 3,
3738 }
3739
3747 public enum CostScalingAlgorithm {
3751 [pbr::OriginalName("NO_COST_SCALING")] NoCostScaling = 0,
3757 [pbr::OriginalName("CONTAIN_ONE_COST_SCALING")] ContainOneCostScaling = 1,
3761 [pbr::OriginalName("MEAN_COST_SCALING")] MeanCostScaling = 2,
3765 [pbr::OriginalName("MEDIAN_COST_SCALING")] MedianCostScaling = 3,
3766 }
3767
3768 }
3769 #endregion
3770
3771 }
3772
3773 #endregion
3774
3775}
3776
3777#endregion Designer generated code
pbr
global::Google.Protobuf.Reflection pbr
Definition SetCover.pb.cs:10
scg
global::System.Collections.Generic scg
Definition SetCover.pb.cs:11
pbc
global::Google.Protobuf.Collections pbc
Definition SetCover.pb.cs:9
pb
global::Google.Protobuf pb
Definition SetCover.pb.cs:8
Google.OrTools.Glop.GlopParameters.Types.PricingRule
PricingRule
General strategy used during pricing.
Definition Parameters.pb.cs:3702
Google.OrTools.Glop.GlopParameters.DropMagnitude
double DropMagnitude
Value in the input LP lower than this will be ignored. This is similar to drop_tolerance but more agg...
Definition Parameters.pb.cs:2121
Google.OrTools.Glop.GlopParameters.InitialConditionNumberThreshold
double InitialConditionNumberThreshold
If our upper bound on the condition number of the initial basis (from our heurisitic or a warm start)...
Definition Parameters.pb.cs:1879
Google.OrTools.Glop.GlopParameters.DualSmallPivotThreshold
double DualSmallPivotThreshold
Like small_pivot_threshold but for the dual simplex. This is needed because the dual algorithm does n...
Definition Parameters.pb.cs:1488
Google.OrTools.Glop.GlopParameters.DegenerateMinistepFactor
double DegenerateMinistepFactor
During a degenerate iteration, the more conservative approach is to do a step of length zero (while s...
Definition Parameters.pb.cs:1639
Google.OrTools.Glop.GlopParameters.InitializeDevexWithColumnNorms
bool InitializeDevexWithColumnNorms
Whether we initialize devex weights to 1.0 or to the norms of the matrix columns.
Definition Parameters.pb.cs:1425
Google.OrTools.Glop.GlopParameters.MaxValidMagnitude
double MaxValidMagnitude
Any finite values in the input LP must be below this threshold, otherwise the model will be reported ...
Definition Parameters.pb.cs:2088
Google.OrTools.Glop.GlopParameters.CostScaling
global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm CostScaling
Definition Parameters.pb.cs:698
Google.OrTools.Glop.GlopParameters.SmallPivotThreshold
double SmallPivotThreshold
When we choose the leaving variable, we want to avoid small pivot because they are the less precise a...
Definition Parameters.pb.cs:578
Google.OrTools.Glop.GlopParameters.ClearRefactorizationThreshold
void ClearRefactorizationThreshold()
Clears the value of the "refactorization_threshold" field.
Definition Parameters.pb.cs:337
Google.OrTools.Glop.GlopParameters.DualizerThreshold
double DualizerThreshold
When solve_dual_problem is LET_SOLVER_DECIDE, take the dual if the number of constraints of the probl...
Definition Parameters.pb.cs:891
Google.OrTools.Glop.GlopParameters.SolveDualProblem
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...
Definition Parameters.pb.cs:859
Google.OrTools.Glop.GlopParameters.UseMiddleProductFormUpdate
bool UseMiddleProductFormUpdate
Whether or not to use the middle product form update rather than the standard eta LU update....
Definition Parameters.pb.cs:1394
Google.OrTools.Glop.GlopParameters.InitialBasis
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...
Definition Parameters.pb.cs:729
Google.OrTools.Glop.GlopParameters.ClearScalingMethod
void ClearScalingMethod()
Clears the value of the "scaling_method" field.
Definition Parameters.pb.cs:242
Google.OrTools.Glop.GlopParameters.UseDualSimplex
bool UseDualSimplex
Whether or not we use the dual simplex algorithm instead of the primal.
Definition Parameters.pb.cs:1265
Google.OrTools.Glop.GlopParameters.UseScaling
bool UseScaling
Whether or not we scale the matrix A so that the maximum coefficient on each line and each column is ...
Definition Parameters.pb.cs:671
Google.OrTools.Glop.GlopParameters.UseTransposedMatrix
bool UseTransposedMatrix
Whether or not we keep a transposed version of the matrix A to speed-up the pricing at the cost of ex...
Definition Parameters.pb.cs:761
Google.OrTools.Glop.GlopParameters.ChangeStatusToImprecise
bool ChangeStatusToImprecise
If true, the internal API will change the return status to imprecise if the solution does not respect...
Definition Parameters.pb.cs:1009
Google.OrTools.Glop.GlopParameters.UseDedicatedDualFeasibilityAlgorithm
bool UseDedicatedDualFeasibilityAlgorithm
We have two possible dual phase I algorithms. Both work on an LP that minimize the sum of dual infeas...
Definition Parameters.pb.cs:1787
Google.OrTools.Glop.GlopParameters.PreprocessorZeroTolerance
double PreprocessorZeroTolerance
A floating point tolerance used by the preprocessors. This is used for things like detecting if two c...
Definition Parameters.pb.cs:1524
Google.OrTools.Glop.GlopParameters.RefactorizationThreshold
double RefactorizationThreshold
We estimate the factorization accuracy of B during each pivot by using the fact that we can compute t...
Definition Parameters.pb.cs:321
Google.OrTools.Glop.GlopParameters.DynamicallyAdjustRefactorizationPeriod
bool DynamicallyAdjustRefactorizationPeriod
If this is true, then basis_refactorization_period becomes a lower bound on the number of iterations ...
Definition Parameters.pb.cs:827
Google.OrTools.Glop.GlopParameters.MarkowitzSingularityThreshold
double MarkowitzSingularityThreshold
If a pivot magnitude is smaller than this during the Markowitz LU factorization, then the matrix is a...
Definition Parameters.pb.cs:1235
Google.OrTools.Glop.GlopParameters.MaxTimeInSeconds
double MaxTimeInSeconds
Maximum time allowed in seconds to solve a problem.
Definition Parameters.pb.cs:1105
Google.OrTools.Glop.GlopParameters.ClearFeasibilityRule
void ClearFeasibilityRule()
Clears the value of the "feasibility_rule" field.
Definition Parameters.pb.cs:272
Google.OrTools.Glop.GlopParameters.Descriptor
static pbr::MessageDescriptor Descriptor
Definition Parameters.pb.cs:129
Google.OrTools.Glop.GlopParameters.UseImpliedFreePreprocessor
bool UseImpliedFreePreprocessor
If presolve runs, include the pass that detects implied free variables.
Definition Parameters.pb.cs:2053
Google.OrTools.Glop.GlopParameters.RecomputeReducedCostsThreshold
double RecomputeReducedCostsThreshold
We estimate the accuracy of the iteratively computed reduced costs. If it falls below this threshold,...
Definition Parameters.pb.cs:355
Google.OrTools.Glop.GlopParameters.HarrisToleranceRatio
double HarrisToleranceRatio
This impacts the ratio test and indicates by how much we allow a basic variable value that we move to...
Definition Parameters.pb.cs:545
Google.OrTools.Glop.GlopParameters.MinimumAcceptablePivot
double MinimumAcceptablePivot
We never follow a basis change with a pivot under this threshold.
Definition Parameters.pb.cs:608
Google.OrTools.Glop.GlopParameters.PerturbCostsInDualSimplex
bool PerturbCostsInDualSimplex
When this is true, then the costs are randomly perturbed before the dual simplex is even started....
Definition Parameters.pb.cs:1749
Google.OrTools.Glop.GlopParameters.PushToVertex
bool PushToVertex
If the optimization phases finishes with super-basic variables (i.e., variables that either 1) have b...
Definition Parameters.pb.cs:2023
Google.OrTools.Glop.GlopParameters.ClearRecomputeReducedCostsThreshold
void ClearRecomputeReducedCostsThreshold()
Clears the value of the "recompute_reduced_costs_threshold" field.
Definition Parameters.pb.cs:371
Google.OrTools.Glop.GlopParameters.DropTolerance
double DropTolerance
In order to increase the sparsity of the manipulated vectors, floating point values with a magnitude ...
Definition Parameters.pb.cs:640
Google.OrTools.Glop.GlopParameters.RelativeCostPerturbation
double RelativeCostPerturbation
The magnitude of the cost perturbation is given by RandomIn(1.0, 2.0) * ( relative_cost_perturbation ...
Definition Parameters.pb.cs:1820
Google.OrTools.Glop.GlopParameters.DualFeasibilityTolerance
double DualFeasibilityTolerance
Variables whose reduced costs have an absolute value smaller than this tolerance are not considered a...
Definition Parameters.pb.cs:467
Google.OrTools.Glop.GlopParameters.MaxDeterministicTime
double MaxDeterministicTime
Maximum deterministic time allowed to solve a problem. The deterministic time is more or less correla...
Definition Parameters.pb.cs:1140
Google.OrTools.Glop.GlopParameters.ClearRecomputeEdgesNormThreshold
void ClearRecomputeEdgesNormThreshold()
Clears the value of the "recompute_edges_norm_threshold" field.
Definition Parameters.pb.cs:405
Google.OrTools.Glop.GlopParameters.NumOmpThreads
int NumOmpThreads
Number of threads in the OMP parallel sections. If left to 1, the code will not create any OMP thread...
Definition Parameters.pb.cs:1716
Google.OrTools.Glop.GlopParameters.ScalingMethodFieldNumber
const int ScalingMethodFieldNumber
Field number for the "scaling_method" field.
Definition Parameters.pb.cs:220
Google.OrTools.Glop.GlopParameters.RatioTestZeroThreshold
double RatioTestZeroThreshold
During the primal simplex (resp. dual simplex), the coefficients of the direction (resp....
Definition Parameters.pb.cs:504
Google.OrTools.Glop.GlopParameters.ProvideStrongOptimalGuarantee
bool ProvideStrongOptimalGuarantee
If true, then when the solver returns a solution with an OPTIMAL status, we can guarantee that:
Definition Parameters.pb.cs:978
Google.OrTools.Glop.GlopParameters.ExploitSingletonColumnInInitialBasis
bool ExploitSingletonColumnInInitialBasis
Whether or not we exploit the singleton columns already present in the problem when we create the ini...
Definition Parameters.pb.cs:1456
Google.OrTools.Glop.GlopParameters.GlopParameters
GlopParameters(GlopParameters other)
Definition Parameters.pb.cs:149
Google.OrTools.Glop.GlopParameters.MarkowitzZlatevParameter
int MarkowitzZlatevParameter
How many columns do we look at in the Markowitz pivoting rule to find a good pivot....
Definition Parameters.pb.cs:1202
Google.OrTools.Glop.GlopParameters.BasisRefactorizationPeriod
int BasisRefactorizationPeriod
Number of iterations between two basis refactorizations. Note that various conditions in the algorith...
Definition Parameters.pb.cs:793
Google.OrTools.Glop.GlopParameters.SolutionFeasibilityTolerance
double SolutionFeasibilityTolerance
When the problem status is OPTIMAL, we check the optimality using this relative tolerance and change ...
Definition Parameters.pb.cs:929
Google.OrTools.Glop.GlopParameters.FeasibilityRule
global::Google.OrTools.Glop.GlopParameters.Types.PricingRule FeasibilityRule
PricingRule to use during the feasibility phase.
Definition Parameters.pb.cs:256
Google.OrTools.Glop.GlopParameters.LuFactorizationPivotThreshold
double LuFactorizationPivotThreshold
Threshold for LU-factorization: for stability reasons, the magnitude of the chosen pivot at a given s...
Definition Parameters.pb.cs:1075
Google.OrTools.Glop.GlopParameters.LogToStdout
bool LogToStdout
If true, logs will be displayed to stdout instead of using Google log info.
Definition Parameters.pb.cs:1941
Google.OrTools.Glop.GlopParameters.UsePreprocessing
bool UsePreprocessing
Whether or not we use advanced preprocessing techniques.
Definition Parameters.pb.cs:1358
Google.OrTools.Glop.GlopParameters.PrimalFeasibilityTolerance
double PrimalFeasibilityTolerance
This tolerance indicates by how much we allow the variable values to go out of bounds and still consi...
Definition Parameters.pb.cs:426
Google.OrTools.Glop.GlopParameters.Parser
static pb::MessageParser< GlopParameters > Parser
Definition Parameters.pb.cs:125
Google.OrTools.Glop.GlopParameters.ObjectiveLowerLimit
double ObjectiveLowerLimit
The solver will stop as soon as it has proven that the objective is smaller than objective_lower_limi...
Definition Parameters.pb.cs:1563
Google.OrTools.Glop.GlopParameters.MaxNumberOfReoptimizations
double MaxNumberOfReoptimizations
When the solution of phase II is imprecise, we re-run the phase II with the opposite algorithm from t...
Definition Parameters.pb.cs:1042
Google.OrTools.Glop.GlopParameters.CrossoverBoundSnappingDistance
double CrossoverBoundSnappingDistance
If the starting basis contains FREE variable with bounds, we will move any such variable to their clo...
Definition Parameters.pb.cs:1988
Google.OrTools.Glop.GlopParameters.ScalingMethod
global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm ScalingMethod
Definition Parameters.pb.cs:226
Google.OrTools.Glop.GlopParameters.RandomSeed
int RandomSeed
At the beginning of each solve, the random number generator used in some part of the solver is reinit...
Definition Parameters.pb.cs:1685
Google.OrTools.Glop.GlopParameters.DevexWeightsResetPeriod
int DevexWeightsResetPeriod
Devex weights will be reset to 1.0 after that number of updates.
Definition Parameters.pb.cs:1328
Google.OrTools.Glop.GlopParameters.AllowSimplexAlgorithmChange
bool AllowSimplexAlgorithmChange
During incremental solve, let the solver decide if it use the primal or dual simplex algorithm depend...
Definition Parameters.pb.cs:1298
Google.OrTools.Glop.GlopParameters.MaxNumberOfIterations
long MaxNumberOfIterations
Maximum number of simplex iterations to solve a problem. A value of -1 means no limit.
Definition Parameters.pb.cs:1171
Google.OrTools.Glop.GlopParameters.OptimizationRule
global::Google.OrTools.Glop.GlopParameters.Types.PricingRule OptimizationRule
PricingRule to use during the optimization phase.
Definition Parameters.pb.cs:286
Google.OrTools.Glop.GlopParameters.DualPricePrioritizeNorm
bool DualPricePrioritizeNorm
On some problem like stp3d or pds-100 this makes a huge difference in speed and number of iterations ...
Definition Parameters.pb.cs:2152
Google.OrTools.Glop.GlopParameters.ClearOptimizationRule
void ClearOptimizationRule()
Clears the value of the "optimization_rule" field.
Definition Parameters.pb.cs:302
Google.OrTools.Glop.GlopParameters.LogSearchProgress
bool LogSearchProgress
If true, logs the progress of a solve to LOG(INFO). Note that the same messages can also be turned on...
Definition Parameters.pb.cs:1911
Google.OrTools.Glop.ParametersReflection
Holder for reflection information generated from ortools/glop/parameters.proto.
Definition Parameters.pb.cs:15
Google.OrTools.Glop.ParametersReflection.Descriptor
static pbr::FileDescriptor Descriptor
File descriptor for ortools/glop/parameters.proto.
Definition Parameters.pb.cs:19