116 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
120 private static readonly pb::MessageParser<GlopParameters> _parser =
new pb::MessageParser<GlopParameters>(() =>
new GlopParameters());
121 private pb::UnknownFieldSet _unknownFields;
122 private int _hasBits0;
123 private int _hasBits1;
124 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
125 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
126 public static pb::MessageParser<GlopParameters>
Parser {
get {
return _parser; } }
128 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
129 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
131 get {
return global::Google.OrTools.Glop.ParametersReflection.Descriptor.MessageTypes[0]; }
134 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
135 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
136 pbr::MessageDescriptor pb::IMessage.Descriptor {
140 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
141 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
146 partial
void OnConstruction();
148 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
149 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
151 _hasBits0 = other._hasBits0;
152 _hasBits1 = other._hasBits1;
153 scalingMethod_ = other.scalingMethod_;
154 feasibilityRule_ = other.feasibilityRule_;
155 optimizationRule_ = other.optimizationRule_;
156 refactorizationThreshold_ = other.refactorizationThreshold_;
157 recomputeReducedCostsThreshold_ = other.recomputeReducedCostsThreshold_;
158 recomputeEdgesNormThreshold_ = other.recomputeEdgesNormThreshold_;
159 primalFeasibilityTolerance_ = other.primalFeasibilityTolerance_;
160 dualFeasibilityTolerance_ = other.dualFeasibilityTolerance_;
161 ratioTestZeroThreshold_ = other.ratioTestZeroThreshold_;
162 harrisToleranceRatio_ = other.harrisToleranceRatio_;
163 smallPivotThreshold_ = other.smallPivotThreshold_;
164 minimumAcceptablePivot_ = other.minimumAcceptablePivot_;
165 dropTolerance_ = other.dropTolerance_;
166 useScaling_ = other.useScaling_;
167 costScaling_ = other.costScaling_;
168 initialBasis_ = other.initialBasis_;
169 useTransposedMatrix_ = other.useTransposedMatrix_;
170 basisRefactorizationPeriod_ = other.basisRefactorizationPeriod_;
171 dynamicallyAdjustRefactorizationPeriod_ = other.dynamicallyAdjustRefactorizationPeriod_;
172 solveDualProblem_ = other.solveDualProblem_;
173 dualizerThreshold_ = other.dualizerThreshold_;
174 solutionFeasibilityTolerance_ = other.solutionFeasibilityTolerance_;
175 provideStrongOptimalGuarantee_ = other.provideStrongOptimalGuarantee_;
176 changeStatusToImprecise_ = other.changeStatusToImprecise_;
177 maxNumberOfReoptimizations_ = other.maxNumberOfReoptimizations_;
178 luFactorizationPivotThreshold_ = other.luFactorizationPivotThreshold_;
179 maxTimeInSeconds_ = other.maxTimeInSeconds_;
180 maxDeterministicTime_ = other.maxDeterministicTime_;
181 maxNumberOfIterations_ = other.maxNumberOfIterations_;
182 markowitzZlatevParameter_ = other.markowitzZlatevParameter_;
183 markowitzSingularityThreshold_ = other.markowitzSingularityThreshold_;
184 useDualSimplex_ = other.useDualSimplex_;
185 allowSimplexAlgorithmChange_ = other.allowSimplexAlgorithmChange_;
186 devexWeightsResetPeriod_ = other.devexWeightsResetPeriod_;
187 usePreprocessing_ = other.usePreprocessing_;
188 useMiddleProductFormUpdate_ = other.useMiddleProductFormUpdate_;
189 initializeDevexWithColumnNorms_ = other.initializeDevexWithColumnNorms_;
190 exploitSingletonColumnInInitialBasis_ = other.exploitSingletonColumnInInitialBasis_;
191 dualSmallPivotThreshold_ = other.dualSmallPivotThreshold_;
192 preprocessorZeroTolerance_ = other.preprocessorZeroTolerance_;
193 objectiveLowerLimit_ = other.objectiveLowerLimit_;
194 objectiveUpperLimit_ = other.objectiveUpperLimit_;
195 degenerateMinistepFactor_ = other.degenerateMinistepFactor_;
196 randomSeed_ = other.randomSeed_;
197 useAbslRandom_ = other.useAbslRandom_;
198 numOmpThreads_ = other.numOmpThreads_;
199 perturbCostsInDualSimplex_ = other.perturbCostsInDualSimplex_;
200 useDedicatedDualFeasibilityAlgorithm_ = other.useDedicatedDualFeasibilityAlgorithm_;
201 relativeCostPerturbation_ = other.relativeCostPerturbation_;
202 relativeMaxCostPerturbation_ = other.relativeMaxCostPerturbation_;
203 initialConditionNumberThreshold_ = other.initialConditionNumberThreshold_;
204 logSearchProgress_ = other.logSearchProgress_;
205 logToStdout_ = other.logToStdout_;
206 crossoverBoundSnappingDistance_ = other.crossoverBoundSnappingDistance_;
207 pushToVertex_ = other.pushToVertex_;
208 useImpliedFreePreprocessor_ = other.useImpliedFreePreprocessor_;
209 maxValidMagnitude_ = other.maxValidMagnitude_;
210 dropMagnitude_ = other.dropMagnitude_;
211 dualPricePrioritizeNorm_ = other.dualPricePrioritizeNorm_;
212 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
215 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
216 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
223 private readonly
static global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm ScalingMethodDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm.Equilibration;
225 private global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm scalingMethod_;
226 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
227 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
229 get { if ((_hasBits1 & 4096) != 0) { return scalingMethod_; } else { return ScalingMethodDefaultValue; } }
232 scalingMethod_ = value;
236 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
237 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
239 get {
return (_hasBits1 & 4096) != 0; }
242 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
243 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
250 private readonly
static global::Google.OrTools.Glop.GlopParameters.Types.PricingRule FeasibilityRuleDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.PricingRule.SteepestEdge;
252 private global::Google.OrTools.Glop.GlopParameters.Types.PricingRule feasibilityRule_;
256 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
257 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
259 get { if ((_hasBits0 & 1) != 0) { return feasibilityRule_; } else { return FeasibilityRuleDefaultValue; } }
262 feasibilityRule_ = value;
266 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
267 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
269 get {
return (_hasBits0 & 1) != 0; }
272 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
273 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
280 private readonly
static global::Google.OrTools.Glop.GlopParameters.Types.PricingRule OptimizationRuleDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.PricingRule.SteepestEdge;
282 private global::Google.OrTools.Glop.GlopParameters.Types.PricingRule optimizationRule_;
286 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
287 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
289 get { if ((_hasBits0 & 2) != 0) { return optimizationRule_; } else { return OptimizationRuleDefaultValue; } }
292 optimizationRule_ = value;
296 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
297 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
299 get {
return (_hasBits0 & 2) != 0; }
302 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
303 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
310 private readonly
static double RefactorizationThresholdDefaultValue = 1e-09D;
312 private double refactorizationThreshold_;
321 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
322 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
324 get {
if ((_hasBits0 & 4) != 0) {
return refactorizationThreshold_; }
else {
return RefactorizationThresholdDefaultValue; } }
327 refactorizationThreshold_ = value;
331 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
332 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
334 get {
return (_hasBits0 & 4) != 0; }
337 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
338 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
345 private readonly
static double RecomputeReducedCostsThresholdDefaultValue = 1e-08D;
347 private double recomputeReducedCostsThreshold_;
355 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
356 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
358 get {
if ((_hasBits0 & 8) != 0) {
return recomputeReducedCostsThreshold_; }
else {
return RecomputeReducedCostsThresholdDefaultValue; } }
361 recomputeReducedCostsThreshold_ = value;
365 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
366 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
368 get {
return (_hasBits0 & 8) != 0; }
371 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
372 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
379 private readonly
static double RecomputeEdgesNormThresholdDefaultValue = 100D;
381 private double recomputeEdgesNormThreshold_;
389 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
390 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
392 get {
if ((_hasBits0 & 16) != 0) {
return recomputeEdgesNormThreshold_; }
else {
return RecomputeEdgesNormThresholdDefaultValue; } }
395 recomputeEdgesNormThreshold_ = value;
399 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
400 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
402 get {
return (_hasBits0 & 16) != 0; }
405 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
406 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
413 private readonly
static double PrimalFeasibilityToleranceDefaultValue = 1e-08D;
415 private double primalFeasibilityTolerance_;
425 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
426 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
428 get {
if ((_hasBits0 & 32) != 0) {
return primalFeasibilityTolerance_; }
else {
return PrimalFeasibilityToleranceDefaultValue; } }
431 primalFeasibilityTolerance_ = value;
435 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
436 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
437 public bool HasPrimalFeasibilityTolerance {
438 get {
return (_hasBits0 & 32) != 0; }
441 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
442 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
443 public void ClearPrimalFeasibilityTolerance() {
448 public const int DualFeasibilityToleranceFieldNumber = 11;
449 private readonly
static double DualFeasibilityToleranceDefaultValue = 1e-08D;
451 private double dualFeasibilityTolerance_;
464 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
465 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
467 get {
if ((_hasBits0 & 64) != 0) {
return dualFeasibilityTolerance_; }
else {
return DualFeasibilityToleranceDefaultValue; } }
470 dualFeasibilityTolerance_ = value;
474 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
475 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
476 public bool HasDualFeasibilityTolerance {
477 get {
return (_hasBits0 & 64) != 0; }
480 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
481 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
488 private readonly
static double RatioTestZeroThresholdDefaultValue = 1e-09D;
490 private double ratioTestZeroThreshold_;
500 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
501 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
503 get {
if ((_hasBits0 & 128) != 0) {
return ratioTestZeroThreshold_; }
else {
return RatioTestZeroThresholdDefaultValue; } }
506 ratioTestZeroThreshold_ = value;
510 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
511 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
512 public bool HasRatioTestZeroThreshold {
513 get {
return (_hasBits0 & 128) != 0; }
516 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
517 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
524 private readonly
static double HarrisToleranceRatioDefaultValue = 0.5D;
526 private double harrisToleranceRatio_;
540 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
541 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
543 get {
if ((_hasBits0 & 256) != 0) {
return harrisToleranceRatio_; }
else {
return HarrisToleranceRatioDefaultValue; } }
546 harrisToleranceRatio_ = value;
550 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
551 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
552 public bool HasHarrisToleranceRatio {
553 get {
return (_hasBits0 & 256) != 0; }
556 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
557 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
564 private readonly
static double SmallPivotThresholdDefaultValue = 1e-06D;
566 private double smallPivotThreshold_;
573 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
574 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
576 get {
if ((_hasBits0 & 512) != 0) {
return smallPivotThreshold_; }
else {
return SmallPivotThresholdDefaultValue; } }
579 smallPivotThreshold_ = value;
583 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
584 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
585 public bool HasSmallPivotThreshold {
586 get {
return (_hasBits0 & 512) != 0; }
589 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
590 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
597 private readonly
static double MinimumAcceptablePivotDefaultValue = 1e-06D;
599 private double minimumAcceptablePivot_;
603 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
604 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
606 get {
if ((_hasBits0 & 1024) != 0) {
return minimumAcceptablePivot_; }
else {
return MinimumAcceptablePivotDefaultValue; } }
609 minimumAcceptablePivot_ = value;
613 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
614 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
615 public bool HasMinimumAcceptablePivot {
616 get {
return (_hasBits0 & 1024) != 0; }
619 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
620 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
627 private readonly
static double DropToleranceDefaultValue = 1e-14D;
629 private double dropTolerance_;
635 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
636 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
638 get {
if ((_hasBits1 & 128) != 0) {
return dropTolerance_; }
else {
return DropToleranceDefaultValue; } }
641 dropTolerance_ = value;
645 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
646 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
647 public bool HasDropTolerance {
648 get {
return (_hasBits1 & 128) != 0; }
651 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
652 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
659 private readonly
static bool UseScalingDefaultValue =
true;
661 private bool useScaling_;
666 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
667 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
669 get {
if ((_hasBits0 & 2048) != 0) {
return useScaling_; }
else {
return UseScalingDefaultValue; } }
676 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
677 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
678 public bool HasUseScaling {
679 get {
return (_hasBits0 & 2048) != 0; }
682 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
683 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
690 private readonly
static global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm CostScalingDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm.ContainOneCostScaling;
692 private global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm costScaling_;
693 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
694 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
696 get { if ((_hasBits1 & 32768) != 0) { return costScaling_; } else { return CostScalingDefaultValue; } }
699 costScaling_ = value;
703 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
704 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
705 public bool HasCostScaling {
706 get {
return (_hasBits1 & 32768) != 0; }
709 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
710 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
717 private readonly
static global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic InitialBasisDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic.Triangular;
719 private global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic initialBasis_;
724 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
725 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
727 get { if ((_hasBits0 & 4096) != 0) { return initialBasis_; } else { return InitialBasisDefaultValue; } }
730 initialBasis_ = value;
734 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
735 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
736 public bool HasInitialBasis {
737 get {
return (_hasBits0 & 4096) != 0; }
740 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
741 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
748 private readonly
static bool UseTransposedMatrixDefaultValue =
true;
750 private bool useTransposedMatrix_;
756 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
757 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
759 get {
if ((_hasBits0 & 8192) != 0) {
return useTransposedMatrix_; }
else {
return UseTransposedMatrixDefaultValue; } }
762 useTransposedMatrix_ = value;
766 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
767 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
768 public bool HasUseTransposedMatrix {
769 get {
return (_hasBits0 & 8192) != 0; }
772 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
773 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
780 private readonly
static int BasisRefactorizationPeriodDefaultValue = 64;
782 private int basisRefactorizationPeriod_;
788 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
789 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
791 get {
if ((_hasBits0 & 16384) != 0) {
return basisRefactorizationPeriod_; }
else {
return BasisRefactorizationPeriodDefaultValue; } }
794 basisRefactorizationPeriod_ = value;
798 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
799 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
800 public bool HasBasisRefactorizationPeriod {
801 get {
return (_hasBits0 & 16384) != 0; }
804 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
805 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
812 private readonly
static bool DynamicallyAdjustRefactorizationPeriodDefaultValue =
true;
814 private bool dynamicallyAdjustRefactorizationPeriod_;
822 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
823 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
825 get {
if ((_hasBits1 & 262144) != 0) {
return dynamicallyAdjustRefactorizationPeriod_; }
else {
return DynamicallyAdjustRefactorizationPeriodDefaultValue; } }
828 dynamicallyAdjustRefactorizationPeriod_ = value;
832 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
833 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
834 public bool HasDynamicallyAdjustRefactorizationPeriod {
835 get {
return (_hasBits1 & 262144) != 0; }
838 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
839 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
841 _hasBits1 &= ~262144;
846 private readonly
static global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior SolveDualProblemDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior.LetSolverDecide;
848 private global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior solveDualProblem_;
854 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
855 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
857 get { if ((_hasBits0 & 32768) != 0) { return solveDualProblem_; } else { return SolveDualProblemDefaultValue; } }
860 solveDualProblem_ = value;
864 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
865 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
866 public bool HasSolveDualProblem {
867 get {
return (_hasBits0 & 32768) != 0; }
870 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
871 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
878 private readonly
static double DualizerThresholdDefaultValue = 1.5D;
880 private double dualizerThreshold_;
886 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
887 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
889 get {
if ((_hasBits0 & 65536) != 0) {
return dualizerThreshold_; }
else {
return DualizerThresholdDefaultValue; } }
892 dualizerThreshold_ = value;
896 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
897 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
898 public bool HasDualizerThreshold {
899 get {
return (_hasBits0 & 65536) != 0; }
902 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
903 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
910 private readonly
static double SolutionFeasibilityToleranceDefaultValue = 1e-06D;
912 private double solutionFeasibilityTolerance_;
923 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
924 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
926 get {
if ((_hasBits0 & 131072) != 0) {
return solutionFeasibilityTolerance_; }
else {
return SolutionFeasibilityToleranceDefaultValue; } }
929 solutionFeasibilityTolerance_ = value;
933 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
934 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
935 public bool HasSolutionFeasibilityTolerance {
936 get {
return (_hasBits0 & 131072) != 0; }
939 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
940 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
942 _hasBits0 &= ~131072;
946 public const int ProvideStrongOptimalGuaranteeFieldNumber = 24;
947 private readonly
static bool ProvideStrongOptimalGuaranteeDefaultValue =
true;
949 private bool provideStrongOptimalGuarantee_;
970 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
971 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
973 get {
if ((_hasBits0 & 262144) != 0) {
return provideStrongOptimalGuarantee_; }
else {
return ProvideStrongOptimalGuaranteeDefaultValue; } }
976 provideStrongOptimalGuarantee_ = value;
980 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
981 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
983 get {
return (_hasBits0 & 262144) != 0; }
986 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
987 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
988 public void ClearProvideStrongOptimalGuarantee() {
989 _hasBits0 &= ~262144;
993 public const int ChangeStatusToImpreciseFieldNumber = 58;
994 private readonly
static bool ChangeStatusToImpreciseDefaultValue =
true;
996 private bool changeStatusToImprecise_;
1001 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1002 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1004 get {
if ((_hasBits1 & 8192) != 0) {
return changeStatusToImprecise_; }
else {
return ChangeStatusToImpreciseDefaultValue; } }
1007 changeStatusToImprecise_ = value;
1011 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1012 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1014 get {
return (_hasBits1 & 8192) != 0; }
1017 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1018 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1019 public void ClearChangeStatusToImprecise() {
1024 public const int MaxNumberOfReoptimizationsFieldNumber = 56;
1025 private readonly
static double MaxNumberOfReoptimizationsDefaultValue = 40D;
1027 private double maxNumberOfReoptimizations_;
1034 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1035 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1037 get {
if ((_hasBits1 & 2048) != 0) {
return maxNumberOfReoptimizations_; }
else {
return MaxNumberOfReoptimizationsDefaultValue; } }
1040 maxNumberOfReoptimizations_ = value;
1044 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1045 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1047 get {
return (_hasBits1 & 2048) != 0; }
1050 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1051 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1052 public void ClearMaxNumberOfReoptimizations() {
1057 public const int LuFactorizationPivotThresholdFieldNumber = 25;
1058 private readonly
static double LuFactorizationPivotThresholdDefaultValue = 0.01D;
1060 private double luFactorizationPivotThreshold_;
1067 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1068 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1070 get {
if ((_hasBits0 & 524288) != 0) {
return luFactorizationPivotThreshold_; }
else {
return LuFactorizationPivotThresholdDefaultValue; } }
1072 _hasBits0 |= 524288;
1073 luFactorizationPivotThreshold_ = value;
1077 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1078 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1080 get {
return (_hasBits0 & 524288) != 0; }
1083 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1084 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1085 public void ClearLuFactorizationPivotThreshold() {
1086 _hasBits0 &= ~524288;
1090 public const int MaxTimeInSecondsFieldNumber = 26;
1091 private readonly
static double MaxTimeInSecondsDefaultValue =
double.PositiveInfinity;
1093 private double maxTimeInSeconds_;
1097 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1098 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1100 get {
if ((_hasBits0 & 1048576) != 0) {
return maxTimeInSeconds_; }
else {
return MaxTimeInSecondsDefaultValue; } }
1102 _hasBits0 |= 1048576;
1103 maxTimeInSeconds_ = value;
1107 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1108 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1110 get {
return (_hasBits0 & 1048576) != 0; }
1113 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1114 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1115 public void ClearMaxTimeInSeconds() {
1116 _hasBits0 &= ~1048576;
1120 public const int MaxDeterministicTimeFieldNumber = 45;
1121 private readonly
static double MaxDeterministicTimeDefaultValue =
double.PositiveInfinity;
1123 private double maxDeterministicTime_;
1131 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1132 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1134 get {
if ((_hasBits1 & 64) != 0) {
return maxDeterministicTime_; }
else {
return MaxDeterministicTimeDefaultValue; } }
1137 maxDeterministicTime_ = value;
1141 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1142 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1144 get {
return (_hasBits1 & 64) != 0; }
1147 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1148 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1149 public void ClearMaxDeterministicTime() {
1155 private readonly
static long MaxNumberOfIterationsDefaultValue = -1L;
1157 private long maxNumberOfIterations_;
1162 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1163 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1165 get {
if ((_hasBits0 & 2097152) != 0) {
return maxNumberOfIterations_; }
else {
return MaxNumberOfIterationsDefaultValue; } }
1167 _hasBits0 |= 2097152;
1168 maxNumberOfIterations_ = value;
1172 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1173 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1175 get {
return (_hasBits0 & 2097152) != 0; }
1178 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1179 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1180 public void ClearMaxNumberOfIterations() {
1181 _hasBits0 &= ~2097152;
1186 private readonly
static int MarkowitzZlatevParameterDefaultValue = 3;
1188 private int markowitzZlatevParameter_;
1193 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1194 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1196 get {
if ((_hasBits0 & 4194304) != 0) {
return markowitzZlatevParameter_; }
else {
return MarkowitzZlatevParameterDefaultValue; } }
1198 _hasBits0 |= 4194304;
1199 markowitzZlatevParameter_ = value;
1203 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1204 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1206 get {
return (_hasBits0 & 4194304) != 0; }
1209 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1210 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1211 public void ClearMarkowitzZlatevParameter() {
1212 _hasBits0 &= ~4194304;
1217 private readonly
static double MarkowitzSingularityThresholdDefaultValue = 1e-15D;
1219 private double markowitzSingularityThreshold_;
1226 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1227 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1229 get {
if ((_hasBits0 & 8388608) != 0) {
return markowitzSingularityThreshold_; }
else {
return MarkowitzSingularityThresholdDefaultValue; } }
1231 _hasBits0 |= 8388608;
1232 markowitzSingularityThreshold_ = value;
1236 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1237 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1239 get {
return (_hasBits0 & 8388608) != 0; }
1242 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1243 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1244 public void ClearMarkowitzSingularityThreshold() {
1245 _hasBits0 &= ~8388608;
1250 private readonly
static bool UseDualSimplexDefaultValue =
false;
1252 private bool useDualSimplex_;
1256 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1257 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1259 get {
if ((_hasBits0 & 16777216) != 0) {
return useDualSimplex_; }
else {
return UseDualSimplexDefaultValue; } }
1261 _hasBits0 |= 16777216;
1262 useDualSimplex_ = value;
1266 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1267 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1269 get {
return (_hasBits0 & 16777216) != 0; }
1272 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1273 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1274 public void ClearUseDualSimplex() {
1275 _hasBits0 &= ~16777216;
1280 private readonly
static bool AllowSimplexAlgorithmChangeDefaultValue =
false;
1282 private bool allowSimplexAlgorithmChange_;
1289 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1290 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1292 get {
if ((_hasBits0 & 33554432) != 0) {
return allowSimplexAlgorithmChange_; }
else {
return AllowSimplexAlgorithmChangeDefaultValue; } }
1294 _hasBits0 |= 33554432;
1295 allowSimplexAlgorithmChange_ = value;
1299 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1300 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1302 get {
return (_hasBits0 & 33554432) != 0; }
1305 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1306 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1307 public void ClearAllowSimplexAlgorithmChange() {
1308 _hasBits0 &= ~33554432;
1313 private readonly
static int DevexWeightsResetPeriodDefaultValue = 150;
1315 private int devexWeightsResetPeriod_;
1319 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1320 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1322 get {
if ((_hasBits0 & 67108864) != 0) {
return devexWeightsResetPeriod_; }
else {
return DevexWeightsResetPeriodDefaultValue; } }
1324 _hasBits0 |= 67108864;
1325 devexWeightsResetPeriod_ = value;
1329 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1330 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1332 get {
return (_hasBits0 & 67108864) != 0; }
1335 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1336 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1337 public void ClearDevexWeightsResetPeriod() {
1338 _hasBits0 &= ~67108864;
1343 private readonly
static bool UsePreprocessingDefaultValue =
true;
1345 private bool usePreprocessing_;
1349 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1350 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1352 get {
if ((_hasBits0 & 134217728) != 0) {
return usePreprocessing_; }
else {
return UsePreprocessingDefaultValue; } }
1354 _hasBits0 |= 134217728;
1355 usePreprocessing_ = value;
1359 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1360 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1362 get {
return (_hasBits0 & 134217728) != 0; }
1365 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1366 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1367 public void ClearUsePreprocessing() {
1368 _hasBits0 &= ~134217728;
1373 private readonly
static bool UseMiddleProductFormUpdateDefaultValue =
true;
1375 private bool useMiddleProductFormUpdate_;
1385 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1386 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1388 get {
if ((_hasBits0 & 268435456) != 0) {
return useMiddleProductFormUpdate_; }
else {
return UseMiddleProductFormUpdateDefaultValue; } }
1390 _hasBits0 |= 268435456;
1391 useMiddleProductFormUpdate_ = value;
1395 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1396 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1398 get {
return (_hasBits0 & 268435456) != 0; }
1401 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1402 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1403 public void ClearUseMiddleProductFormUpdate() {
1404 _hasBits0 &= ~268435456;
1409 private readonly
static bool InitializeDevexWithColumnNormsDefaultValue =
true;
1411 private bool initializeDevexWithColumnNorms_;
1416 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1417 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1419 get {
if ((_hasBits0 & 536870912) != 0) {
return initializeDevexWithColumnNorms_; }
else {
return InitializeDevexWithColumnNormsDefaultValue; } }
1421 _hasBits0 |= 536870912;
1422 initializeDevexWithColumnNorms_ = value;
1426 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1427 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1429 get {
return (_hasBits0 & 536870912) != 0; }
1432 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1433 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1434 public void ClearInitializeDevexWithColumnNorms() {
1435 _hasBits0 &= ~536870912;
1440 private readonly
static bool ExploitSingletonColumnInInitialBasisDefaultValue =
true;
1442 private bool exploitSingletonColumnInInitialBasis_;
1447 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1448 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1450 get {
if ((_hasBits0 & 1073741824) != 0) {
return exploitSingletonColumnInInitialBasis_; }
else {
return ExploitSingletonColumnInInitialBasisDefaultValue; } }
1452 _hasBits0 |= 1073741824;
1453 exploitSingletonColumnInInitialBasis_ = value;
1457 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1458 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1460 get {
return (_hasBits0 & 1073741824) != 0; }
1463 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1464 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1465 public void ClearExploitSingletonColumnInInitialBasis() {
1466 _hasBits0 &= ~1073741824;
1471 private readonly
static double DualSmallPivotThresholdDefaultValue = 0.0001D;
1473 private double dualSmallPivotThreshold_;
1479 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1480 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1482 get {
if ((_hasBits0 & -2147483648) != 0) {
return dualSmallPivotThreshold_; }
else {
return DualSmallPivotThresholdDefaultValue; } }
1484 _hasBits0 |= -2147483648;
1485 dualSmallPivotThreshold_ = value;
1489 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1490 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1492 get {
return (_hasBits0 & -2147483648) != 0; }
1495 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1496 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1497 public void ClearDualSmallPivotThreshold() {
1498 _hasBits0 &= ~-2147483648;
1503 private readonly
static double PreprocessorZeroToleranceDefaultValue = 1e-09D;
1505 private double preprocessorZeroTolerance_;
1514 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1515 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1517 get {
if ((_hasBits1 & 1) != 0) {
return preprocessorZeroTolerance_; }
else {
return PreprocessorZeroToleranceDefaultValue; } }
1520 preprocessorZeroTolerance_ = value;
1524 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1525 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1527 get {
return (_hasBits1 & 1) != 0; }
1530 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1531 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1532 public void ClearPreprocessorZeroTolerance() {
1538 private readonly
static double ObjectiveLowerLimitDefaultValue =
double.NegativeInfinity;
1540 private double objectiveLowerLimit_;
1552 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1553 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1555 get {
if ((_hasBits1 & 2) != 0) {
return objectiveLowerLimit_; }
else {
return ObjectiveLowerLimitDefaultValue; } }
1558 objectiveLowerLimit_ = value;
1562 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1563 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1564 public bool HasObjectiveLowerLimit {
1565 get {
return (_hasBits1 & 2) != 0; }
1568 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1569 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1570 public void ClearObjectiveLowerLimit() {
1576 private readonly
static double ObjectiveUpperLimitDefaultValue =
double.PositiveInfinity;
1578 private double objectiveUpperLimit_;
1579 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1580 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1582 get {
if ((_hasBits1 & 4) != 0) {
return objectiveUpperLimit_; }
else {
return ObjectiveUpperLimitDefaultValue; } }
1585 objectiveUpperLimit_ = value;
1589 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1590 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1591 public bool HasObjectiveUpperLimit {
1592 get {
return (_hasBits1 & 4) != 0; }
1595 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1596 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1597 public void ClearObjectiveUpperLimit() {
1603 private readonly
static double DegenerateMinistepFactorDefaultValue = 0.01D;
1605 private double degenerateMinistepFactor_;
1626 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1627 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1629 get {
if ((_hasBits1 & 8) != 0) {
return degenerateMinistepFactor_; }
else {
return DegenerateMinistepFactorDefaultValue; } }
1632 degenerateMinistepFactor_ = value;
1636 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1637 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1638 public bool HasDegenerateMinistepFactor {
1639 get {
return (_hasBits1 & 8) != 0; }
1642 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1643 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1649 public const int RandomSeedFieldNumber = 43;
1650 private readonly
static int RandomSeedDefaultValue = 1;
1652 private int randomSeed_;
1670 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1671 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1673 get {
if ((_hasBits1 & 16) != 0) {
return randomSeed_; }
else {
return RandomSeedDefaultValue; } }
1676 randomSeed_ = value;
1680 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1681 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1682 public bool HasRandomSeed {
1683 get {
return (_hasBits1 & 16) != 0; }
1686 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1687 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1693 public const int UseAbslRandomFieldNumber = 72;
1694 private readonly
static bool UseAbslRandomDefaultValue =
false;
1696 private bool useAbslRandom_;
1700 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1701 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1703 get {
if ((_hasBits1 & 67108864) != 0) {
return useAbslRandom_; }
else {
return UseAbslRandomDefaultValue; } }
1705 _hasBits1 |= 67108864;
1706 useAbslRandom_ = value;
1710 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1711 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1712 public bool HasUseAbslRandom {
1713 get {
return (_hasBits1 & 67108864) != 0; }
1716 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1717 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1719 _hasBits1 &= ~67108864;
1723 public const int NumOmpThreadsFieldNumber = 44;
1724 private readonly
static int NumOmpThreadsDefaultValue = 1;
1726 private int numOmpThreads_;
1731 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1732 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1734 get {
if ((_hasBits1 & 32) != 0) {
return numOmpThreads_; }
else {
return NumOmpThreadsDefaultValue; } }
1737 numOmpThreads_ = value;
1741 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1742 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1743 public bool HasNumOmpThreads {
1744 get {
return (_hasBits1 & 32) != 0; }
1747 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1748 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1754 public const int PerturbCostsInDualSimplexFieldNumber = 53;
1755 private readonly
static bool PerturbCostsInDualSimplexDefaultValue =
false;
1757 private bool perturbCostsInDualSimplex_;
1764 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1765 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1767 get {
if ((_hasBits1 & 256) != 0) {
return perturbCostsInDualSimplex_; }
else {
return PerturbCostsInDualSimplexDefaultValue; } }
1770 perturbCostsInDualSimplex_ = value;
1774 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1775 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1776 public bool HasPerturbCostsInDualSimplex {
1777 get {
return (_hasBits1 & 256) != 0; }
1780 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1781 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1787 public const int UseDedicatedDualFeasibilityAlgorithmFieldNumber = 62;
1788 private readonly
static bool UseDedicatedDualFeasibilityAlgorithmDefaultValue =
true;
1790 private bool useDedicatedDualFeasibilityAlgorithm_;
1801 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1802 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1804 get {
if ((_hasBits1 & 131072) != 0) {
return useDedicatedDualFeasibilityAlgorithm_; }
else {
return UseDedicatedDualFeasibilityAlgorithmDefaultValue; } }
1806 _hasBits1 |= 131072;
1807 useDedicatedDualFeasibilityAlgorithm_ = value;
1811 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1812 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1813 public bool HasUseDedicatedDualFeasibilityAlgorithm {
1814 get {
return (_hasBits1 & 131072) != 0; }
1817 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1818 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1820 _hasBits1 &= ~131072;
1824 public const int RelativeCostPerturbationFieldNumber = 54;
1825 private readonly
static double RelativeCostPerturbationDefaultValue = 1e-05D;
1827 private double relativeCostPerturbation_;
1834 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1835 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1837 get {
if ((_hasBits1 & 512) != 0) {
return relativeCostPerturbation_; }
else {
return RelativeCostPerturbationDefaultValue; } }
1840 relativeCostPerturbation_ = value;
1844 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1845 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1846 public bool HasRelativeCostPerturbation {
1847 get {
return (_hasBits1 & 512) != 0; }
1850 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1851 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1857 public const int RelativeMaxCostPerturbationFieldNumber = 55;
1858 private readonly
static double RelativeMaxCostPerturbationDefaultValue = 1e-07D;
1860 private double relativeMaxCostPerturbation_;
1861 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1862 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1864 get {
if ((_hasBits1 & 1024) != 0) {
return relativeMaxCostPerturbation_; }
else {
return RelativeMaxCostPerturbationDefaultValue; } }
1867 relativeMaxCostPerturbation_ = value;
1871 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1872 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1874 get {
return (_hasBits1 & 1024) != 0; }
1877 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1878 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1884 public const int InitialConditionNumberThresholdFieldNumber = 59;
1885 private readonly
static double InitialConditionNumberThresholdDefaultValue = 1e+50D;
1887 private double initialConditionNumberThreshold_;
1893 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1894 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1896 get {
if ((_hasBits1 & 16384) != 0) {
return initialConditionNumberThreshold_; }
else {
return InitialConditionNumberThresholdDefaultValue; } }
1899 initialConditionNumberThreshold_ = value;
1903 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1904 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1905 public bool HasInitialConditionNumberThreshold {
1906 get {
return (_hasBits1 & 16384) != 0; }
1909 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1910 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1912 _hasBits1 &= ~16384;
1916 public const int LogSearchProgressFieldNumber = 61;
1917 private readonly
static bool LogSearchProgressDefaultValue =
false;
1919 private bool logSearchProgress_;
1925 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1926 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1928 get {
if ((_hasBits1 & 65536) != 0) {
return logSearchProgress_; }
else {
return LogSearchProgressDefaultValue; } }
1931 logSearchProgress_ = value;
1935 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1936 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1937 public bool HasLogSearchProgress {
1938 get {
return (_hasBits1 & 65536) != 0; }
1941 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1942 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1944 _hasBits1 &= ~65536;
1948 public const int LogToStdoutFieldNumber = 66;
1949 private readonly
static bool LogToStdoutDefaultValue =
true;
1951 private bool logToStdout_;
1955 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1956 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1958 get {
if ((_hasBits1 & 2097152) != 0) {
return logToStdout_; }
else {
return LogToStdoutDefaultValue; } }
1960 _hasBits1 |= 2097152;
1961 logToStdout_ = value;
1965 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1966 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1968 get {
return (_hasBits1 & 2097152) != 0; }
1971 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1972 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1974 _hasBits1 &= ~2097152;
1978 public const int CrossoverBoundSnappingDistanceFieldNumber = 64;
1979 private readonly
static double CrossoverBoundSnappingDistanceDefaultValue =
double.PositiveInfinity;
1981 private double crossoverBoundSnappingDistance_;
1999 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2000 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2002 get {
if ((_hasBits1 & 524288) != 0) {
return crossoverBoundSnappingDistance_; }
else {
return CrossoverBoundSnappingDistanceDefaultValue; } }
2004 _hasBits1 |= 524288;
2005 crossoverBoundSnappingDistance_ = value;
2009 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2010 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2011 public bool HasCrossoverBoundSnappingDistance {
2012 get {
return (_hasBits1 & 524288) != 0; }
2015 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2016 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2017 public void ClearCrossoverBoundSnappingDistance() {
2018 _hasBits1 &= ~524288;
2023 private readonly
static bool PushToVertexDefaultValue =
true;
2025 private bool pushToVertex_;
2034 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2035 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2037 get {
if ((_hasBits1 & 1048576) != 0) {
return pushToVertex_; }
else {
return PushToVertexDefaultValue; } }
2039 _hasBits1 |= 1048576;
2040 pushToVertex_ = value;
2044 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2045 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2046 public bool HasPushToVertex {
2047 get {
return (_hasBits1 & 1048576) != 0; }
2050 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2051 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2052 public void ClearPushToVertex() {
2053 _hasBits1 &= ~1048576;
2058 private readonly
static bool UseImpliedFreePreprocessorDefaultValue =
true;
2060 private bool useImpliedFreePreprocessor_;
2064 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2065 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2067 get {
if ((_hasBits1 & 4194304) != 0) {
return useImpliedFreePreprocessor_; }
else {
return UseImpliedFreePreprocessorDefaultValue; } }
2069 _hasBits1 |= 4194304;
2070 useImpliedFreePreprocessor_ = value;
2074 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2075 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2077 get {
return (_hasBits1 & 4194304) != 0; }
2080 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2081 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2082 public void ClearUseImpliedFreePreprocessor() {
2083 _hasBits1 &= ~4194304;
2088 private readonly
static double MaxValidMagnitudeDefaultValue = 1e+30D;
2090 private double maxValidMagnitude_;
2099 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2100 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2102 get {
if ((_hasBits1 & 16777216) != 0) {
return maxValidMagnitude_; }
else {
return MaxValidMagnitudeDefaultValue; } }
2104 _hasBits1 |= 16777216;
2105 maxValidMagnitude_ = value;
2109 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2110 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2111 public bool HasMaxValidMagnitude {
2112 get {
return (_hasBits1 & 16777216) != 0; }
2115 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2116 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2117 public void ClearMaxValidMagnitude() {
2118 _hasBits1 &= ~16777216;
2123 private readonly
static double DropMagnitudeDefaultValue = 1e-30D;
2125 private double dropMagnitude_;
2132 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2133 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2135 get {
if ((_hasBits1 & 33554432) != 0) {
return dropMagnitude_; }
else {
return DropMagnitudeDefaultValue; } }
2137 _hasBits1 |= 33554432;
2138 dropMagnitude_ = value;
2142 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2143 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2145 get {
return (_hasBits1 & 33554432) != 0; }
2148 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2149 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2150 public void ClearDropMagnitude() {
2151 _hasBits1 &= ~33554432;
2156 private readonly
static bool DualPricePrioritizeNormDefaultValue =
false;
2158 private bool dualPricePrioritizeNorm_;
2163 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2164 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2166 get {
if ((_hasBits1 & 8388608) != 0) {
return dualPricePrioritizeNorm_; }
else {
return DualPricePrioritizeNormDefaultValue; } }
2168 _hasBits1 |= 8388608;
2169 dualPricePrioritizeNorm_ = value;
2173 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2174 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2176 get {
return (_hasBits1 & 8388608) != 0; }
2179 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2180 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2181 public void ClearDualPricePrioritizeNorm() {
2182 _hasBits1 &= ~8388608;
2185 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2186 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2187 public override bool Equals(
object other) {
2191 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2192 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2194 if (ReferenceEquals(other,
null)) {
2197 if (ReferenceEquals(other,
this)) {
2259 return Equals(_unknownFields, other._unknownFields);
2262 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2263 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2264 public override int GetHashCode() {
2266 if (HasScalingMethod) hash ^= ScalingMethod.GetHashCode();
2267 if (HasFeasibilityRule) hash ^= FeasibilityRule.GetHashCode();
2268 if (HasOptimizationRule) hash ^= OptimizationRule.GetHashCode();
2269 if (HasRefactorizationThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RefactorizationThreshold);
2270 if (HasRecomputeReducedCostsThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RecomputeReducedCostsThreshold);
2271 if (HasRecomputeEdgesNormThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RecomputeEdgesNormThreshold);
2272 if (HasPrimalFeasibilityTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PrimalFeasibilityTolerance);
2273 if (HasDualFeasibilityTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DualFeasibilityTolerance);
2274 if (HasRatioTestZeroThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RatioTestZeroThreshold);
2275 if (HasHarrisToleranceRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(HarrisToleranceRatio);
2276 if (HasSmallPivotThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(SmallPivotThreshold);
2277 if (HasMinimumAcceptablePivot) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MinimumAcceptablePivot);
2278 if (HasDropTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DropTolerance);
2279 if (HasUseScaling) hash ^= UseScaling.GetHashCode();
2280 if (HasCostScaling) hash ^= CostScaling.GetHashCode();
2281 if (HasInitialBasis) hash ^= InitialBasis.GetHashCode();
2282 if (HasUseTransposedMatrix) hash ^= UseTransposedMatrix.GetHashCode();
2325 if (_unknownFields !=
null) {
2326 hash ^= _unknownFields.GetHashCode();
2331 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2332 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2333 public override string ToString() {
2334 return pb::JsonFormatter.ToDiagnosticString(
this);
2337 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2338 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2339 public void WriteTo(pb::CodedOutputStream output) {
2340 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2341 output.WriteRawMessage(
this);
2343 if (HasFeasibilityRule) {
2344 output.WriteRawTag(8);
2345 output.WriteEnum((
int) FeasibilityRule);
2347 if (HasOptimizationRule) {
2348 output.WriteRawTag(16);
2349 output.WriteEnum((
int) OptimizationRule);
2351 if (HasRefactorizationThreshold) {
2352 output.WriteRawTag(49);
2355 if (HasRecomputeReducedCostsThreshold) {
2356 output.WriteRawTag(65);
2357 output.WriteDouble(RecomputeReducedCostsThreshold);
2359 if (HasRecomputeEdgesNormThreshold) {
2360 output.WriteRawTag(73);
2361 output.WriteDouble(RecomputeEdgesNormThreshold);
2363 if (HasPrimalFeasibilityTolerance) {
2364 output.WriteRawTag(81);
2365 output.WriteDouble(PrimalFeasibilityTolerance);
2367 if (HasDualFeasibilityTolerance) {
2368 output.WriteRawTag(89);
2369 output.WriteDouble(DualFeasibilityTolerance);
2371 if (HasRatioTestZeroThreshold) {
2372 output.WriteRawTag(97);
2373 output.WriteDouble(RatioTestZeroThreshold);
2375 if (HasHarrisToleranceRatio) {
2376 output.WriteRawTag(105);
2377 output.WriteDouble(HarrisToleranceRatio);
2379 if (HasSmallPivotThreshold) {
2380 output.WriteRawTag(113);
2381 output.WriteDouble(SmallPivotThreshold);
2383 if (HasMinimumAcceptablePivot) {
2384 output.WriteRawTag(121);
2385 output.WriteDouble(MinimumAcceptablePivot);
2387 if (HasUseScaling) {
2388 output.WriteRawTag(128, 1);
2389 output.WriteBool(UseScaling);
2391 if (HasInitialBasis) {
2392 output.WriteRawTag(136, 1);
2393 output.WriteEnum((
int) InitialBasis);
2395 if (HasUseTransposedMatrix) {
2396 output.WriteRawTag(144, 1);
2397 output.WriteBool(UseTransposedMatrix);
2399 if (HasBasisRefactorizationPeriod) {
2400 output.WriteRawTag(152, 1);
2401 output.WriteInt32(BasisRefactorizationPeriod);
2403 if (HasSolveDualProblem) {
2404 output.WriteRawTag(160, 1);
2405 output.WriteEnum((
int) SolveDualProblem);
2407 if (HasDualizerThreshold) {
2408 output.WriteRawTag(169, 1);
2409 output.WriteDouble(DualizerThreshold);
2411 if (HasSolutionFeasibilityTolerance) {
2412 output.WriteRawTag(177, 1);
2413 output.WriteDouble(SolutionFeasibilityTolerance);
2415 if (HasProvideStrongOptimalGuarantee) {
2416 output.WriteRawTag(192, 1);
2417 output.WriteBool(ProvideStrongOptimalGuarantee);
2419 if (HasLuFactorizationPivotThreshold) {
2420 output.WriteRawTag(201, 1);
2421 output.WriteDouble(LuFactorizationPivotThreshold);
2423 if (HasMaxTimeInSeconds) {
2424 output.WriteRawTag(209, 1);
2425 output.WriteDouble(MaxTimeInSeconds);
2427 if (HasMaxNumberOfIterations) {
2428 output.WriteRawTag(216, 1);
2429 output.WriteInt64(MaxNumberOfIterations);
2431 if (HasMarkowitzZlatevParameter) {
2432 output.WriteRawTag(232, 1);
2433 output.WriteInt32(MarkowitzZlatevParameter);
2435 if (HasMarkowitzSingularityThreshold) {
2436 output.WriteRawTag(241, 1);
2437 output.WriteDouble(MarkowitzSingularityThreshold);
2439 if (HasUseDualSimplex) {
2440 output.WriteRawTag(248, 1);
2441 output.WriteBool(UseDualSimplex);
2443 if (HasAllowSimplexAlgorithmChange) {
2444 output.WriteRawTag(128, 2);
2445 output.WriteBool(AllowSimplexAlgorithmChange);
2447 if (HasDevexWeightsResetPeriod) {
2448 output.WriteRawTag(136, 2);
2449 output.WriteInt32(DevexWeightsResetPeriod);
2451 if (HasUsePreprocessing) {
2452 output.WriteRawTag(144, 2);
2453 output.WriteBool(UsePreprocessing);
2455 if (HasUseMiddleProductFormUpdate) {
2456 output.WriteRawTag(152, 2);
2457 output.WriteBool(UseMiddleProductFormUpdate);
2459 if (HasInitializeDevexWithColumnNorms) {
2460 output.WriteRawTag(160, 2);
2461 output.WriteBool(InitializeDevexWithColumnNorms);
2463 if (HasExploitSingletonColumnInInitialBasis) {
2464 output.WriteRawTag(168, 2);
2465 output.WriteBool(ExploitSingletonColumnInInitialBasis);
2467 if (HasDualSmallPivotThreshold) {
2468 output.WriteRawTag(177, 2);
2469 output.WriteDouble(DualSmallPivotThreshold);
2471 if (HasPreprocessorZeroTolerance) {
2472 output.WriteRawTag(185, 2);
2473 output.WriteDouble(PreprocessorZeroTolerance);
2475 if (HasObjectiveLowerLimit) {
2476 output.WriteRawTag(193, 2);
2477 output.WriteDouble(ObjectiveLowerLimit);
2479 if (HasObjectiveUpperLimit) {
2480 output.WriteRawTag(201, 2);
2481 output.WriteDouble(ObjectiveUpperLimit);
2483 if (HasDegenerateMinistepFactor) {
2484 output.WriteRawTag(209, 2);
2485 output.WriteDouble(DegenerateMinistepFactor);
2487 if (HasRandomSeed) {
2488 output.WriteRawTag(216, 2);
2489 output.WriteInt32(RandomSeed);
2491 if (HasNumOmpThreads) {
2492 output.WriteRawTag(224, 2);
2493 output.WriteInt32(NumOmpThreads);
2495 if (HasMaxDeterministicTime) {
2496 output.WriteRawTag(233, 2);
2497 output.WriteDouble(MaxDeterministicTime);
2499 if (HasDropTolerance) {
2500 output.WriteRawTag(161, 3);
2501 output.WriteDouble(DropTolerance);
2503 if (HasPerturbCostsInDualSimplex) {
2504 output.WriteRawTag(168, 3);
2505 output.WriteBool(PerturbCostsInDualSimplex);
2507 if (HasRelativeCostPerturbation) {
2508 output.WriteRawTag(177, 3);
2509 output.WriteDouble(RelativeCostPerturbation);
2511 if (HasRelativeMaxCostPerturbation) {
2512 output.WriteRawTag(185, 3);
2513 output.WriteDouble(RelativeMaxCostPerturbation);
2515 if (HasMaxNumberOfReoptimizations) {
2516 output.WriteRawTag(193, 3);
2517 output.WriteDouble(MaxNumberOfReoptimizations);
2519 if (HasScalingMethod) {
2520 output.WriteRawTag(200, 3);
2521 output.WriteEnum((
int) ScalingMethod);
2523 if (HasChangeStatusToImprecise) {
2524 output.WriteRawTag(208, 3);
2525 output.WriteBool(ChangeStatusToImprecise);
2527 if (HasInitialConditionNumberThreshold) {
2528 output.WriteRawTag(217, 3);
2529 output.WriteDouble(InitialConditionNumberThreshold);
2531 if (HasCostScaling) {
2532 output.WriteRawTag(224, 3);
2533 output.WriteEnum((
int) CostScaling);
2535 if (HasLogSearchProgress) {
2536 output.WriteRawTag(232, 3);
2537 output.WriteBool(LogSearchProgress);
2539 if (HasUseDedicatedDualFeasibilityAlgorithm) {
2540 output.WriteRawTag(240, 3);
2541 output.WriteBool(UseDedicatedDualFeasibilityAlgorithm);
2543 if (HasDynamicallyAdjustRefactorizationPeriod) {
2544 output.WriteRawTag(248, 3);
2545 output.WriteBool(DynamicallyAdjustRefactorizationPeriod);
2547 if (HasCrossoverBoundSnappingDistance) {
2548 output.WriteRawTag(129, 4);
2549 output.WriteDouble(CrossoverBoundSnappingDistance);
2551 if (HasPushToVertex) {
2552 output.WriteRawTag(136, 4);
2553 output.WriteBool(PushToVertex);
2555 if (HasLogToStdout) {
2556 output.WriteRawTag(144, 4);
2557 output.WriteBool(LogToStdout);
2559 if (HasUseImpliedFreePreprocessor) {
2560 output.WriteRawTag(152, 4);
2561 output.WriteBool(UseImpliedFreePreprocessor);
2563 if (HasDualPricePrioritizeNorm) {
2564 output.WriteRawTag(168, 4);
2565 output.WriteBool(DualPricePrioritizeNorm);
2567 if (HasMaxValidMagnitude) {
2568 output.WriteRawTag(177, 4);
2569 output.WriteDouble(MaxValidMagnitude);
2571 if (HasDropMagnitude) {
2572 output.WriteRawTag(185, 4);
2573 output.WriteDouble(DropMagnitude);
2575 if (HasUseAbslRandom) {
2576 output.WriteRawTag(192, 4);
2577 output.WriteBool(UseAbslRandom);
2579 if (_unknownFields !=
null) {
2580 _unknownFields.WriteTo(output);
2585 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
2586 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2587 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2588 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
2589 if (HasFeasibilityRule) {
2590 output.WriteRawTag(8);
2591 output.WriteEnum((
int) FeasibilityRule);
2593 if (HasOptimizationRule) {
2594 output.WriteRawTag(16);
2595 output.WriteEnum((
int) OptimizationRule);
2597 if (HasRefactorizationThreshold) {
2598 output.WriteRawTag(49);
2599 output.WriteDouble(RefactorizationThreshold);
2601 if (HasRecomputeReducedCostsThreshold) {
2602 output.WriteRawTag(65);
2603 output.WriteDouble(RecomputeReducedCostsThreshold);
2605 if (HasRecomputeEdgesNormThreshold) {
2606 output.WriteRawTag(73);
2607 output.WriteDouble(RecomputeEdgesNormThreshold);
2609 if (HasPrimalFeasibilityTolerance) {
2610 output.WriteRawTag(81);
2611 output.WriteDouble(PrimalFeasibilityTolerance);
2613 if (HasDualFeasibilityTolerance) {
2614 output.WriteRawTag(89);
2615 output.WriteDouble(DualFeasibilityTolerance);
2617 if (HasRatioTestZeroThreshold) {
2618 output.WriteRawTag(97);
2619 output.WriteDouble(RatioTestZeroThreshold);
2621 if (HasHarrisToleranceRatio) {
2622 output.WriteRawTag(105);
2623 output.WriteDouble(HarrisToleranceRatio);
2625 if (HasSmallPivotThreshold) {
2626 output.WriteRawTag(113);
2627 output.WriteDouble(SmallPivotThreshold);
2629 if (HasMinimumAcceptablePivot) {
2630 output.WriteRawTag(121);
2631 output.WriteDouble(MinimumAcceptablePivot);
2633 if (HasUseScaling) {
2634 output.WriteRawTag(128, 1);
2635 output.WriteBool(UseScaling);
2637 if (HasInitialBasis) {
2638 output.WriteRawTag(136, 1);
2639 output.WriteEnum((
int) InitialBasis);
2641 if (HasUseTransposedMatrix) {
2642 output.WriteRawTag(144, 1);
2643 output.WriteBool(UseTransposedMatrix);
2645 if (HasBasisRefactorizationPeriod) {
2646 output.WriteRawTag(152, 1);
2647 output.WriteInt32(BasisRefactorizationPeriod);
2649 if (HasSolveDualProblem) {
2650 output.WriteRawTag(160, 1);
2651 output.WriteEnum((
int) SolveDualProblem);
2653 if (HasDualizerThreshold) {
2654 output.WriteRawTag(169, 1);
2655 output.WriteDouble(DualizerThreshold);
2657 if (HasSolutionFeasibilityTolerance) {
2658 output.WriteRawTag(177, 1);
2659 output.WriteDouble(SolutionFeasibilityTolerance);
2661 if (HasProvideStrongOptimalGuarantee) {
2662 output.WriteRawTag(192, 1);
2663 output.WriteBool(ProvideStrongOptimalGuarantee);
2665 if (HasLuFactorizationPivotThreshold) {
2666 output.WriteRawTag(201, 1);
2667 output.WriteDouble(LuFactorizationPivotThreshold);
2669 if (HasMaxTimeInSeconds) {
2670 output.WriteRawTag(209, 1);
2671 output.WriteDouble(MaxTimeInSeconds);
2673 if (HasMaxNumberOfIterations) {
2674 output.WriteRawTag(216, 1);
2675 output.WriteInt64(MaxNumberOfIterations);
2677 if (HasMarkowitzZlatevParameter) {
2678 output.WriteRawTag(232, 1);
2679 output.WriteInt32(MarkowitzZlatevParameter);
2681 if (HasMarkowitzSingularityThreshold) {
2682 output.WriteRawTag(241, 1);
2683 output.WriteDouble(MarkowitzSingularityThreshold);
2685 if (HasUseDualSimplex) {
2686 output.WriteRawTag(248, 1);
2687 output.WriteBool(UseDualSimplex);
2689 if (HasAllowSimplexAlgorithmChange) {
2690 output.WriteRawTag(128, 2);
2691 output.WriteBool(AllowSimplexAlgorithmChange);
2693 if (HasDevexWeightsResetPeriod) {
2694 output.WriteRawTag(136, 2);
2695 output.WriteInt32(DevexWeightsResetPeriod);
2697 if (HasUsePreprocessing) {
2698 output.WriteRawTag(144, 2);
2699 output.WriteBool(UsePreprocessing);
2701 if (HasUseMiddleProductFormUpdate) {
2702 output.WriteRawTag(152, 2);
2703 output.WriteBool(UseMiddleProductFormUpdate);
2705 if (HasInitializeDevexWithColumnNorms) {
2706 output.WriteRawTag(160, 2);
2707 output.WriteBool(InitializeDevexWithColumnNorms);
2709 if (HasExploitSingletonColumnInInitialBasis) {
2710 output.WriteRawTag(168, 2);
2711 output.WriteBool(ExploitSingletonColumnInInitialBasis);
2713 if (HasDualSmallPivotThreshold) {
2714 output.WriteRawTag(177, 2);
2715 output.WriteDouble(DualSmallPivotThreshold);
2717 if (HasPreprocessorZeroTolerance) {
2718 output.WriteRawTag(185, 2);
2719 output.WriteDouble(PreprocessorZeroTolerance);
2721 if (HasObjectiveLowerLimit) {
2722 output.WriteRawTag(193, 2);
2723 output.WriteDouble(ObjectiveLowerLimit);
2725 if (HasObjectiveUpperLimit) {
2726 output.WriteRawTag(201, 2);
2727 output.WriteDouble(ObjectiveUpperLimit);
2729 if (HasDegenerateMinistepFactor) {
2730 output.WriteRawTag(209, 2);
2731 output.WriteDouble(DegenerateMinistepFactor);
2733 if (HasRandomSeed) {
2734 output.WriteRawTag(216, 2);
2735 output.WriteInt32(RandomSeed);
2737 if (HasNumOmpThreads) {
2738 output.WriteRawTag(224, 2);
2739 output.WriteInt32(NumOmpThreads);
2741 if (HasMaxDeterministicTime) {
2742 output.WriteRawTag(233, 2);
2743 output.WriteDouble(MaxDeterministicTime);
2745 if (HasDropTolerance) {
2746 output.WriteRawTag(161, 3);
2747 output.WriteDouble(DropTolerance);
2749 if (HasPerturbCostsInDualSimplex) {
2750 output.WriteRawTag(168, 3);
2751 output.WriteBool(PerturbCostsInDualSimplex);
2753 if (HasRelativeCostPerturbation) {
2754 output.WriteRawTag(177, 3);
2755 output.WriteDouble(RelativeCostPerturbation);
2757 if (HasRelativeMaxCostPerturbation) {
2758 output.WriteRawTag(185, 3);
2759 output.WriteDouble(RelativeMaxCostPerturbation);
2761 if (HasMaxNumberOfReoptimizations) {
2762 output.WriteRawTag(193, 3);
2763 output.WriteDouble(MaxNumberOfReoptimizations);
2765 if (HasScalingMethod) {
2766 output.WriteRawTag(200, 3);
2767 output.WriteEnum((
int) ScalingMethod);
2769 if (HasChangeStatusToImprecise) {
2770 output.WriteRawTag(208, 3);
2771 output.WriteBool(ChangeStatusToImprecise);
2773 if (HasInitialConditionNumberThreshold) {
2774 output.WriteRawTag(217, 3);
2775 output.WriteDouble(InitialConditionNumberThreshold);
2777 if (HasCostScaling) {
2778 output.WriteRawTag(224, 3);
2779 output.WriteEnum((
int) CostScaling);
2781 if (HasLogSearchProgress) {
2782 output.WriteRawTag(232, 3);
2783 output.WriteBool(LogSearchProgress);
2785 if (HasUseDedicatedDualFeasibilityAlgorithm) {
2786 output.WriteRawTag(240, 3);
2787 output.WriteBool(UseDedicatedDualFeasibilityAlgorithm);
2789 if (HasDynamicallyAdjustRefactorizationPeriod) {
2790 output.WriteRawTag(248, 3);
2791 output.WriteBool(DynamicallyAdjustRefactorizationPeriod);
2793 if (HasCrossoverBoundSnappingDistance) {
2794 output.WriteRawTag(129, 4);
2795 output.WriteDouble(CrossoverBoundSnappingDistance);
2797 if (HasPushToVertex) {
2798 output.WriteRawTag(136, 4);
2799 output.WriteBool(PushToVertex);
2801 if (HasLogToStdout) {
2802 output.WriteRawTag(144, 4);
2803 output.WriteBool(LogToStdout);
2805 if (HasUseImpliedFreePreprocessor) {
2806 output.WriteRawTag(152, 4);
2807 output.WriteBool(UseImpliedFreePreprocessor);
2809 if (HasDualPricePrioritizeNorm) {
2810 output.WriteRawTag(168, 4);
2811 output.WriteBool(DualPricePrioritizeNorm);
2813 if (HasMaxValidMagnitude) {
2814 output.WriteRawTag(177, 4);
2815 output.WriteDouble(MaxValidMagnitude);
2817 if (HasDropMagnitude) {
2818 output.WriteRawTag(185, 4);
2819 output.WriteDouble(DropMagnitude);
2821 if (HasUseAbslRandom) {
2822 output.WriteRawTag(192, 4);
2823 output.WriteBool(UseAbslRandom);
2825 if (_unknownFields !=
null) {
2826 _unknownFields.WriteTo(ref output);
2831 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2832 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2833 public int CalculateSize() {
2835 if (HasScalingMethod) {
2836 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) ScalingMethod);
2838 if (HasFeasibilityRule) {
2839 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) FeasibilityRule);
2841 if (HasOptimizationRule) {
2842 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) OptimizationRule);
2844 if (HasRefactorizationThreshold) {
2847 if (HasRecomputeReducedCostsThreshold) {
2850 if (HasRecomputeEdgesNormThreshold) {
2853 if (HasPrimalFeasibilityTolerance) {
2856 if (HasDualFeasibilityTolerance) {
2859 if (HasRatioTestZeroThreshold) {
2862 if (HasHarrisToleranceRatio) {
2865 if (HasSmallPivotThreshold) {
2868 if (HasMinimumAcceptablePivot) {
2871 if (HasDropTolerance) {
2874 if (HasUseScaling) {
2877 if (HasCostScaling) {
2878 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) CostScaling);
2880 if (HasInitialBasis) {
2881 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) InitialBasis);
2883 if (HasUseTransposedMatrix) {
2886 if (HasBasisRefactorizationPeriod) {
2887 size += 2 + pb::CodedOutputStream.ComputeInt32Size(BasisRefactorizationPeriod);
2889 if (HasDynamicallyAdjustRefactorizationPeriod) {
2892 if (HasSolveDualProblem) {
2893 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) SolveDualProblem);
2895 if (HasDualizerThreshold) {
2898 if (HasSolutionFeasibilityTolerance) {
2901 if (HasProvideStrongOptimalGuarantee) {
2904 if (HasChangeStatusToImprecise) {
2907 if (HasMaxNumberOfReoptimizations) {
2910 if (HasLuFactorizationPivotThreshold) {
2913 if (HasMaxTimeInSeconds) {
2916 if (HasMaxDeterministicTime) {
2919 if (HasMaxNumberOfIterations) {
2920 size += 2 + pb::CodedOutputStream.ComputeInt64Size(MaxNumberOfIterations);
2922 if (HasMarkowitzZlatevParameter) {
2923 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MarkowitzZlatevParameter);
2925 if (HasMarkowitzSingularityThreshold) {
2928 if (HasUseDualSimplex) {
2931 if (HasAllowSimplexAlgorithmChange) {
2934 if (HasDevexWeightsResetPeriod) {
2935 size += 2 + pb::CodedOutputStream.ComputeInt32Size(DevexWeightsResetPeriod);
2937 if (HasUsePreprocessing) {
2940 if (HasUseMiddleProductFormUpdate) {
2943 if (HasInitializeDevexWithColumnNorms) {
2946 if (HasExploitSingletonColumnInInitialBasis) {
2949 if (HasDualSmallPivotThreshold) {
2952 if (HasPreprocessorZeroTolerance) {
2955 if (HasObjectiveLowerLimit) {
2958 if (HasObjectiveUpperLimit) {
2961 if (HasDegenerateMinistepFactor) {
2964 if (HasRandomSeed) {
2965 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RandomSeed);
2967 if (HasUseAbslRandom) {
2970 if (HasNumOmpThreads) {
2971 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumOmpThreads);
2973 if (HasPerturbCostsInDualSimplex) {
2976 if (HasUseDedicatedDualFeasibilityAlgorithm) {
2979 if (HasRelativeCostPerturbation) {
2982 if (HasRelativeMaxCostPerturbation) {
2985 if (HasInitialConditionNumberThreshold) {
2988 if (HasLogSearchProgress) {
2991 if (HasLogToStdout) {
2994 if (HasCrossoverBoundSnappingDistance) {
2997 if (HasPushToVertex) {
3000 if (HasUseImpliedFreePreprocessor) {
3003 if (HasMaxValidMagnitude) {
3006 if (HasDropMagnitude) {
3009 if (HasDualPricePrioritizeNorm) {
3012 if (_unknownFields !=
null) {
3013 size += _unknownFields.CalculateSize();
3018 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3019 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3020 public void MergeFrom(GlopParameters other) {
3021 if (other ==
null) {
3024 if (other.HasScalingMethod) {
3025 ScalingMethod = other.ScalingMethod;
3027 if (other.HasFeasibilityRule) {
3028 FeasibilityRule = other.FeasibilityRule;
3030 if (other.HasOptimizationRule) {
3031 OptimizationRule = other.OptimizationRule;
3033 if (other.HasRefactorizationThreshold) {
3034 RefactorizationThreshold = other.RefactorizationThreshold;
3036 if (other.HasRecomputeReducedCostsThreshold) {
3037 RecomputeReducedCostsThreshold = other.RecomputeReducedCostsThreshold;
3039 if (other.HasRecomputeEdgesNormThreshold) {
3042 if (other.HasPrimalFeasibilityTolerance) {
3043 PrimalFeasibilityTolerance = other.PrimalFeasibilityTolerance;
3045 if (other.HasDualFeasibilityTolerance) {
3046 DualFeasibilityTolerance = other.DualFeasibilityTolerance;
3048 if (other.HasRatioTestZeroThreshold) {
3049 RatioTestZeroThreshold = other.RatioTestZeroThreshold;
3051 if (other.HasHarrisToleranceRatio) {
3052 HarrisToleranceRatio = other.HarrisToleranceRatio;
3054 if (other.HasSmallPivotThreshold) {
3055 SmallPivotThreshold = other.SmallPivotThreshold;
3057 if (other.HasMinimumAcceptablePivot) {
3058 MinimumAcceptablePivot = other.MinimumAcceptablePivot;
3060 if (other.HasDropTolerance) {
3061 DropTolerance = other.DropTolerance;
3063 if (other.HasUseScaling) {
3064 UseScaling = other.UseScaling;
3066 if (other.HasCostScaling) {
3067 CostScaling = other.CostScaling;
3069 if (other.HasInitialBasis) {
3070 InitialBasis = other.InitialBasis;
3072 if (other.HasUseTransposedMatrix) {
3073 UseTransposedMatrix = other.UseTransposedMatrix;
3075 if (other.HasBasisRefactorizationPeriod) {
3076 BasisRefactorizationPeriod = other.BasisRefactorizationPeriod;
3078 if (other.HasDynamicallyAdjustRefactorizationPeriod) {
3079 DynamicallyAdjustRefactorizationPeriod = other.DynamicallyAdjustRefactorizationPeriod;
3081 if (other.HasSolveDualProblem) {
3082 SolveDualProblem = other.SolveDualProblem;
3084 if (other.HasDualizerThreshold) {
3085 DualizerThreshold = other.DualizerThreshold;
3087 if (other.HasSolutionFeasibilityTolerance) {
3088 SolutionFeasibilityTolerance = other.SolutionFeasibilityTolerance;
3090 if (other.HasProvideStrongOptimalGuarantee) {
3091 ProvideStrongOptimalGuarantee = other.ProvideStrongOptimalGuarantee;
3093 if (other.HasChangeStatusToImprecise) {
3094 ChangeStatusToImprecise = other.ChangeStatusToImprecise;
3096 if (other.HasMaxNumberOfReoptimizations) {
3097 MaxNumberOfReoptimizations = other.MaxNumberOfReoptimizations;
3099 if (other.HasLuFactorizationPivotThreshold) {
3100 LuFactorizationPivotThreshold = other.LuFactorizationPivotThreshold;
3102 if (other.HasMaxTimeInSeconds) {
3103 MaxTimeInSeconds = other.MaxTimeInSeconds;
3105 if (other.HasMaxDeterministicTime) {
3106 MaxDeterministicTime = other.MaxDeterministicTime;
3108 if (other.HasMaxNumberOfIterations) {
3109 MaxNumberOfIterations = other.MaxNumberOfIterations;
3111 if (other.HasMarkowitzZlatevParameter) {
3112 MarkowitzZlatevParameter = other.MarkowitzZlatevParameter;
3114 if (other.HasMarkowitzSingularityThreshold) {
3115 MarkowitzSingularityThreshold = other.MarkowitzSingularityThreshold;
3117 if (other.HasUseDualSimplex) {
3118 UseDualSimplex = other.UseDualSimplex;
3120 if (other.HasAllowSimplexAlgorithmChange) {
3121 AllowSimplexAlgorithmChange = other.AllowSimplexAlgorithmChange;
3123 if (other.HasDevexWeightsResetPeriod) {
3124 DevexWeightsResetPeriod = other.DevexWeightsResetPeriod;
3126 if (other.HasUsePreprocessing) {
3127 UsePreprocessing = other.UsePreprocessing;
3129 if (other.HasUseMiddleProductFormUpdate) {
3130 UseMiddleProductFormUpdate = other.UseMiddleProductFormUpdate;
3132 if (other.HasInitializeDevexWithColumnNorms) {
3133 InitializeDevexWithColumnNorms = other.InitializeDevexWithColumnNorms;
3135 if (other.HasExploitSingletonColumnInInitialBasis) {
3136 ExploitSingletonColumnInInitialBasis = other.ExploitSingletonColumnInInitialBasis;
3138 if (other.HasDualSmallPivotThreshold) {
3139 DualSmallPivotThreshold = other.DualSmallPivotThreshold;
3141 if (other.HasPreprocessorZeroTolerance) {
3142 PreprocessorZeroTolerance = other.PreprocessorZeroTolerance;
3144 if (other.HasObjectiveLowerLimit) {
3145 ObjectiveLowerLimit = other.ObjectiveLowerLimit;
3147 if (other.HasObjectiveUpperLimit) {
3148 ObjectiveUpperLimit = other.ObjectiveUpperLimit;
3150 if (other.HasDegenerateMinistepFactor) {
3151 DegenerateMinistepFactor = other.DegenerateMinistepFactor;
3153 if (other.HasRandomSeed) {
3154 RandomSeed = other.RandomSeed;
3156 if (other.HasUseAbslRandom) {
3157 UseAbslRandom = other.UseAbslRandom;
3159 if (other.HasNumOmpThreads) {
3160 NumOmpThreads = other.NumOmpThreads;
3162 if (other.HasPerturbCostsInDualSimplex) {
3163 PerturbCostsInDualSimplex = other.PerturbCostsInDualSimplex;
3165 if (other.HasUseDedicatedDualFeasibilityAlgorithm) {
3166 UseDedicatedDualFeasibilityAlgorithm = other.UseDedicatedDualFeasibilityAlgorithm;
3168 if (other.HasRelativeCostPerturbation) {
3169 RelativeCostPerturbation = other.RelativeCostPerturbation;
3171 if (other.HasRelativeMaxCostPerturbation) {
3172 RelativeMaxCostPerturbation = other.RelativeMaxCostPerturbation;
3174 if (other.HasInitialConditionNumberThreshold) {
3175 InitialConditionNumberThreshold = other.InitialConditionNumberThreshold;
3177 if (other.HasLogSearchProgress) {
3178 LogSearchProgress = other.LogSearchProgress;
3180 if (other.HasLogToStdout) {
3181 LogToStdout = other.LogToStdout;
3183 if (other.HasCrossoverBoundSnappingDistance) {
3184 CrossoverBoundSnappingDistance = other.CrossoverBoundSnappingDistance;
3186 if (other.HasPushToVertex) {
3187 PushToVertex = other.PushToVertex;
3189 if (other.HasUseImpliedFreePreprocessor) {
3190 UseImpliedFreePreprocessor = other.UseImpliedFreePreprocessor;
3192 if (other.HasMaxValidMagnitude) {
3193 MaxValidMagnitude = other.MaxValidMagnitude;
3195 if (other.HasDropMagnitude) {
3196 DropMagnitude = other.DropMagnitude;
3198 if (other.HasDualPricePrioritizeNorm) {
3199 DualPricePrioritizeNorm = other.DualPricePrioritizeNorm;
3201 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
3204 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3205 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3206 public void MergeFrom(pb::CodedInputStream input) {
3207 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3208 input.ReadRawMessage(
this);
3211 while ((tag = input.ReadTag()) != 0) {
3212 if ((tag & 7) == 4) {
3218 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
3221 FeasibilityRule = (global::Google.OrTools.Glop.GlopParameters.Types.PricingRule) input.ReadEnum();
3225 OptimizationRule = (global::Google.OrTools.Glop.GlopParameters.Types.PricingRule) input.ReadEnum();
3229 RefactorizationThreshold = input.ReadDouble();
3233 RecomputeReducedCostsThreshold = input.ReadDouble();
3237 RecomputeEdgesNormThreshold = input.ReadDouble();
3241 PrimalFeasibilityTolerance = input.ReadDouble();
3245 DualFeasibilityTolerance = input.ReadDouble();
3249 RatioTestZeroThreshold = input.ReadDouble();
3253 HarrisToleranceRatio = input.ReadDouble();
3257 SmallPivotThreshold = input.ReadDouble();
3261 MinimumAcceptablePivot = input.ReadDouble();
3265 UseScaling = input.ReadBool();
3269 InitialBasis = (global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic) input.ReadEnum();
3273 UseTransposedMatrix = input.ReadBool();
3277 BasisRefactorizationPeriod = input.ReadInt32();
3281 SolveDualProblem = (global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior) input.ReadEnum();
3285 DualizerThreshold = input.ReadDouble();
3289 SolutionFeasibilityTolerance = input.ReadDouble();
3293 ProvideStrongOptimalGuarantee = input.ReadBool();
3297 LuFactorizationPivotThreshold = input.ReadDouble();
3301 MaxTimeInSeconds = input.ReadDouble();
3305 MaxNumberOfIterations = input.ReadInt64();
3309 MarkowitzZlatevParameter = input.ReadInt32();
3313 MarkowitzSingularityThreshold = input.ReadDouble();
3317 UseDualSimplex = input.ReadBool();
3321 AllowSimplexAlgorithmChange = input.ReadBool();
3325 DevexWeightsResetPeriod = input.ReadInt32();
3329 UsePreprocessing = input.ReadBool();
3333 UseMiddleProductFormUpdate = input.ReadBool();
3337 InitializeDevexWithColumnNorms = input.ReadBool();
3341 ExploitSingletonColumnInInitialBasis = input.ReadBool();
3345 DualSmallPivotThreshold = input.ReadDouble();
3349 PreprocessorZeroTolerance = input.ReadDouble();
3353 ObjectiveLowerLimit = input.ReadDouble();
3357 ObjectiveUpperLimit = input.ReadDouble();
3361 DegenerateMinistepFactor = input.ReadDouble();
3365 RandomSeed = input.ReadInt32();
3369 NumOmpThreads = input.ReadInt32();
3373 MaxDeterministicTime = input.ReadDouble();
3377 DropTolerance = input.ReadDouble();
3381 PerturbCostsInDualSimplex = input.ReadBool();
3385 RelativeCostPerturbation = input.ReadDouble();
3389 RelativeMaxCostPerturbation = input.ReadDouble();
3393 MaxNumberOfReoptimizations = input.ReadDouble();
3397 ScalingMethod = (global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm) input.ReadEnum();
3401 ChangeStatusToImprecise = input.ReadBool();
3405 InitialConditionNumberThreshold = input.ReadDouble();
3409 CostScaling = (global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm) input.ReadEnum();
3413 LogSearchProgress = input.ReadBool();
3417 UseDedicatedDualFeasibilityAlgorithm = input.ReadBool();
3421 DynamicallyAdjustRefactorizationPeriod = input.ReadBool();
3425 CrossoverBoundSnappingDistance = input.ReadDouble();
3429 PushToVertex = input.ReadBool();
3433 LogToStdout = input.ReadBool();
3437 UseImpliedFreePreprocessor = input.ReadBool();
3441 DualPricePrioritizeNorm = input.ReadBool();
3445 MaxValidMagnitude = input.ReadDouble();
3449 DropMagnitude = input.ReadDouble();
3453 UseAbslRandom = input.ReadBool();
3461 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
3462 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3463 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3464 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
3466 while ((tag = input.ReadTag()) != 0) {
3467 if ((tag & 7) == 4) {
3473 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
3476 FeasibilityRule = (global::Google.OrTools.Glop.GlopParameters.Types.PricingRule) input.ReadEnum();
3480 OptimizationRule = (global::Google.OrTools.Glop.GlopParameters.Types.PricingRule) input.ReadEnum();
3484 RefactorizationThreshold = input.ReadDouble();
3488 RecomputeReducedCostsThreshold = input.ReadDouble();
3492 RecomputeEdgesNormThreshold = input.ReadDouble();
3496 PrimalFeasibilityTolerance = input.ReadDouble();
3500 DualFeasibilityTolerance = input.ReadDouble();
3504 RatioTestZeroThreshold = input.ReadDouble();
3508 HarrisToleranceRatio = input.ReadDouble();
3512 SmallPivotThreshold = input.ReadDouble();
3516 MinimumAcceptablePivot = input.ReadDouble();
3520 UseScaling = input.ReadBool();
3524 InitialBasis = (global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic) input.ReadEnum();
3528 UseTransposedMatrix = input.ReadBool();
3532 BasisRefactorizationPeriod = input.ReadInt32();
3536 SolveDualProblem = (global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior) input.ReadEnum();
3540 DualizerThreshold = input.ReadDouble();
3544 SolutionFeasibilityTolerance = input.ReadDouble();
3548 ProvideStrongOptimalGuarantee = input.ReadBool();
3552 LuFactorizationPivotThreshold = input.ReadDouble();
3556 MaxTimeInSeconds = input.ReadDouble();
3560 MaxNumberOfIterations = input.ReadInt64();
3564 MarkowitzZlatevParameter = input.ReadInt32();
3568 MarkowitzSingularityThreshold = input.ReadDouble();
3572 UseDualSimplex = input.ReadBool();
3576 AllowSimplexAlgorithmChange = input.ReadBool();
3580 DevexWeightsResetPeriod = input.ReadInt32();
3584 UsePreprocessing = input.ReadBool();
3588 UseMiddleProductFormUpdate = input.ReadBool();
3592 InitializeDevexWithColumnNorms = input.ReadBool();
3596 ExploitSingletonColumnInInitialBasis = input.ReadBool();
3600 DualSmallPivotThreshold = input.ReadDouble();
3604 PreprocessorZeroTolerance = input.ReadDouble();
3608 ObjectiveLowerLimit = input.ReadDouble();
3612 ObjectiveUpperLimit = input.ReadDouble();
3616 DegenerateMinistepFactor = input.ReadDouble();
3620 RandomSeed = input.ReadInt32();
3624 NumOmpThreads = input.ReadInt32();
3628 MaxDeterministicTime = input.ReadDouble();
3632 DropTolerance = input.ReadDouble();
3636 PerturbCostsInDualSimplex = input.ReadBool();
3640 RelativeCostPerturbation = input.ReadDouble();
3644 RelativeMaxCostPerturbation = input.ReadDouble();
3648 MaxNumberOfReoptimizations = input.ReadDouble();
3652 ScalingMethod = (global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm) input.ReadEnum();
3656 ChangeStatusToImprecise = input.ReadBool();
3660 InitialConditionNumberThreshold = input.ReadDouble();
3664 CostScaling = (global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm) input.ReadEnum();
3668 LogSearchProgress = input.ReadBool();
3672 UseDedicatedDualFeasibilityAlgorithm = input.ReadBool();
3676 DynamicallyAdjustRefactorizationPeriod = input.ReadBool();
3680 CrossoverBoundSnappingDistance = input.ReadDouble();
3684 PushToVertex = input.ReadBool();
3688 LogToStdout = input.ReadBool();
3692 UseImpliedFreePreprocessor = input.ReadBool();
3696 DualPricePrioritizeNorm = input.ReadBool();
3700 MaxValidMagnitude = input.ReadDouble();
3704 DropMagnitude = input.ReadDouble();
3708 UseAbslRandom = input.ReadBool();
3716 #region Nested types
3718 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3719 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3720 public static partial
class Types {
3728 public enum ScalingAlgorithm {
3729 [pbr::OriginalName(
"DEFAULT")] Default = 0,
3730 [pbr::OriginalName(
"EQUILIBRATION")] Equilibration = 1,
3731 [pbr::OriginalName(
"LINEAR_PROGRAM")] LinearProgram = 2,
3738 public enum SolverBehavior {
3740 [pbr::OriginalName(
"NEVER_DO")]
NeverDo = 1,
3756 [pbr::OriginalName(
"DANTZIG")]
Dantzig = 0,
3767 [pbr::OriginalName(
"DEVEX")]
Devex = 2,
3774 public enum InitialBasisHeuristic {
3778 [pbr::OriginalName(
"NONE")]
None = 0,
3795 [pbr::OriginalName(
"TRIANGULAR")]
Triangular = 2,
3801 [pbr::OriginalName(
"MAROS")]
Maros = 3,
3841#endregion Designer generated code