328 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
332 private static readonly pb::MessageParser<SatParameters> _parser =
new pb::MessageParser<SatParameters>(() =>
new SatParameters());
333 private pb::UnknownFieldSet _unknownFields;
334 private int _hasBits0;
335 private int _hasBits1;
336 private int _hasBits2;
337 private int _hasBits3;
338 private int _hasBits4;
339 private int _hasBits5;
340 private int _hasBits6;
341 private int _hasBits7;
342 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
343 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
344 public static pb::MessageParser<SatParameters>
Parser {
get {
return _parser; } }
346 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
347 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
348 public static pbr::MessageDescriptor
Descriptor {
349 get {
return global::Google.OrTools.Sat.SatParametersReflection.Descriptor.MessageTypes[0]; }
352 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
353 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
354 pbr::MessageDescriptor pb::IMessage.Descriptor {
358 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
359 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
364 partial
void OnConstruction();
366 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
367 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
369 _hasBits0 = other._hasBits0;
370 _hasBits1 = other._hasBits1;
371 _hasBits2 = other._hasBits2;
372 _hasBits3 = other._hasBits3;
373 _hasBits4 = other._hasBits4;
374 _hasBits5 = other._hasBits5;
375 _hasBits6 = other._hasBits6;
376 _hasBits7 = other._hasBits7;
378 preferredVariableOrder_ = other.preferredVariableOrder_;
379 initialPolarity_ = other.initialPolarity_;
380 usePhaseSaving_ = other.usePhaseSaving_;
381 polarityRephaseIncrement_ = other.polarityRephaseIncrement_;
382 randomPolarityRatio_ = other.randomPolarityRatio_;
383 randomBranchesRatio_ = other.randomBranchesRatio_;
384 useErwaHeuristic_ = other.useErwaHeuristic_;
385 initialVariablesActivity_ = other.initialVariablesActivity_;
386 alsoBumpVariablesInConflictReasons_ = other.alsoBumpVariablesInConflictReasons_;
387 minimizationAlgorithm_ = other.minimizationAlgorithm_;
388 binaryMinimizationAlgorithm_ = other.binaryMinimizationAlgorithm_;
389 subsumptionDuringConflictAnalysis_ = other.subsumptionDuringConflictAnalysis_;
390 clauseCleanupPeriod_ = other.clauseCleanupPeriod_;
391 clauseCleanupTarget_ = other.clauseCleanupTarget_;
392 clauseCleanupRatio_ = other.clauseCleanupRatio_;
393 clauseCleanupProtection_ = other.clauseCleanupProtection_;
394 clauseCleanupLbdBound_ = other.clauseCleanupLbdBound_;
395 clauseCleanupOrdering_ = other.clauseCleanupOrdering_;
396 pbCleanupIncrement_ = other.pbCleanupIncrement_;
397 pbCleanupRatio_ = other.pbCleanupRatio_;
398 variableActivityDecay_ = other.variableActivityDecay_;
399 maxVariableActivityValue_ = other.maxVariableActivityValue_;
400 glucoseMaxDecay_ = other.glucoseMaxDecay_;
401 glucoseDecayIncrement_ = other.glucoseDecayIncrement_;
402 glucoseDecayIncrementPeriod_ = other.glucoseDecayIncrementPeriod_;
403 clauseActivityDecay_ = other.clauseActivityDecay_;
404 maxClauseActivityValue_ = other.maxClauseActivityValue_;
405 restartAlgorithms_ = other.restartAlgorithms_.Clone();
406 defaultRestartAlgorithms_ = other.defaultRestartAlgorithms_;
407 restartPeriod_ = other.restartPeriod_;
408 restartRunningWindowSize_ = other.restartRunningWindowSize_;
409 restartDlAverageRatio_ = other.restartDlAverageRatio_;
410 restartLbdAverageRatio_ = other.restartLbdAverageRatio_;
411 useBlockingRestart_ = other.useBlockingRestart_;
412 blockingRestartWindowSize_ = other.blockingRestartWindowSize_;
413 blockingRestartMultiplier_ = other.blockingRestartMultiplier_;
414 numConflictsBeforeStrategyChanges_ = other.numConflictsBeforeStrategyChanges_;
415 strategyChangeIncreaseRatio_ = other.strategyChangeIncreaseRatio_;
416 maxTimeInSeconds_ = other.maxTimeInSeconds_;
417 maxDeterministicTime_ = other.maxDeterministicTime_;
418 maxNumDeterministicBatches_ = other.maxNumDeterministicBatches_;
419 maxNumberOfConflicts_ = other.maxNumberOfConflicts_;
420 maxMemoryInMb_ = other.maxMemoryInMb_;
421 absoluteGapLimit_ = other.absoluteGapLimit_;
422 relativeGapLimit_ = other.relativeGapLimit_;
423 randomSeed_ = other.randomSeed_;
424 permuteVariableRandomly_ = other.permuteVariableRandomly_;
425 permutePresolveConstraintOrder_ = other.permutePresolveConstraintOrder_;
426 useAbslRandom_ = other.useAbslRandom_;
427 logSearchProgress_ = other.logSearchProgress_;
428 logSubsolverStatistics_ = other.logSubsolverStatistics_;
429 logPrefix_ = other.logPrefix_;
430 logToStdout_ = other.logToStdout_;
431 logToResponse_ = other.logToResponse_;
432 usePbResolution_ = other.usePbResolution_;
433 minimizeReductionDuringPbResolution_ = other.minimizeReductionDuringPbResolution_;
434 countAssumptionLevelsInLbd_ = other.countAssumptionLevelsInLbd_;
435 presolveBveThreshold_ = other.presolveBveThreshold_;
436 presolveBveClauseWeight_ = other.presolveBveClauseWeight_;
437 probingDeterministicTimeLimit_ = other.probingDeterministicTimeLimit_;
438 presolveProbingDeterministicTimeLimit_ = other.presolveProbingDeterministicTimeLimit_;
439 presolveBlockedClause_ = other.presolveBlockedClause_;
440 presolveUseBva_ = other.presolveUseBva_;
441 presolveBvaThreshold_ = other.presolveBvaThreshold_;
442 maxPresolveIterations_ = other.maxPresolveIterations_;
443 cpModelPresolve_ = other.cpModelPresolve_;
444 cpModelProbingLevel_ = other.cpModelProbingLevel_;
445 cpModelUseSatPresolve_ = other.cpModelUseSatPresolve_;
446 detectTableWithCost_ = other.detectTableWithCost_;
447 tableCompressionLevel_ = other.tableCompressionLevel_;
448 expandAlldiffConstraints_ = other.expandAlldiffConstraints_;
449 expandReservoirConstraints_ = other.expandReservoirConstraints_;
450 expandReservoirUsingCircuit_ = other.expandReservoirUsingCircuit_;
451 encodeCumulativeAsReservoir_ = other.encodeCumulativeAsReservoir_;
452 maxLinMaxSizeForExpansion_ = other.maxLinMaxSizeForExpansion_;
453 disableConstraintExpansion_ = other.disableConstraintExpansion_;
454 encodeComplexLinearConstraintWithInteger_ = other.encodeComplexLinearConstraintWithInteger_;
455 mergeNoOverlapWorkLimit_ = other.mergeNoOverlapWorkLimit_;
456 mergeAtMostOneWorkLimit_ = other.mergeAtMostOneWorkLimit_;
457 presolveSubstitutionLevel_ = other.presolveSubstitutionLevel_;
458 presolveExtractIntegerEnforcement_ = other.presolveExtractIntegerEnforcement_;
459 presolveInclusionWorkLimit_ = other.presolveInclusionWorkLimit_;
460 ignoreNames_ = other.ignoreNames_;
461 inferAllDiffs_ = other.inferAllDiffs_;
462 findBigLinearOverlap_ = other.findBigLinearOverlap_;
463 useSatInprocessing_ = other.useSatInprocessing_;
464 inprocessingDtimeRatio_ = other.inprocessingDtimeRatio_;
465 inprocessingProbingDtime_ = other.inprocessingProbingDtime_;
466 inprocessingMinimizationDtime_ = other.inprocessingMinimizationDtime_;
467 numWorkers_ = other.numWorkers_;
468 numSearchWorkers_ = other.numSearchWorkers_;
469 numFullSubsolvers_ = other.numFullSubsolvers_;
470 subsolvers_ = other.subsolvers_.Clone();
471 extraSubsolvers_ = other.extraSubsolvers_.Clone();
472 ignoreSubsolvers_ = other.ignoreSubsolvers_.Clone();
473 filterSubsolvers_ = other.filterSubsolvers_.Clone();
474 subsolverParams_ = other.subsolverParams_.Clone();
475 interleaveSearch_ = other.interleaveSearch_;
476 interleaveBatchSize_ = other.interleaveBatchSize_;
477 shareObjectiveBounds_ = other.shareObjectiveBounds_;
478 shareLevelZeroBounds_ = other.shareLevelZeroBounds_;
479 shareBinaryClauses_ = other.shareBinaryClauses_;
480 shareGlueClauses_ = other.shareGlueClauses_;
481 debugPostsolveWithFullSolver_ = other.debugPostsolveWithFullSolver_;
482 debugMaxNumPresolveOperations_ = other.debugMaxNumPresolveOperations_;
483 debugCrashOnBadHint_ = other.debugCrashOnBadHint_;
484 useOptimizationHints_ = other.useOptimizationHints_;
485 coreMinimizationLevel_ = other.coreMinimizationLevel_;
486 findMultipleCores_ = other.findMultipleCores_;
487 coverOptimization_ = other.coverOptimization_;
488 maxSatAssumptionOrder_ = other.maxSatAssumptionOrder_;
489 maxSatReverseAssumptionOrder_ = other.maxSatReverseAssumptionOrder_;
490 maxSatStratification_ = other.maxSatStratification_;
491 propagationLoopDetectionFactor_ = other.propagationLoopDetectionFactor_;
492 usePrecedencesInDisjunctiveConstraint_ = other.usePrecedencesInDisjunctiveConstraint_;
493 maxSizeToCreatePrecedenceLiteralsInDisjunctive_ = other.maxSizeToCreatePrecedenceLiteralsInDisjunctive_;
494 useStrongPropagationInDisjunctive_ = other.useStrongPropagationInDisjunctive_;
495 useDynamicPrecedenceInDisjunctive_ = other.useDynamicPrecedenceInDisjunctive_;
496 useDynamicPrecedenceInCumulative_ = other.useDynamicPrecedenceInCumulative_;
497 useOverloadCheckerInCumulative_ = other.useOverloadCheckerInCumulative_;
498 useConservativeScaleOverloadChecker_ = other.useConservativeScaleOverloadChecker_;
499 useTimetableEdgeFindingInCumulative_ = other.useTimetableEdgeFindingInCumulative_;
500 maxNumIntervalsForTimetableEdgeFinding_ = other.maxNumIntervalsForTimetableEdgeFinding_;
501 useHardPrecedencesInCumulative_ = other.useHardPrecedencesInCumulative_;
502 exploitAllPrecedences_ = other.exploitAllPrecedences_;
503 useDisjunctiveConstraintInCumulative_ = other.useDisjunctiveConstraintInCumulative_;
504 useTimetablingInNoOverlap2D_ = other.useTimetablingInNoOverlap2D_;
505 useEnergeticReasoningInNoOverlap2D_ = other.useEnergeticReasoningInNoOverlap2D_;
506 useAreaEnergeticReasoningInNoOverlap2D_ = other.useAreaEnergeticReasoningInNoOverlap2D_;
507 maxPairsPairwiseReasoningInNoOverlap2D_ = other.maxPairsPairwiseReasoningInNoOverlap2D_;
508 useDualSchedulingHeuristics_ = other.useDualSchedulingHeuristics_;
509 searchBranching_ = other.searchBranching_;
510 hintConflictLimit_ = other.hintConflictLimit_;
511 repairHint_ = other.repairHint_;
512 fixVariablesToTheirHintedValue_ = other.fixVariablesToTheirHintedValue_;
513 useProbingSearch_ = other.useProbingSearch_;
514 useExtendedProbing_ = other.useExtendedProbing_;
515 probingNumCombinationsLimit_ = other.probingNumCombinationsLimit_;
516 useShavingInProbingSearch_ = other.useShavingInProbingSearch_;
517 shavingSearchDeterministicTime_ = other.shavingSearchDeterministicTime_;
518 shavingSearchThreshold_ = other.shavingSearchThreshold_;
519 useObjectiveLbSearch_ = other.useObjectiveLbSearch_;
520 useObjectiveShavingSearch_ = other.useObjectiveShavingSearch_;
521 useVariablesShavingSearch_ = other.useVariablesShavingSearch_;
522 pseudoCostReliabilityThreshold_ = other.pseudoCostReliabilityThreshold_;
523 optimizeWithCore_ = other.optimizeWithCore_;
524 optimizeWithLbTreeSearch_ = other.optimizeWithLbTreeSearch_;
525 saveLpBasisInLbTreeSearch_ = other.saveLpBasisInLbTreeSearch_;
526 binarySearchNumConflicts_ = other.binarySearchNumConflicts_;
527 optimizeWithMaxHs_ = other.optimizeWithMaxHs_;
528 useFeasibilityJump_ = other.useFeasibilityJump_;
529 useLsOnly_ = other.useLsOnly_;
530 feasibilityJumpDecay_ = other.feasibilityJumpDecay_;
531 feasibilityJumpLinearizationLevel_ = other.feasibilityJumpLinearizationLevel_;
532 feasibilityJumpRestartFactor_ = other.feasibilityJumpRestartFactor_;
533 feasibilityJumpBatchDtime_ = other.feasibilityJumpBatchDtime_;
534 feasibilityJumpVarRandomizationProbability_ = other.feasibilityJumpVarRandomizationProbability_;
535 feasibilityJumpVarPerburbationRangeRatio_ = other.feasibilityJumpVarPerburbationRangeRatio_;
536 feasibilityJumpEnableRestarts_ = other.feasibilityJumpEnableRestarts_;
537 feasibilityJumpMaxExpandedConstraintSize_ = other.feasibilityJumpMaxExpandedConstraintSize_;
538 numViolationLs_ = other.numViolationLs_;
539 violationLsPerturbationPeriod_ = other.violationLsPerturbationPeriod_;
540 violationLsCompoundMoveProbability_ = other.violationLsCompoundMoveProbability_;
541 sharedTreeNumWorkers_ = other.sharedTreeNumWorkers_;
542 useSharedTreeSearch_ = other.useSharedTreeSearch_;
543 sharedTreeWorkerObjectiveSplitProbability_ = other.sharedTreeWorkerObjectiveSplitProbability_;
544 sharedTreeWorkerMinRestartsPerSubtree_ = other.sharedTreeWorkerMinRestartsPerSubtree_;
545 sharedTreeWorkerEnableTrailSharing_ = other.sharedTreeWorkerEnableTrailSharing_;
546 sharedTreeOpenLeavesPerWorker_ = other.sharedTreeOpenLeavesPerWorker_;
547 sharedTreeMaxNodesPerWorker_ = other.sharedTreeMaxNodesPerWorker_;
548 sharedTreeSplitStrategy_ = other.sharedTreeSplitStrategy_;
549 enumerateAllSolutions_ = other.enumerateAllSolutions_;
550 keepAllFeasibleSolutionsInPresolve_ = other.keepAllFeasibleSolutionsInPresolve_;
551 fillTightenedDomainsInResponse_ = other.fillTightenedDomainsInResponse_;
552 fillAdditionalSolutionsInResponse_ = other.fillAdditionalSolutionsInResponse_;
553 instantiateAllVariables_ = other.instantiateAllVariables_;
554 autoDetectGreaterThanAtLeastOneOf_ = other.autoDetectGreaterThanAtLeastOneOf_;
555 stopAfterFirstSolution_ = other.stopAfterFirstSolution_;
556 stopAfterPresolve_ = other.stopAfterPresolve_;
557 stopAfterRootPropagation_ = other.stopAfterRootPropagation_;
558 useLns_ = other.useLns_;
559 useLnsOnly_ = other.useLnsOnly_;
560 solutionPoolSize_ = other.solutionPoolSize_;
561 useRinsLns_ = other.useRinsLns_;
562 useFeasibilityPump_ = other.useFeasibilityPump_;
563 useLbRelaxLns_ = other.useLbRelaxLns_;
564 fpRounding_ = other.fpRounding_;
565 diversifyLnsParams_ = other.diversifyLnsParams_;
566 randomizeSearch_ = other.randomizeSearch_;
567 searchRandomVariablePoolSize_ = other.searchRandomVariablePoolSize_;
568 pushAllTasksTowardStart_ = other.pushAllTasksTowardStart_;
569 useOptionalVariables_ = other.useOptionalVariables_;
570 useExactLpReason_ = other.useExactLpReason_;
571 useCombinedNoOverlap_ = other.useCombinedNoOverlap_;
572 atMostOneMaxExpansionSize_ = other.atMostOneMaxExpansionSize_;
573 catchSigintSignal_ = other.catchSigintSignal_;
574 useImpliedBounds_ = other.useImpliedBounds_;
575 polishLpSolution_ = other.polishLpSolution_;
576 lpPrimalTolerance_ = other.lpPrimalTolerance_;
577 lpDualTolerance_ = other.lpDualTolerance_;
578 convertIntervals_ = other.convertIntervals_;
579 symmetryLevel_ = other.symmetryLevel_;
580 newLinearPropagation_ = other.newLinearPropagation_;
581 linearSplitSize_ = other.linearSplitSize_;
582 linearizationLevel_ = other.linearizationLevel_;
583 booleanEncodingLevel_ = other.booleanEncodingLevel_;
584 maxDomainSizeWhenEncodingEqNeqConstraints_ = other.maxDomainSizeWhenEncodingEqNeqConstraints_;
585 maxNumCuts_ = other.maxNumCuts_;
586 cutLevel_ = other.cutLevel_;
587 onlyAddCutsAtLevelZero_ = other.onlyAddCutsAtLevelZero_;
588 addObjectiveCut_ = other.addObjectiveCut_;
589 addCgCuts_ = other.addCgCuts_;
590 addMirCuts_ = other.addMirCuts_;
591 addZeroHalfCuts_ = other.addZeroHalfCuts_;
592 addCliqueCuts_ = other.addCliqueCuts_;
593 addRltCuts_ = other.addRltCuts_;
594 maxAllDiffCutSize_ = other.maxAllDiffCutSize_;
595 addLinMaxCuts_ = other.addLinMaxCuts_;
596 maxIntegerRoundingScaling_ = other.maxIntegerRoundingScaling_;
597 addLpConstraintsLazily_ = other.addLpConstraintsLazily_;
598 rootLpIterations_ = other.rootLpIterations_;
599 minOrthogonalityForLpConstraints_ = other.minOrthogonalityForLpConstraints_;
600 maxCutRoundsAtLevelZero_ = other.maxCutRoundsAtLevelZero_;
601 maxConsecutiveInactiveCount_ = other.maxConsecutiveInactiveCount_;
602 cutMaxActiveCountValue_ = other.cutMaxActiveCountValue_;
603 cutActiveCountDecay_ = other.cutActiveCountDecay_;
604 cutCleanupTarget_ = other.cutCleanupTarget_;
605 newConstraintsBatchSize_ = other.newConstraintsBatchSize_;
606 exploitIntegerLpSolution_ = other.exploitIntegerLpSolution_;
607 exploitAllLpSolution_ = other.exploitAllLpSolution_;
608 exploitBestSolution_ = other.exploitBestSolution_;
609 exploitRelaxationSolution_ = other.exploitRelaxationSolution_;
610 exploitObjective_ = other.exploitObjective_;
611 detectLinearizedProduct_ = other.detectLinearizedProduct_;
612 mipMaxBound_ = other.mipMaxBound_;
613 mipVarScaling_ = other.mipVarScaling_;
614 mipScaleLargeDomain_ = other.mipScaleLargeDomain_;
615 mipAutomaticallyScaleVariables_ = other.mipAutomaticallyScaleVariables_;
616 onlySolveIp_ = other.onlySolveIp_;
617 mipWantedPrecision_ = other.mipWantedPrecision_;
618 mipMaxActivityExponent_ = other.mipMaxActivityExponent_;
619 mipCheckPrecision_ = other.mipCheckPrecision_;
620 mipComputeTrueObjectiveBound_ = other.mipComputeTrueObjectiveBound_;
621 mipMaxValidMagnitude_ = other.mipMaxValidMagnitude_;
622 mipTreatHighMagnitudeBoundsAsInfinity_ = other.mipTreatHighMagnitudeBoundsAsInfinity_;
623 mipDropTolerance_ = other.mipDropTolerance_;
624 mipPresolveLevel_ = other.mipPresolveLevel_;
625 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
628 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
629 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
636 private readonly
static string NameDefaultValue =
"";
638 private string name_;
643 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
644 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
646 get {
return name_ ?? NameDefaultValue; }
648 name_ = pb::ProtoPreconditions.CheckNotNull(value,
"value");
652 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
653 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
655 get {
return name_ !=
null; }
658 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
659 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
666 private readonly
static global::Google.OrTools.Sat.
SatParameters.Types.VariableOrder PreferredVariableOrderDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.VariableOrder.InOrder;
668 private global::Google.OrTools.Sat.SatParameters.Types.VariableOrder preferredVariableOrder_;
669 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
670 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
672 get { if ((_hasBits0 & 1) != 0) { return preferredVariableOrder_; } else { return PreferredVariableOrderDefaultValue; } }
675 preferredVariableOrder_ = value;
679 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
680 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
681 public bool HasPreferredVariableOrder {
682 get {
return (_hasBits0 & 1) != 0; }
685 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
686 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
687 public void ClearPreferredVariableOrder() {
692 public const int InitialPolarityFieldNumber = 2;
693 private readonly
static global::Google.OrTools.Sat.
SatParameters.Types.Polarity InitialPolarityDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.Polarity.False;
695 private global::Google.OrTools.Sat.SatParameters.Types.Polarity initialPolarity_;
696 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
697 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
698 public global::Google.OrTools.Sat.SatParameters.Types.Polarity InitialPolarity {
699 get { if ((_hasBits0 & 2) != 0) { return initialPolarity_; } else { return InitialPolarityDefaultValue; } }
702 initialPolarity_ = value;
706 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
707 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
708 public bool HasInitialPolarity {
709 get {
return (_hasBits0 & 2) != 0; }
712 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
713 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
714 public void ClearInitialPolarity() {
719 public const int UsePhaseSavingFieldNumber = 44;
720 private readonly
static bool UsePhaseSavingDefaultValue =
true;
722 private bool usePhaseSaving_;
736 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
737 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
738 public bool UsePhaseSaving {
739 get {
if ((_hasBits0 & 4194304) != 0) {
return usePhaseSaving_; }
else {
return UsePhaseSavingDefaultValue; } }
741 _hasBits0 |= 4194304;
742 usePhaseSaving_ = value;
746 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
747 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
748 public bool HasUsePhaseSaving {
749 get {
return (_hasBits0 & 4194304) != 0; }
752 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
753 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
754 public void ClearUsePhaseSaving() {
755 _hasBits0 &= ~4194304;
759 public const int PolarityRephaseIncrementFieldNumber = 168;
760 private readonly
static int PolarityRephaseIncrementDefaultValue = 1000;
762 private int polarityRephaseIncrement_;
768 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
769 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
770 public int PolarityRephaseIncrement {
771 get {
if ((_hasBits4 & 4) != 0) {
return polarityRephaseIncrement_; }
else {
return PolarityRephaseIncrementDefaultValue; } }
774 polarityRephaseIncrement_ = value;
778 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
779 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
780 public bool HasPolarityRephaseIncrement {
781 get {
return (_hasBits4 & 4) != 0; }
784 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
785 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
786 public void ClearPolarityRephaseIncrement() {
791 public const int RandomPolarityRatioFieldNumber = 45;
792 private readonly
static double RandomPolarityRatioDefaultValue = 0D;
794 private double randomPolarityRatio_;
802 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
803 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
804 public double RandomPolarityRatio {
805 get {
if ((_hasBits0 & 8388608) != 0) {
return randomPolarityRatio_; }
else {
return RandomPolarityRatioDefaultValue; } }
807 _hasBits0 |= 8388608;
808 randomPolarityRatio_ = value;
812 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
813 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
814 public bool HasRandomPolarityRatio {
815 get {
return (_hasBits0 & 8388608) != 0; }
818 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
819 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
820 public void ClearRandomPolarityRatio() {
821 _hasBits0 &= ~8388608;
825 public const int RandomBranchesRatioFieldNumber = 32;
826 private readonly
static double RandomBranchesRatioDefaultValue = 0D;
828 private double randomBranchesRatio_;
834 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
835 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
836 public double RandomBranchesRatio {
837 get {
if ((_hasBits0 & 16384) != 0) {
return randomBranchesRatio_; }
else {
return RandomBranchesRatioDefaultValue; } }
840 randomBranchesRatio_ = value;
844 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
845 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
846 public bool HasRandomBranchesRatio {
847 get {
return (_hasBits0 & 16384) != 0; }
850 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
851 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
852 public void ClearRandomBranchesRatio() {
857 public const int UseErwaHeuristicFieldNumber = 75;
858 private readonly
static bool UseErwaHeuristicDefaultValue =
false;
860 private bool useErwaHeuristic_;
866 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
867 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
868 public bool UseErwaHeuristic {
869 get {
if ((_hasBits1 & 524288) != 0) {
return useErwaHeuristic_; }
else {
return UseErwaHeuristicDefaultValue; } }
872 useErwaHeuristic_ = value;
876 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
877 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
878 public bool HasUseErwaHeuristic {
879 get {
return (_hasBits1 & 524288) != 0; }
882 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
883 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
884 public void ClearUseErwaHeuristic() {
885 _hasBits1 &= ~524288;
889 public const int InitialVariablesActivityFieldNumber = 76;
890 private readonly
static double InitialVariablesActivityDefaultValue = 0D;
892 private double initialVariablesActivity_;
901 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
902 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
903 public double InitialVariablesActivity {
904 get {
if ((_hasBits1 & 1048576) != 0) {
return initialVariablesActivity_; }
else {
return InitialVariablesActivityDefaultValue; } }
906 _hasBits1 |= 1048576;
907 initialVariablesActivity_ = value;
911 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
912 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
913 public bool HasInitialVariablesActivity {
914 get {
return (_hasBits1 & 1048576) != 0; }
917 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
918 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
919 public void ClearInitialVariablesActivity() {
920 _hasBits1 &= ~1048576;
924 public const int AlsoBumpVariablesInConflictReasonsFieldNumber = 77;
925 private readonly
static bool AlsoBumpVariablesInConflictReasonsDefaultValue =
false;
927 private bool alsoBumpVariablesInConflictReasons_;
934 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
935 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
936 public bool AlsoBumpVariablesInConflictReasons {
937 get {
if ((_hasBits1 & 2097152) != 0) {
return alsoBumpVariablesInConflictReasons_; }
else {
return AlsoBumpVariablesInConflictReasonsDefaultValue; } }
939 _hasBits1 |= 2097152;
940 alsoBumpVariablesInConflictReasons_ = value;
944 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
945 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
946 public bool HasAlsoBumpVariablesInConflictReasons {
947 get {
return (_hasBits1 & 2097152) != 0; }
950 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
951 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
952 public void ClearAlsoBumpVariablesInConflictReasons() {
953 _hasBits1 &= ~2097152;
957 public const int MinimizationAlgorithmFieldNumber = 4;
958 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm MinimizationAlgorithmDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm.Recursive;
960 private global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm minimizationAlgorithm_;
961 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
962 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
963 public global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm MinimizationAlgorithm {
964 get { if ((_hasBits0 & 4) != 0) { return minimizationAlgorithm_; } else { return MinimizationAlgorithmDefaultValue; } }
967 minimizationAlgorithm_ = value;
971 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
972 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
973 public bool HasMinimizationAlgorithm {
974 get {
return (_hasBits0 & 4) != 0; }
977 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
978 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
979 public void ClearMinimizationAlgorithm() {
984 public const int BinaryMinimizationAlgorithmFieldNumber = 34;
985 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm BinaryMinimizationAlgorithmDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm.BinaryMinimizationFirst;
987 private global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm binaryMinimizationAlgorithm_;
988 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
989 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
990 public global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm BinaryMinimizationAlgorithm {
991 get { if ((_hasBits0 & 32768) != 0) { return binaryMinimizationAlgorithm_; } else { return BinaryMinimizationAlgorithmDefaultValue; } }
994 binaryMinimizationAlgorithm_ = value;
998 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
999 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1000 public bool HasBinaryMinimizationAlgorithm {
1001 get {
return (_hasBits0 & 32768) != 0; }
1004 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1005 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1006 public void ClearBinaryMinimizationAlgorithm() {
1007 _hasBits0 &= ~32768;
1011 public const int SubsumptionDuringConflictAnalysisFieldNumber = 56;
1012 private readonly
static bool SubsumptionDuringConflictAnalysisDefaultValue =
true;
1014 private bool subsumptionDuringConflictAnalysis_;
1021 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1022 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1023 public bool SubsumptionDuringConflictAnalysis {
1024 get {
if ((_hasBits1 & 4) != 0) {
return subsumptionDuringConflictAnalysis_; }
else {
return SubsumptionDuringConflictAnalysisDefaultValue; } }
1027 subsumptionDuringConflictAnalysis_ = value;
1031 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1032 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1033 public bool HasSubsumptionDuringConflictAnalysis {
1034 get {
return (_hasBits1 & 4) != 0; }
1037 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1038 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1039 public void ClearSubsumptionDuringConflictAnalysis() {
1044 public const int ClauseCleanupPeriodFieldNumber = 11;
1045 private readonly
static int ClauseCleanupPeriodDefaultValue = 10000;
1047 private int clauseCleanupPeriod_;
1051 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1052 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1053 public int ClauseCleanupPeriod {
1054 get {
if ((_hasBits0 & 8) != 0) {
return clauseCleanupPeriod_; }
else {
return ClauseCleanupPeriodDefaultValue; } }
1057 clauseCleanupPeriod_ = value;
1061 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1062 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1063 public bool HasClauseCleanupPeriod {
1064 get {
return (_hasBits0 & 8) != 0; }
1067 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1068 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1069 public void ClearClauseCleanupPeriod() {
1074 public const int ClauseCleanupTargetFieldNumber = 13;
1075 private readonly
static int ClauseCleanupTargetDefaultValue = 0;
1077 private int clauseCleanupTarget_;
1082 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1083 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1084 public int ClauseCleanupTarget {
1085 get {
if ((_hasBits0 & 16) != 0) {
return clauseCleanupTarget_; }
else {
return ClauseCleanupTargetDefaultValue; } }
1088 clauseCleanupTarget_ = value;
1092 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1093 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1094 public bool HasClauseCleanupTarget {
1095 get {
return (_hasBits0 & 16) != 0; }
1098 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1099 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1100 public void ClearClauseCleanupTarget() {
1105 public const int ClauseCleanupRatioFieldNumber = 190;
1106 private readonly
static double ClauseCleanupRatioDefaultValue = 0.5D;
1108 private double clauseCleanupRatio_;
1114 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1115 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1116 public double ClauseCleanupRatio {
1117 get {
if ((_hasBits4 & 2097152) != 0) {
return clauseCleanupRatio_; }
else {
return ClauseCleanupRatioDefaultValue; } }
1119 _hasBits4 |= 2097152;
1120 clauseCleanupRatio_ = value;
1124 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1125 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1126 public bool HasClauseCleanupRatio {
1127 get {
return (_hasBits4 & 2097152) != 0; }
1130 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1131 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1132 public void ClearClauseCleanupRatio() {
1133 _hasBits4 &= ~2097152;
1137 public const int ClauseCleanupProtectionFieldNumber = 58;
1138 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.ClauseProtection ClauseCleanupProtectionDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.ClauseProtection.ProtectionNone;
1140 private global::Google.OrTools.Sat.SatParameters.Types.ClauseProtection clauseCleanupProtection_;
1141 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1142 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1143 public global::Google.OrTools.Sat.SatParameters.Types.ClauseProtection ClauseCleanupProtection {
1144 get { if ((_hasBits1 & 16) != 0) { return clauseCleanupProtection_; } else { return ClauseCleanupProtectionDefaultValue; } }
1147 clauseCleanupProtection_ = value;
1151 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1152 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1153 public bool HasClauseCleanupProtection {
1154 get {
return (_hasBits1 & 16) != 0; }
1157 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1158 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1159 public void ClearClauseCleanupProtection() {
1164 public const int ClauseCleanupLbdBoundFieldNumber = 59;
1165 private readonly
static int ClauseCleanupLbdBoundDefaultValue = 5;
1167 private int clauseCleanupLbdBound_;
1172 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1173 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1174 public int ClauseCleanupLbdBound {
1175 get {
if ((_hasBits1 & 32) != 0) {
return clauseCleanupLbdBound_; }
else {
return ClauseCleanupLbdBoundDefaultValue; } }
1178 clauseCleanupLbdBound_ = value;
1182 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1183 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1184 public bool HasClauseCleanupLbdBound {
1185 get {
return (_hasBits1 & 32) != 0; }
1188 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1189 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1190 public void ClearClauseCleanupLbdBound() {
1195 public const int ClauseCleanupOrderingFieldNumber = 60;
1196 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering ClauseCleanupOrderingDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering.ClauseActivity;
1198 private global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering clauseCleanupOrdering_;
1199 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1200 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1201 public global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering ClauseCleanupOrdering {
1202 get { if ((_hasBits1 & 64) != 0) { return clauseCleanupOrdering_; } else { return ClauseCleanupOrderingDefaultValue; } }
1205 clauseCleanupOrdering_ = value;
1209 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1210 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1211 public bool HasClauseCleanupOrdering {
1212 get {
return (_hasBits1 & 64) != 0; }
1215 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1216 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1217 public void ClearClauseCleanupOrdering() {
1222 public const int PbCleanupIncrementFieldNumber = 46;
1223 private readonly
static int PbCleanupIncrementDefaultValue = 200;
1225 private int pbCleanupIncrement_;
1229 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1230 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1231 public int PbCleanupIncrement {
1232 get {
if ((_hasBits0 & 16777216) != 0) {
return pbCleanupIncrement_; }
else {
return PbCleanupIncrementDefaultValue; } }
1234 _hasBits0 |= 16777216;
1235 pbCleanupIncrement_ = value;
1239 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1240 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1241 public bool HasPbCleanupIncrement {
1242 get {
return (_hasBits0 & 16777216) != 0; }
1245 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1246 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1247 public void ClearPbCleanupIncrement() {
1248 _hasBits0 &= ~16777216;
1252 public const int PbCleanupRatioFieldNumber = 47;
1253 private readonly
static double PbCleanupRatioDefaultValue = 0.5D;
1255 private double pbCleanupRatio_;
1256 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1257 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1258 public double PbCleanupRatio {
1259 get {
if ((_hasBits0 & 33554432) != 0) {
return pbCleanupRatio_; }
else {
return PbCleanupRatioDefaultValue; } }
1261 _hasBits0 |= 33554432;
1262 pbCleanupRatio_ = value;
1266 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1267 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1268 public bool HasPbCleanupRatio {
1269 get {
return (_hasBits0 & 33554432) != 0; }
1272 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1273 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1274 public void ClearPbCleanupRatio() {
1275 _hasBits0 &= ~33554432;
1279 public const int VariableActivityDecayFieldNumber = 15;
1280 private readonly
static double VariableActivityDecayDefaultValue = 0.8D;
1282 private double variableActivityDecay_;
1293 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1294 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1295 public double VariableActivityDecay {
1296 get {
if ((_hasBits0 & 32) != 0) {
return variableActivityDecay_; }
else {
return VariableActivityDecayDefaultValue; } }
1299 variableActivityDecay_ = value;
1303 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1304 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1305 public bool HasVariableActivityDecay {
1306 get {
return (_hasBits0 & 32) != 0; }
1309 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1310 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1311 public void ClearVariableActivityDecay() {
1316 public const int MaxVariableActivityValueFieldNumber = 16;
1317 private readonly
static double MaxVariableActivityValueDefaultValue = 1e+100D;
1319 private double maxVariableActivityValue_;
1320 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1321 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1322 public double MaxVariableActivityValue {
1323 get {
if ((_hasBits0 & 64) != 0) {
return maxVariableActivityValue_; }
else {
return MaxVariableActivityValueDefaultValue; } }
1326 maxVariableActivityValue_ = value;
1330 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1331 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1332 public bool HasMaxVariableActivityValue {
1333 get {
return (_hasBits0 & 64) != 0; }
1336 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1337 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1338 public void ClearMaxVariableActivityValue() {
1343 public const int GlucoseMaxDecayFieldNumber = 22;
1344 private readonly
static double GlucoseMaxDecayDefaultValue = 0.95D;
1346 private double glucoseMaxDecay_;
1354 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1355 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1356 public double GlucoseMaxDecay {
1357 get {
if ((_hasBits0 & 512) != 0) {
return glucoseMaxDecay_; }
else {
return GlucoseMaxDecayDefaultValue; } }
1360 glucoseMaxDecay_ = value;
1364 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1365 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1366 public bool HasGlucoseMaxDecay {
1367 get {
return (_hasBits0 & 512) != 0; }
1370 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1371 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1372 public void ClearGlucoseMaxDecay() {
1377 public const int GlucoseDecayIncrementFieldNumber = 23;
1378 private readonly
static double GlucoseDecayIncrementDefaultValue = 0.01D;
1380 private double glucoseDecayIncrement_;
1381 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1382 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1383 public double GlucoseDecayIncrement {
1384 get {
if ((_hasBits0 & 1024) != 0) {
return glucoseDecayIncrement_; }
else {
return GlucoseDecayIncrementDefaultValue; } }
1387 glucoseDecayIncrement_ = value;
1391 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1392 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1393 public bool HasGlucoseDecayIncrement {
1394 get {
return (_hasBits0 & 1024) != 0; }
1397 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1398 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1399 public void ClearGlucoseDecayIncrement() {
1404 public const int GlucoseDecayIncrementPeriodFieldNumber = 24;
1405 private readonly
static int GlucoseDecayIncrementPeriodDefaultValue = 5000;
1407 private int glucoseDecayIncrementPeriod_;
1408 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1409 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1410 public int GlucoseDecayIncrementPeriod {
1411 get {
if ((_hasBits0 & 2048) != 0) {
return glucoseDecayIncrementPeriod_; }
else {
return GlucoseDecayIncrementPeriodDefaultValue; } }
1414 glucoseDecayIncrementPeriod_ = value;
1418 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1419 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1420 public bool HasGlucoseDecayIncrementPeriod {
1421 get {
return (_hasBits0 & 2048) != 0; }
1424 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1425 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1426 public void ClearGlucoseDecayIncrementPeriod() {
1431 public const int ClauseActivityDecayFieldNumber = 17;
1432 private readonly
static double ClauseActivityDecayDefaultValue = 0.999D;
1434 private double clauseActivityDecay_;
1438 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1439 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1440 public double ClauseActivityDecay {
1441 get {
if ((_hasBits0 & 128) != 0) {
return clauseActivityDecay_; }
else {
return ClauseActivityDecayDefaultValue; } }
1444 clauseActivityDecay_ = value;
1448 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1449 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1450 public bool HasClauseActivityDecay {
1451 get {
return (_hasBits0 & 128) != 0; }
1454 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1455 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1456 public void ClearClauseActivityDecay() {
1461 public const int MaxClauseActivityValueFieldNumber = 18;
1462 private readonly
static double MaxClauseActivityValueDefaultValue = 1e+20D;
1464 private double maxClauseActivityValue_;
1465 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1466 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1467 public double MaxClauseActivityValue {
1468 get {
if ((_hasBits0 & 256) != 0) {
return maxClauseActivityValue_; }
else {
return MaxClauseActivityValueDefaultValue; } }
1471 maxClauseActivityValue_ = value;
1475 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1476 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1477 public bool HasMaxClauseActivityValue {
1478 get {
return (_hasBits0 & 256) != 0; }
1481 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1482 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1483 public void ClearMaxClauseActivityValue() {
1488 public const int RestartAlgorithmsFieldNumber = 61;
1489 private static readonly pb::FieldCodec<global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm> _repeated_restartAlgorithms_codec
1490 = pb::FieldCodec.ForEnum(488, x => (
int) x, x => (global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm) x);
1491 private readonly pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm> restartAlgorithms_ =
new pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm>();
1503 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1504 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1505 public pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm> RestartAlgorithms {
1506 get { return restartAlgorithms_; }
1510 public const int DefaultRestartAlgorithmsFieldNumber = 70;
1511 private readonly
static string DefaultRestartAlgorithmsDefaultValue = global::System.Text.Encoding.UTF8.GetString(global::System.Convert.FromBase64String(
"TFVCWV9SRVNUQVJULExCRF9NT1ZJTkdfQVZFUkFHRV9SRVNUQVJULERMX01PVklOR19BVkVSQUdFX1JFU1RBUlQ="), 0, 65);
1513 private string defaultRestartAlgorithms_;
1514 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1515 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1516 public string DefaultRestartAlgorithms {
1517 get { return defaultRestartAlgorithms_ ?? DefaultRestartAlgorithmsDefaultValue; }
1519 defaultRestartAlgorithms_ = pb::ProtoPreconditions.CheckNotNull(value,
"value");
1523 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1524 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1525 public bool HasDefaultRestartAlgorithms {
1526 get {
return defaultRestartAlgorithms_ !=
null; }
1529 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1530 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1531 public void ClearDefaultRestartAlgorithms() {
1532 defaultRestartAlgorithms_ =
null;
1536 public const int RestartPeriodFieldNumber = 30;
1537 private readonly
static int RestartPeriodDefaultValue = 50;
1539 private int restartPeriod_;
1544 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1545 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1546 public int RestartPeriod {
1547 get {
if ((_hasBits0 & 4096) != 0) {
return restartPeriod_; }
else {
return RestartPeriodDefaultValue; } }
1550 restartPeriod_ = value;
1554 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1555 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1556 public bool HasRestartPeriod {
1557 get {
return (_hasBits0 & 4096) != 0; }
1560 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1561 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1562 public void ClearRestartPeriod() {
1567 public const int RestartRunningWindowSizeFieldNumber = 62;
1568 private readonly
static int RestartRunningWindowSizeDefaultValue = 50;
1570 private int restartRunningWindowSize_;
1574 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1575 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1576 public int RestartRunningWindowSize {
1577 get {
if ((_hasBits1 & 128) != 0) {
return restartRunningWindowSize_; }
else {
return RestartRunningWindowSizeDefaultValue; } }
1580 restartRunningWindowSize_ = value;
1584 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1585 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1586 public bool HasRestartRunningWindowSize {
1587 get {
return (_hasBits1 & 128) != 0; }
1590 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1591 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1592 public void ClearRestartRunningWindowSize() {
1597 public const int RestartDlAverageRatioFieldNumber = 63;
1598 private readonly
static double RestartDlAverageRatioDefaultValue = 1D;
1600 private double restartDlAverageRatio_;
1605 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1606 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1607 public double RestartDlAverageRatio {
1608 get {
if ((_hasBits1 & 256) != 0) {
return restartDlAverageRatio_; }
else {
return RestartDlAverageRatioDefaultValue; } }
1611 restartDlAverageRatio_ = value;
1615 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1616 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1617 public bool HasRestartDlAverageRatio {
1618 get {
return (_hasBits1 & 256) != 0; }
1621 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1622 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1623 public void ClearRestartDlAverageRatio() {
1628 public const int RestartLbdAverageRatioFieldNumber = 71;
1629 private readonly
static double RestartLbdAverageRatioDefaultValue = 1D;
1631 private double restartLbdAverageRatio_;
1632 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1633 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1634 public double RestartLbdAverageRatio {
1635 get {
if ((_hasBits1 & 32768) != 0) {
return restartLbdAverageRatio_; }
else {
return RestartLbdAverageRatioDefaultValue; } }
1638 restartLbdAverageRatio_ = value;
1642 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1643 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1644 public bool HasRestartLbdAverageRatio {
1645 get {
return (_hasBits1 & 32768) != 0; }
1648 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1649 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1650 public void ClearRestartLbdAverageRatio() {
1651 _hasBits1 &= ~32768;
1655 public const int UseBlockingRestartFieldNumber = 64;
1656 private readonly
static bool UseBlockingRestartDefaultValue =
false;
1658 private bool useBlockingRestart_;
1664 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1665 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1666 public bool UseBlockingRestart {
1667 get {
if ((_hasBits1 & 512) != 0) {
return useBlockingRestart_; }
else {
return UseBlockingRestartDefaultValue; } }
1670 useBlockingRestart_ = value;
1674 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1675 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1676 public bool HasUseBlockingRestart {
1677 get {
return (_hasBits1 & 512) != 0; }
1680 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1681 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1682 public void ClearUseBlockingRestart() {
1687 public const int BlockingRestartWindowSizeFieldNumber = 65;
1688 private readonly
static int BlockingRestartWindowSizeDefaultValue = 5000;
1690 private int blockingRestartWindowSize_;
1691 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1692 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1693 public int BlockingRestartWindowSize {
1694 get {
if ((_hasBits1 & 1024) != 0) {
return blockingRestartWindowSize_; }
else {
return BlockingRestartWindowSizeDefaultValue; } }
1697 blockingRestartWindowSize_ = value;
1701 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1702 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1703 public bool HasBlockingRestartWindowSize {
1704 get {
return (_hasBits1 & 1024) != 0; }
1707 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1708 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1709 public void ClearBlockingRestartWindowSize() {
1714 public const int BlockingRestartMultiplierFieldNumber = 66;
1715 private readonly
static double BlockingRestartMultiplierDefaultValue = 1.4D;
1717 private double blockingRestartMultiplier_;
1718 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1719 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1720 public double BlockingRestartMultiplier {
1721 get {
if ((_hasBits1 & 2048) != 0) {
return blockingRestartMultiplier_; }
else {
return BlockingRestartMultiplierDefaultValue; } }
1724 blockingRestartMultiplier_ = value;
1728 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1729 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1730 public bool HasBlockingRestartMultiplier {
1731 get {
return (_hasBits1 & 2048) != 0; }
1734 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1735 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1736 public void ClearBlockingRestartMultiplier() {
1741 public const int NumConflictsBeforeStrategyChangesFieldNumber = 68;
1742 private readonly
static int NumConflictsBeforeStrategyChangesDefaultValue = 0;
1744 private int numConflictsBeforeStrategyChanges_;
1750 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1751 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1752 public int NumConflictsBeforeStrategyChanges {
1753 get {
if ((_hasBits1 & 8192) != 0) {
return numConflictsBeforeStrategyChanges_; }
else {
return NumConflictsBeforeStrategyChangesDefaultValue; } }
1756 numConflictsBeforeStrategyChanges_ = value;
1760 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1761 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1762 public bool HasNumConflictsBeforeStrategyChanges {
1763 get {
return (_hasBits1 & 8192) != 0; }
1766 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1767 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1768 public void ClearNumConflictsBeforeStrategyChanges() {
1773 public const int StrategyChangeIncreaseRatioFieldNumber = 69;
1774 private readonly
static double StrategyChangeIncreaseRatioDefaultValue = 0D;
1776 private double strategyChangeIncreaseRatio_;
1781 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1782 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1783 public double StrategyChangeIncreaseRatio {
1784 get {
if ((_hasBits1 & 16384) != 0) {
return strategyChangeIncreaseRatio_; }
else {
return StrategyChangeIncreaseRatioDefaultValue; } }
1787 strategyChangeIncreaseRatio_ = value;
1791 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1792 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1793 public bool HasStrategyChangeIncreaseRatio {
1794 get {
return (_hasBits1 & 16384) != 0; }
1797 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1798 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1799 public void ClearStrategyChangeIncreaseRatio() {
1800 _hasBits1 &= ~16384;
1804 public const int MaxTimeInSecondsFieldNumber = 36;
1805 private readonly
static double MaxTimeInSecondsDefaultValue =
double.PositiveInfinity;
1807 private double maxTimeInSeconds_;
1812 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1813 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1814 public double MaxTimeInSeconds {
1815 get {
if ((_hasBits0 & 131072) != 0) {
return maxTimeInSeconds_; }
else {
return MaxTimeInSecondsDefaultValue; } }
1817 _hasBits0 |= 131072;
1818 maxTimeInSeconds_ = value;
1822 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1823 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1824 public bool HasMaxTimeInSeconds {
1825 get {
return (_hasBits0 & 131072) != 0; }
1828 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1829 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1830 public void ClearMaxTimeInSeconds() {
1831 _hasBits0 &= ~131072;
1835 public const int MaxDeterministicTimeFieldNumber = 67;
1836 private readonly
static double MaxDeterministicTimeDefaultValue =
double.PositiveInfinity;
1838 private double maxDeterministicTime_;
1844 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1845 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1846 public double MaxDeterministicTime {
1847 get {
if ((_hasBits1 & 4096) != 0) {
return maxDeterministicTime_; }
else {
return MaxDeterministicTimeDefaultValue; } }
1850 maxDeterministicTime_ = value;
1854 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1855 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1856 public bool HasMaxDeterministicTime {
1857 get {
return (_hasBits1 & 4096) != 0; }
1860 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1861 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1862 public void ClearMaxDeterministicTime() {
1867 public const int MaxNumDeterministicBatchesFieldNumber = 291;
1868 private readonly
static int MaxNumDeterministicBatchesDefaultValue = 0;
1870 private int maxNumDeterministicBatches_;
1875 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1876 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1877 public int MaxNumDeterministicBatches {
1878 get {
if ((_hasBits7 & 2048) != 0) {
return maxNumDeterministicBatches_; }
else {
return MaxNumDeterministicBatchesDefaultValue; } }
1881 maxNumDeterministicBatches_ = value;
1885 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1886 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1887 public bool HasMaxNumDeterministicBatches {
1888 get {
return (_hasBits7 & 2048) != 0; }
1891 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1892 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1893 public void ClearMaxNumDeterministicBatches() {
1898 public const int MaxNumberOfConflictsFieldNumber = 37;
1899 private readonly
static long MaxNumberOfConflictsDefaultValue = 9223372036854775807L;
1901 private long maxNumberOfConflicts_;
1911 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1912 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1913 public long MaxNumberOfConflicts {
1914 get {
if ((_hasBits0 & 262144) != 0) {
return maxNumberOfConflicts_; }
else {
return MaxNumberOfConflictsDefaultValue; } }
1916 _hasBits0 |= 262144;
1917 maxNumberOfConflicts_ = value;
1921 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1922 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1923 public bool HasMaxNumberOfConflicts {
1924 get {
return (_hasBits0 & 262144) != 0; }
1927 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1928 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1929 public void ClearMaxNumberOfConflicts() {
1930 _hasBits0 &= ~262144;
1934 public const int MaxMemoryInMbFieldNumber = 40;
1935 private readonly
static long MaxMemoryInMbDefaultValue = 10000L;
1937 private long maxMemoryInMb_;
1946 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1947 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1948 public long MaxMemoryInMb {
1949 get {
if ((_hasBits0 & 524288) != 0) {
return maxMemoryInMb_; }
else {
return MaxMemoryInMbDefaultValue; } }
1951 _hasBits0 |= 524288;
1952 maxMemoryInMb_ = value;
1956 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1957 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1958 public bool HasMaxMemoryInMb {
1959 get {
return (_hasBits0 & 524288) != 0; }
1962 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1963 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1964 public void ClearMaxMemoryInMb() {
1965 _hasBits0 &= ~524288;
1969 public const int AbsoluteGapLimitFieldNumber = 159;
1970 private readonly
static double AbsoluteGapLimitDefaultValue = 0.0001D;
1972 private double absoluteGapLimit_;
1993 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1994 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1995 public double AbsoluteGapLimit {
1996 get {
if ((_hasBits3 & 33554432) != 0) {
return absoluteGapLimit_; }
else {
return AbsoluteGapLimitDefaultValue; } }
1998 _hasBits3 |= 33554432;
1999 absoluteGapLimit_ = value;
2003 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2004 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2005 public bool HasAbsoluteGapLimit {
2006 get {
return (_hasBits3 & 33554432) != 0; }
2009 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2010 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2011 public void ClearAbsoluteGapLimit() {
2012 _hasBits3 &= ~33554432;
2016 public const int RelativeGapLimitFieldNumber = 160;
2017 private readonly
static double RelativeGapLimitDefaultValue = 0D;
2019 private double relativeGapLimit_;
2020 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2021 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2022 public double RelativeGapLimit {
2023 get {
if ((_hasBits3 & 67108864) != 0) {
return relativeGapLimit_; }
else {
return RelativeGapLimitDefaultValue; } }
2025 _hasBits3 |= 67108864;
2026 relativeGapLimit_ = value;
2030 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2031 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2032 public bool HasRelativeGapLimit {
2033 get {
return (_hasBits3 & 67108864) != 0; }
2036 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2037 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2038 public void ClearRelativeGapLimit() {
2039 _hasBits3 &= ~67108864;
2043 public const int RandomSeedFieldNumber = 31;
2044 private readonly
static int RandomSeedDefaultValue = 1;
2046 private int randomSeed_;
2056 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2057 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2058 public int RandomSeed {
2059 get {
if ((_hasBits0 & 8192) != 0) {
return randomSeed_; }
else {
return RandomSeedDefaultValue; } }
2062 randomSeed_ = value;
2066 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2067 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2068 public bool HasRandomSeed {
2069 get {
return (_hasBits0 & 8192) != 0; }
2072 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2073 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2074 public void ClearRandomSeed() {
2079 public const int PermuteVariableRandomlyFieldNumber = 178;
2080 private readonly
static bool PermuteVariableRandomlyDefaultValue =
false;
2082 private bool permuteVariableRandomly_;
2089 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2090 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2091 public bool PermuteVariableRandomly {
2092 get {
if ((_hasBits4 & 2048) != 0) {
return permuteVariableRandomly_; }
else {
return PermuteVariableRandomlyDefaultValue; } }
2095 permuteVariableRandomly_ = value;
2099 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2100 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2101 public bool HasPermuteVariableRandomly {
2102 get {
return (_hasBits4 & 2048) != 0; }
2105 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2106 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2107 public void ClearPermuteVariableRandomly() {
2112 public const int PermutePresolveConstraintOrderFieldNumber = 179;
2113 private readonly
static bool PermutePresolveConstraintOrderDefaultValue =
false;
2115 private bool permutePresolveConstraintOrder_;
2116 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2117 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2118 public bool PermutePresolveConstraintOrder {
2119 get {
if ((_hasBits4 & 4096) != 0) {
return permutePresolveConstraintOrder_; }
else {
return PermutePresolveConstraintOrderDefaultValue; } }
2122 permutePresolveConstraintOrder_ = value;
2126 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2127 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2128 public bool HasPermutePresolveConstraintOrder {
2129 get {
return (_hasBits4 & 4096) != 0; }
2132 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2133 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2134 public void ClearPermutePresolveConstraintOrder() {
2139 public const int UseAbslRandomFieldNumber = 180;
2140 private readonly
static bool UseAbslRandomDefaultValue =
false;
2142 private bool useAbslRandom_;
2143 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2144 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2145 public bool UseAbslRandom {
2146 get {
if ((_hasBits4 & 8192) != 0) {
return useAbslRandom_; }
else {
return UseAbslRandomDefaultValue; } }
2149 useAbslRandom_ = value;
2153 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2154 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2155 public bool HasUseAbslRandom {
2156 get {
return (_hasBits4 & 8192) != 0; }
2159 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2160 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2161 public void ClearUseAbslRandom() {
2166 public const int LogSearchProgressFieldNumber = 41;
2167 private readonly
static bool LogSearchProgressDefaultValue =
false;
2169 private bool logSearchProgress_;
2175 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2176 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2177 public bool LogSearchProgress {
2178 get {
if ((_hasBits0 & 1048576) != 0) {
return logSearchProgress_; }
else {
return LogSearchProgressDefaultValue; } }
2180 _hasBits0 |= 1048576;
2181 logSearchProgress_ = value;
2185 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2186 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2187 public bool HasLogSearchProgress {
2188 get {
return (_hasBits0 & 1048576) != 0; }
2191 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2192 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2193 public void ClearLogSearchProgress() {
2194 _hasBits0 &= ~1048576;
2198 public const int LogSubsolverStatisticsFieldNumber = 189;
2199 private readonly
static bool LogSubsolverStatisticsDefaultValue =
false;
2201 private bool logSubsolverStatistics_;
2208 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2209 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2210 public bool LogSubsolverStatistics {
2211 get {
if ((_hasBits4 & 1048576) != 0) {
return logSubsolverStatistics_; }
else {
return LogSubsolverStatisticsDefaultValue; } }
2213 _hasBits4 |= 1048576;
2214 logSubsolverStatistics_ = value;
2218 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2219 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2220 public bool HasLogSubsolverStatistics {
2221 get {
return (_hasBits4 & 1048576) != 0; }
2224 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2225 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2226 public void ClearLogSubsolverStatistics() {
2227 _hasBits4 &= ~1048576;
2231 public const int LogPrefixFieldNumber = 185;
2232 private readonly
static string LogPrefixDefaultValue =
"";
2234 private string logPrefix_;
2238 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2239 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2240 public string LogPrefix {
2241 get {
return logPrefix_ ?? LogPrefixDefaultValue; }
2243 logPrefix_ = pb::ProtoPreconditions.CheckNotNull(value,
"value");
2247 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2248 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2249 public bool HasLogPrefix {
2250 get {
return logPrefix_ !=
null; }
2253 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2254 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2255 public void ClearLogPrefix() {
2260 public const int LogToStdoutFieldNumber = 186;
2261 private readonly
static bool LogToStdoutDefaultValue =
true;
2263 private bool logToStdout_;
2267 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2268 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2269 public bool LogToStdout {
2270 get {
if ((_hasBits4 & 131072) != 0) {
return logToStdout_; }
else {
return LogToStdoutDefaultValue; } }
2272 _hasBits4 |= 131072;
2273 logToStdout_ = value;
2277 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2278 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2279 public bool HasLogToStdout {
2280 get {
return (_hasBits4 & 131072) != 0; }
2283 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2284 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2285 public void ClearLogToStdout() {
2286 _hasBits4 &= ~131072;
2290 public const int LogToResponseFieldNumber = 187;
2291 private readonly
static bool LogToResponseDefaultValue =
false;
2293 private bool logToResponse_;
2297 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2298 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2299 public bool LogToResponse {
2300 get {
if ((_hasBits4 & 262144) != 0) {
return logToResponse_; }
else {
return LogToResponseDefaultValue; } }
2302 _hasBits4 |= 262144;
2303 logToResponse_ = value;
2307 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2308 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2309 public bool HasLogToResponse {
2310 get {
return (_hasBits4 & 262144) != 0; }
2313 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2314 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2315 public void ClearLogToResponse() {
2316 _hasBits4 &= ~262144;
2320 public const int UsePbResolutionFieldNumber = 43;
2321 private readonly
static bool UsePbResolutionDefaultValue =
false;
2323 private bool usePbResolution_;
2330 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2331 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2332 public bool UsePbResolution {
2333 get {
if ((_hasBits0 & 2097152) != 0) {
return usePbResolution_; }
else {
return UsePbResolutionDefaultValue; } }
2335 _hasBits0 |= 2097152;
2336 usePbResolution_ = value;
2340 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2341 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2342 public bool HasUsePbResolution {
2343 get {
return (_hasBits0 & 2097152) != 0; }
2346 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2347 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2348 public void ClearUsePbResolution() {
2349 _hasBits0 &= ~2097152;
2353 public const int MinimizeReductionDuringPbResolutionFieldNumber = 48;
2354 private readonly
static bool MinimizeReductionDuringPbResolutionDefaultValue =
false;
2356 private bool minimizeReductionDuringPbResolution_;
2363 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2364 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2365 public bool MinimizeReductionDuringPbResolution {
2366 get {
if ((_hasBits0 & 67108864) != 0) {
return minimizeReductionDuringPbResolution_; }
else {
return MinimizeReductionDuringPbResolutionDefaultValue; } }
2368 _hasBits0 |= 67108864;
2369 minimizeReductionDuringPbResolution_ = value;
2373 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2374 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2375 public bool HasMinimizeReductionDuringPbResolution {
2376 get {
return (_hasBits0 & 67108864) != 0; }
2379 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2380 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2381 public void ClearMinimizeReductionDuringPbResolution() {
2382 _hasBits0 &= ~67108864;
2386 public const int CountAssumptionLevelsInLbdFieldNumber = 49;
2387 private readonly
static bool CountAssumptionLevelsInLbdDefaultValue =
true;
2389 private bool countAssumptionLevelsInLbd_;
2401 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2402 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2403 public bool CountAssumptionLevelsInLbd {
2404 get {
if ((_hasBits0 & 134217728) != 0) {
return countAssumptionLevelsInLbd_; }
else {
return CountAssumptionLevelsInLbdDefaultValue; } }
2406 _hasBits0 |= 134217728;
2407 countAssumptionLevelsInLbd_ = value;
2411 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2412 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2413 public bool HasCountAssumptionLevelsInLbd {
2414 get {
return (_hasBits0 & 134217728) != 0; }
2417 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2418 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2419 public void ClearCountAssumptionLevelsInLbd() {
2420 _hasBits0 &= ~134217728;
2424 public const int PresolveBveThresholdFieldNumber = 54;
2425 private readonly
static int PresolveBveThresholdDefaultValue = 500;
2427 private int presolveBveThreshold_;
2433 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2434 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2435 public int PresolveBveThreshold {
2436 get {
if ((_hasBits1 & 1) != 0) {
return presolveBveThreshold_; }
else {
return PresolveBveThresholdDefaultValue; } }
2439 presolveBveThreshold_ = value;
2443 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2444 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2445 public bool HasPresolveBveThreshold {
2446 get {
return (_hasBits1 & 1) != 0; }
2449 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2450 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2451 public void ClearPresolveBveThreshold() {
2456 public const int PresolveBveClauseWeightFieldNumber = 55;
2457 private readonly
static int PresolveBveClauseWeightDefaultValue = 3;
2459 private int presolveBveClauseWeight_;
2464 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2465 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2466 public int PresolveBveClauseWeight {
2467 get {
if ((_hasBits1 & 2) != 0) {
return presolveBveClauseWeight_; }
else {
return PresolveBveClauseWeightDefaultValue; } }
2470 presolveBveClauseWeight_ = value;
2474 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2475 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2476 public bool HasPresolveBveClauseWeight {
2477 get {
return (_hasBits1 & 2) != 0; }
2480 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2481 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2482 public void ClearPresolveBveClauseWeight() {
2487 public const int ProbingDeterministicTimeLimitFieldNumber = 226;
2488 private readonly
static double ProbingDeterministicTimeLimitDefaultValue = 1D;
2490 private double probingDeterministicTimeLimit_;
2498 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2499 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2500 public double ProbingDeterministicTimeLimit {
2501 get {
if ((_hasBits5 & 131072) != 0) {
return probingDeterministicTimeLimit_; }
else {
return ProbingDeterministicTimeLimitDefaultValue; } }
2503 _hasBits5 |= 131072;
2504 probingDeterministicTimeLimit_ = value;
2508 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2509 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2510 public bool HasProbingDeterministicTimeLimit {
2511 get {
return (_hasBits5 & 131072) != 0; }
2514 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2515 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2516 public void ClearProbingDeterministicTimeLimit() {
2517 _hasBits5 &= ~131072;
2521 public const int PresolveProbingDeterministicTimeLimitFieldNumber = 57;
2522 private readonly
static double PresolveProbingDeterministicTimeLimitDefaultValue = 30D;
2524 private double presolveProbingDeterministicTimeLimit_;
2525 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2526 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2527 public double PresolveProbingDeterministicTimeLimit {
2528 get {
if ((_hasBits1 & 8) != 0) {
return presolveProbingDeterministicTimeLimit_; }
else {
return PresolveProbingDeterministicTimeLimitDefaultValue; } }
2531 presolveProbingDeterministicTimeLimit_ = value;
2535 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2536 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2537 public bool HasPresolveProbingDeterministicTimeLimit {
2538 get {
return (_hasBits1 & 8) != 0; }
2541 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2542 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2543 public void ClearPresolveProbingDeterministicTimeLimit() {
2548 public const int PresolveBlockedClauseFieldNumber = 88;
2549 private readonly
static bool PresolveBlockedClauseDefaultValue =
true;
2551 private bool presolveBlockedClause_;
2556 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2557 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2558 public bool PresolveBlockedClause {
2559 get {
if ((_hasBits1 & -2147483648) != 0) {
return presolveBlockedClause_; }
else {
return PresolveBlockedClauseDefaultValue; } }
2561 _hasBits1 |= -2147483648;
2562 presolveBlockedClause_ = value;
2566 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2567 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2568 public bool HasPresolveBlockedClause {
2569 get {
return (_hasBits1 & -2147483648) != 0; }
2572 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2573 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2574 public void ClearPresolveBlockedClause() {
2575 _hasBits1 &= ~-2147483648;
2579 public const int PresolveUseBvaFieldNumber = 72;
2580 private readonly
static bool PresolveUseBvaDefaultValue =
true;
2582 private bool presolveUseBva_;
2586 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2587 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2588 public bool PresolveUseBva {
2589 get {
if ((_hasBits1 & 65536) != 0) {
return presolveUseBva_; }
else {
return PresolveUseBvaDefaultValue; } }
2592 presolveUseBva_ = value;
2596 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2597 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2598 public bool HasPresolveUseBva {
2599 get {
return (_hasBits1 & 65536) != 0; }
2602 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2603 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2604 public void ClearPresolveUseBva() {
2605 _hasBits1 &= ~65536;
2609 public const int PresolveBvaThresholdFieldNumber = 73;
2610 private readonly
static int PresolveBvaThresholdDefaultValue = 1;
2612 private int presolveBvaThreshold_;
2619 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2620 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2621 public int PresolveBvaThreshold {
2622 get {
if ((_hasBits1 & 131072) != 0) {
return presolveBvaThreshold_; }
else {
return PresolveBvaThresholdDefaultValue; } }
2624 _hasBits1 |= 131072;
2625 presolveBvaThreshold_ = value;
2629 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2630 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2631 public bool HasPresolveBvaThreshold {
2632 get {
return (_hasBits1 & 131072) != 0; }
2635 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2636 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2637 public void ClearPresolveBvaThreshold() {
2638 _hasBits1 &= ~131072;
2642 public const int MaxPresolveIterationsFieldNumber = 138;
2643 private readonly
static int MaxPresolveIterationsDefaultValue = 3;
2645 private int maxPresolveIterations_;
2651 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2652 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2653 public int MaxPresolveIterations {
2654 get {
if ((_hasBits3 & 2048) != 0) {
return maxPresolveIterations_; }
else {
return MaxPresolveIterationsDefaultValue; } }
2657 maxPresolveIterations_ = value;
2661 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2662 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2663 public bool HasMaxPresolveIterations {
2664 get {
return (_hasBits3 & 2048) != 0; }
2667 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2668 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2669 public void ClearMaxPresolveIterations() {
2674 public const int CpModelPresolveFieldNumber = 86;
2675 private readonly
static bool CpModelPresolveDefaultValue =
true;
2677 private bool cpModelPresolve_;
2681 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2682 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2683 public bool CpModelPresolve {
2684 get {
if ((_hasBits1 & 536870912) != 0) {
return cpModelPresolve_; }
else {
return CpModelPresolveDefaultValue; } }
2686 _hasBits1 |= 536870912;
2687 cpModelPresolve_ = value;
2691 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2692 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2693 public bool HasCpModelPresolve {
2694 get {
return (_hasBits1 & 536870912) != 0; }
2697 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2698 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2699 public void ClearCpModelPresolve() {
2700 _hasBits1 &= ~536870912;
2704 public const int CpModelProbingLevelFieldNumber = 110;
2705 private readonly
static int CpModelProbingLevelDefaultValue = 2;
2707 private int cpModelProbingLevel_;
2711 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2712 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2713 public int CpModelProbingLevel {
2714 get {
if ((_hasBits2 & 131072) != 0) {
return cpModelProbingLevel_; }
else {
return CpModelProbingLevelDefaultValue; } }
2716 _hasBits2 |= 131072;
2717 cpModelProbingLevel_ = value;
2721 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2722 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2723 public bool HasCpModelProbingLevel {
2724 get {
return (_hasBits2 & 131072) != 0; }
2727 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2728 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2729 public void ClearCpModelProbingLevel() {
2730 _hasBits2 &= ~131072;
2734 public const int CpModelUseSatPresolveFieldNumber = 93;
2735 private readonly
static bool CpModelUseSatPresolveDefaultValue =
true;
2737 private bool cpModelUseSatPresolve_;
2741 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2742 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2743 public bool CpModelUseSatPresolve {
2744 get {
if ((_hasBits2 & 16) != 0) {
return cpModelUseSatPresolve_; }
else {
return CpModelUseSatPresolveDefaultValue; } }
2747 cpModelUseSatPresolve_ = value;
2751 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2752 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2753 public bool HasCpModelUseSatPresolve {
2754 get {
return (_hasBits2 & 16) != 0; }
2757 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2758 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2759 public void ClearCpModelUseSatPresolve() {
2764 public const int DetectTableWithCostFieldNumber = 216;
2765 private readonly
static bool DetectTableWithCostDefaultValue =
false;
2767 private bool detectTableWithCost_;
2776 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2777 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2778 public bool DetectTableWithCost {
2779 get {
if ((_hasBits5 & 512) != 0) {
return detectTableWithCost_; }
else {
return DetectTableWithCostDefaultValue; } }
2782 detectTableWithCost_ = value;
2786 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2787 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2788 public bool HasDetectTableWithCost {
2789 get {
return (_hasBits5 & 512) != 0; }
2792 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2793 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2794 public void ClearDetectTableWithCost() {
2799 public const int TableCompressionLevelFieldNumber = 217;
2800 private readonly
static int TableCompressionLevelDefaultValue = 2;
2802 private int tableCompressionLevel_;
2809 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2810 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2811 public int TableCompressionLevel {
2812 get {
if ((_hasBits5 & 1024) != 0) {
return tableCompressionLevel_; }
else {
return TableCompressionLevelDefaultValue; } }
2815 tableCompressionLevel_ = value;
2819 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2820 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2821 public bool HasTableCompressionLevel {
2822 get {
return (_hasBits5 & 1024) != 0; }
2825 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2826 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2827 public void ClearTableCompressionLevel() {
2832 public const int ExpandAlldiffConstraintsFieldNumber = 170;
2833 private readonly
static bool ExpandAlldiffConstraintsDefaultValue =
false;
2835 private bool expandAlldiffConstraints_;
2840 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2841 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2842 public bool ExpandAlldiffConstraints {
2843 get {
if ((_hasBits4 & 16) != 0) {
return expandAlldiffConstraints_; }
else {
return ExpandAlldiffConstraintsDefaultValue; } }
2846 expandAlldiffConstraints_ = value;
2850 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2851 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2852 public bool HasExpandAlldiffConstraints {
2853 get {
return (_hasBits4 & 16) != 0; }
2856 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2857 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2858 public void ClearExpandAlldiffConstraints() {
2863 public const int ExpandReservoirConstraintsFieldNumber = 182;
2864 private readonly
static bool ExpandReservoirConstraintsDefaultValue =
true;
2866 private bool expandReservoirConstraints_;
2871 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2872 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2873 public bool ExpandReservoirConstraints {
2874 get {
if ((_hasBits4 & 32768) != 0) {
return expandReservoirConstraints_; }
else {
return ExpandReservoirConstraintsDefaultValue; } }
2877 expandReservoirConstraints_ = value;
2881 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2882 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2883 public bool HasExpandReservoirConstraints {
2884 get {
return (_hasBits4 & 32768) != 0; }
2887 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2888 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2889 public void ClearExpandReservoirConstraints() {
2890 _hasBits4 &= ~32768;
2894 public const int ExpandReservoirUsingCircuitFieldNumber = 288;
2895 private readonly
static bool ExpandReservoirUsingCircuitDefaultValue =
false;
2897 private bool expandReservoirUsingCircuit_;
2912 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2913 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2914 public bool ExpandReservoirUsingCircuit {
2915 get {
if ((_hasBits7 & 256) != 0) {
return expandReservoirUsingCircuit_; }
else {
return ExpandReservoirUsingCircuitDefaultValue; } }
2918 expandReservoirUsingCircuit_ = value;
2922 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2923 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2924 public bool HasExpandReservoirUsingCircuit {
2925 get {
return (_hasBits7 & 256) != 0; }
2928 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2929 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2930 public void ClearExpandReservoirUsingCircuit() {
2935 public const int EncodeCumulativeAsReservoirFieldNumber = 287;
2936 private readonly
static bool EncodeCumulativeAsReservoirDefaultValue =
false;
2938 private bool encodeCumulativeAsReservoir_;
2944 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2945 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2946 public bool EncodeCumulativeAsReservoir {
2947 get {
if ((_hasBits7 & 128) != 0) {
return encodeCumulativeAsReservoir_; }
else {
return EncodeCumulativeAsReservoirDefaultValue; } }
2950 encodeCumulativeAsReservoir_ = value;
2954 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2955 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2956 public bool HasEncodeCumulativeAsReservoir {
2957 get {
return (_hasBits7 & 128) != 0; }
2960 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2961 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2962 public void ClearEncodeCumulativeAsReservoir() {
2967 public const int MaxLinMaxSizeForExpansionFieldNumber = 280;
2968 private readonly
static int MaxLinMaxSizeForExpansionDefaultValue = 0;
2970 private int maxLinMaxSizeForExpansion_;
2978 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2979 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2980 public int MaxLinMaxSizeForExpansion {
2981 get {
if ((_hasBits7 & 1) != 0) {
return maxLinMaxSizeForExpansion_; }
else {
return MaxLinMaxSizeForExpansionDefaultValue; } }
2984 maxLinMaxSizeForExpansion_ = value;
2988 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2989 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2990 public bool HasMaxLinMaxSizeForExpansion {
2991 get {
return (_hasBits7 & 1) != 0; }
2994 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2995 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2996 public void ClearMaxLinMaxSizeForExpansion() {
3001 public const int DisableConstraintExpansionFieldNumber = 181;
3002 private readonly
static bool DisableConstraintExpansionDefaultValue =
false;
3004 private bool disableConstraintExpansion_;
3009 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3010 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3011 public bool DisableConstraintExpansion {
3012 get {
if ((_hasBits4 & 16384) != 0) {
return disableConstraintExpansion_; }
else {
return DisableConstraintExpansionDefaultValue; } }
3015 disableConstraintExpansion_ = value;
3019 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3020 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3021 public bool HasDisableConstraintExpansion {
3022 get {
return (_hasBits4 & 16384) != 0; }
3025 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3026 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3027 public void ClearDisableConstraintExpansion() {
3028 _hasBits4 &= ~16384;
3032 public const int EncodeComplexLinearConstraintWithIntegerFieldNumber = 223;
3033 private readonly
static bool EncodeComplexLinearConstraintWithIntegerDefaultValue =
false;
3035 private bool encodeComplexLinearConstraintWithInteger_;
3040 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3041 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3042 public bool EncodeComplexLinearConstraintWithInteger {
3043 get {
if ((_hasBits5 & 16384) != 0) {
return encodeComplexLinearConstraintWithInteger_; }
else {
return EncodeComplexLinearConstraintWithIntegerDefaultValue; } }
3046 encodeComplexLinearConstraintWithInteger_ = value;
3050 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3051 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3052 public bool HasEncodeComplexLinearConstraintWithInteger {
3053 get {
return (_hasBits5 & 16384) != 0; }
3056 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3057 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3058 public void ClearEncodeComplexLinearConstraintWithInteger() {
3059 _hasBits5 &= ~16384;
3063 public const int MergeNoOverlapWorkLimitFieldNumber = 145;
3064 private readonly
static double MergeNoOverlapWorkLimitDefaultValue = 1e+12D;
3066 private double mergeNoOverlapWorkLimit_;
3074 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3075 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3076 public double MergeNoOverlapWorkLimit {
3077 get {
if ((_hasBits3 & 8192) != 0) {
return mergeNoOverlapWorkLimit_; }
else {
return MergeNoOverlapWorkLimitDefaultValue; } }
3080 mergeNoOverlapWorkLimit_ = value;
3084 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3085 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3086 public bool HasMergeNoOverlapWorkLimit {
3087 get {
return (_hasBits3 & 8192) != 0; }
3090 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3091 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3092 public void ClearMergeNoOverlapWorkLimit() {
3097 public const int MergeAtMostOneWorkLimitFieldNumber = 146;
3098 private readonly
static double MergeAtMostOneWorkLimitDefaultValue = 1e+08D;
3100 private double mergeAtMostOneWorkLimit_;
3101 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3102 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3103 public double MergeAtMostOneWorkLimit {
3104 get {
if ((_hasBits3 & 16384) != 0) {
return mergeAtMostOneWorkLimit_; }
else {
return MergeAtMostOneWorkLimitDefaultValue; } }
3107 mergeAtMostOneWorkLimit_ = value;
3111 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3112 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3113 public bool HasMergeAtMostOneWorkLimit {
3114 get {
return (_hasBits3 & 16384) != 0; }
3117 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3118 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3119 public void ClearMergeAtMostOneWorkLimit() {
3120 _hasBits3 &= ~16384;
3124 public const int PresolveSubstitutionLevelFieldNumber = 147;
3125 private readonly
static int PresolveSubstitutionLevelDefaultValue = 1;
3127 private int presolveSubstitutionLevel_;
3134 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3135 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3136 public int PresolveSubstitutionLevel {
3137 get {
if ((_hasBits3 & 32768) != 0) {
return presolveSubstitutionLevel_; }
else {
return PresolveSubstitutionLevelDefaultValue; } }
3140 presolveSubstitutionLevel_ = value;
3144 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3145 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3146 public bool HasPresolveSubstitutionLevel {
3147 get {
return (_hasBits3 & 32768) != 0; }
3150 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3151 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3152 public void ClearPresolveSubstitutionLevel() {
3153 _hasBits3 &= ~32768;
3157 public const int PresolveExtractIntegerEnforcementFieldNumber = 174;
3158 private readonly
static bool PresolveExtractIntegerEnforcementDefaultValue =
false;
3160 private bool presolveExtractIntegerEnforcement_;
3169 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3170 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3171 public bool PresolveExtractIntegerEnforcement {
3172 get {
if ((_hasBits4 & 128) != 0) {
return presolveExtractIntegerEnforcement_; }
else {
return PresolveExtractIntegerEnforcementDefaultValue; } }
3175 presolveExtractIntegerEnforcement_ = value;
3179 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3180 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3181 public bool HasPresolveExtractIntegerEnforcement {
3182 get {
return (_hasBits4 & 128) != 0; }
3185 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3186 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3187 public void ClearPresolveExtractIntegerEnforcement() {
3192 public const int PresolveInclusionWorkLimitFieldNumber = 201;
3193 private readonly
static long PresolveInclusionWorkLimitDefaultValue = 100000000L;
3195 private long presolveInclusionWorkLimit_;
3205 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3206 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3207 public long PresolveInclusionWorkLimit {
3208 get {
if ((_hasBits5 & 1) != 0) {
return presolveInclusionWorkLimit_; }
else {
return PresolveInclusionWorkLimitDefaultValue; } }
3211 presolveInclusionWorkLimit_ = value;
3215 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3216 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3217 public bool HasPresolveInclusionWorkLimit {
3218 get {
return (_hasBits5 & 1) != 0; }
3221 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3222 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3223 public void ClearPresolveInclusionWorkLimit() {
3228 public const int IgnoreNamesFieldNumber = 202;
3229 private readonly
static bool IgnoreNamesDefaultValue =
true;
3231 private bool ignoreNames_;
3235 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3236 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3237 public bool IgnoreNames {
3238 get {
if ((_hasBits5 & 2) != 0) {
return ignoreNames_; }
else {
return IgnoreNamesDefaultValue; } }
3241 ignoreNames_ = value;
3245 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3246 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3247 public bool HasIgnoreNames {
3248 get {
return (_hasBits5 & 2) != 0; }
3251 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3252 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3253 public void ClearIgnoreNames() {
3258 public const int InferAllDiffsFieldNumber = 233;
3259 private readonly
static bool InferAllDiffsDefaultValue =
true;
3261 private bool inferAllDiffs_;
3272 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3273 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3274 public bool InferAllDiffs {
3275 get {
if ((_hasBits5 & 8388608) != 0) {
return inferAllDiffs_; }
else {
return InferAllDiffsDefaultValue; } }
3277 _hasBits5 |= 8388608;
3278 inferAllDiffs_ = value;
3282 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3283 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3284 public bool HasInferAllDiffs {
3285 get {
return (_hasBits5 & 8388608) != 0; }
3288 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3289 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3290 public void ClearInferAllDiffs() {
3291 _hasBits5 &= ~8388608;
3295 public const int FindBigLinearOverlapFieldNumber = 234;
3296 private readonly
static bool FindBigLinearOverlapDefaultValue =
true;
3298 private bool findBigLinearOverlap_;
3305 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3306 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3307 public bool FindBigLinearOverlap {
3308 get {
if ((_hasBits5 & 16777216) != 0) {
return findBigLinearOverlap_; }
else {
return FindBigLinearOverlapDefaultValue; } }
3310 _hasBits5 |= 16777216;
3311 findBigLinearOverlap_ = value;
3315 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3316 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3317 public bool HasFindBigLinearOverlap {
3318 get {
return (_hasBits5 & 16777216) != 0; }
3321 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3322 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3323 public void ClearFindBigLinearOverlap() {
3324 _hasBits5 &= ~16777216;
3328 public const int UseSatInprocessingFieldNumber = 163;
3329 private readonly
static bool UseSatInprocessingDefaultValue =
true;
3331 private bool useSatInprocessing_;
3336 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3337 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3338 public bool UseSatInprocessing {
3339 get {
if ((_hasBits3 & 536870912) != 0) {
return useSatInprocessing_; }
else {
return UseSatInprocessingDefaultValue; } }
3341 _hasBits3 |= 536870912;
3342 useSatInprocessing_ = value;
3346 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3347 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3348 public bool HasUseSatInprocessing {
3349 get {
return (_hasBits3 & 536870912) != 0; }
3352 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3353 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3354 public void ClearUseSatInprocessing() {
3355 _hasBits3 &= ~536870912;
3359 public const int InprocessingDtimeRatioFieldNumber = 273;
3360 private readonly
static double InprocessingDtimeRatioDefaultValue = 0.2D;
3362 private double inprocessingDtimeRatio_;
3368 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3369 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3370 public double InprocessingDtimeRatio {
3371 get {
if ((_hasBits6 & 33554432) != 0) {
return inprocessingDtimeRatio_; }
else {
return InprocessingDtimeRatioDefaultValue; } }
3373 _hasBits6 |= 33554432;
3374 inprocessingDtimeRatio_ = value;
3378 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3379 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3380 public bool HasInprocessingDtimeRatio {
3381 get {
return (_hasBits6 & 33554432) != 0; }
3384 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3385 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3386 public void ClearInprocessingDtimeRatio() {
3387 _hasBits6 &= ~33554432;
3391 public const int InprocessingProbingDtimeFieldNumber = 274;
3392 private readonly
static double InprocessingProbingDtimeDefaultValue = 1D;
3394 private double inprocessingProbingDtime_;
3398 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3399 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3400 public double InprocessingProbingDtime {
3401 get {
if ((_hasBits6 & 67108864) != 0) {
return inprocessingProbingDtime_; }
else {
return InprocessingProbingDtimeDefaultValue; } }
3403 _hasBits6 |= 67108864;
3404 inprocessingProbingDtime_ = value;
3408 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3409 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3410 public bool HasInprocessingProbingDtime {
3411 get {
return (_hasBits6 & 67108864) != 0; }
3414 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3415 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3416 public void ClearInprocessingProbingDtime() {
3417 _hasBits6 &= ~67108864;
3421 public const int InprocessingMinimizationDtimeFieldNumber = 275;
3422 private readonly
static double InprocessingMinimizationDtimeDefaultValue = 1D;
3424 private double inprocessingMinimizationDtime_;
3437 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3438 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3439 public double InprocessingMinimizationDtime {
3440 get {
if ((_hasBits6 & 134217728) != 0) {
return inprocessingMinimizationDtime_; }
else {
return InprocessingMinimizationDtimeDefaultValue; } }
3442 _hasBits6 |= 134217728;
3443 inprocessingMinimizationDtime_ = value;
3447 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3448 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3449 public bool HasInprocessingMinimizationDtime {
3450 get {
return (_hasBits6 & 134217728) != 0; }
3453 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3454 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3455 public void ClearInprocessingMinimizationDtime() {
3456 _hasBits6 &= ~134217728;
3460 public const int NumWorkersFieldNumber = 206;
3461 private readonly
static int NumWorkersDefaultValue = 0;
3463 private int numWorkers_;
3480 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3481 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3482 public int NumWorkers {
3483 get {
if ((_hasBits5 & 32) != 0) {
return numWorkers_; }
else {
return NumWorkersDefaultValue; } }
3486 numWorkers_ = value;
3490 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3491 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3492 public bool HasNumWorkers {
3493 get {
return (_hasBits5 & 32) != 0; }
3496 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3497 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3498 public void ClearNumWorkers() {
3503 public const int NumSearchWorkersFieldNumber = 100;
3504 private readonly
static int NumSearchWorkersDefaultValue = 0;
3506 private int numSearchWorkers_;
3507 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3508 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3509 public int NumSearchWorkers {
3510 get {
if ((_hasBits2 & 512) != 0) {
return numSearchWorkers_; }
else {
return NumSearchWorkersDefaultValue; } }
3513 numSearchWorkers_ = value;
3517 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3518 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3519 public bool HasNumSearchWorkers {
3520 get {
return (_hasBits2 & 512) != 0; }
3523 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3524 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3525 public void ClearNumSearchWorkers() {
3530 public const int NumFullSubsolversFieldNumber = 294;
3531 private readonly
static int NumFullSubsolversDefaultValue = 0;
3533 private int numFullSubsolvers_;
3541 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3542 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3543 public int NumFullSubsolvers {
3544 get {
if ((_hasBits7 & 8192) != 0) {
return numFullSubsolvers_; }
else {
return NumFullSubsolversDefaultValue; } }
3547 numFullSubsolvers_ = value;
3551 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3552 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3553 public bool HasNumFullSubsolvers {
3554 get {
return (_hasBits7 & 8192) != 0; }
3557 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3558 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3559 public void ClearNumFullSubsolvers() {
3564 public const int SubsolversFieldNumber = 207;
3565 private static readonly pb::FieldCodec<string> _repeated_subsolvers_codec
3566 = pb::FieldCodec.ForString(1658);
3567 private readonly pbc::RepeatedField<string> subsolvers_ =
new pbc::RepeatedField<string>();
3595 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3596 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3597 public pbc::RepeatedField<string> Subsolvers {
3598 get {
return subsolvers_; }
3602 public const int ExtraSubsolversFieldNumber = 219;
3603 private static readonly pb::FieldCodec<string> _repeated_extraSubsolvers_codec
3604 = pb::FieldCodec.ForString(1754);
3605 private readonly pbc::RepeatedField<string> extraSubsolvers_ =
new pbc::RepeatedField<string>();
3610 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3611 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3612 public pbc::RepeatedField<string> ExtraSubsolvers {
3613 get {
return extraSubsolvers_; }
3617 public const int IgnoreSubsolversFieldNumber = 209;
3618 private static readonly pb::FieldCodec<string> _repeated_ignoreSubsolvers_codec
3619 = pb::FieldCodec.ForString(1674);
3620 private readonly pbc::RepeatedField<string> ignoreSubsolvers_ =
new pbc::RepeatedField<string>();
3632 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3633 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3634 public pbc::RepeatedField<string> IgnoreSubsolvers {
3635 get {
return ignoreSubsolvers_; }
3639 public const int FilterSubsolversFieldNumber = 293;
3640 private static readonly pb::FieldCodec<string> _repeated_filterSubsolvers_codec
3641 = pb::FieldCodec.ForString(2346);
3642 private readonly pbc::RepeatedField<string> filterSubsolvers_ =
new pbc::RepeatedField<string>();
3643 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3644 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3645 public pbc::RepeatedField<string> FilterSubsolvers {
3646 get {
return filterSubsolvers_; }
3650 public const int SubsolverParamsFieldNumber = 210;
3651 private static readonly pb::FieldCodec<global::Google.OrTools.Sat.SatParameters> _repeated_subsolverParams_codec
3652 = pb::FieldCodec.ForMessage(1682, global::Google.OrTools.Sat.SatParameters.Parser);
3653 private readonly pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters> subsolverParams_ =
new pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters>();
3661 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3662 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3663 public pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters> SubsolverParams {
3664 get {
return subsolverParams_; }
3668 public const int InterleaveSearchFieldNumber = 136;
3669 private readonly
static bool InterleaveSearchDefaultValue =
false;
3671 private bool interleaveSearch_;
3680 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3681 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3682 public bool InterleaveSearch {
3683 get {
if ((_hasBits3 & 512) != 0) {
return interleaveSearch_; }
else {
return InterleaveSearchDefaultValue; } }
3686 interleaveSearch_ = value;
3690 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3691 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3692 public bool HasInterleaveSearch {
3693 get {
return (_hasBits3 & 512) != 0; }
3696 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3697 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3698 public void ClearInterleaveSearch() {
3703 public const int InterleaveBatchSizeFieldNumber = 134;
3704 private readonly
static int InterleaveBatchSizeDefaultValue = 0;
3706 private int interleaveBatchSize_;
3707 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3708 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3709 public int InterleaveBatchSize {
3710 get {
if ((_hasBits3 & 128) != 0) {
return interleaveBatchSize_; }
else {
return InterleaveBatchSizeDefaultValue; } }
3713 interleaveBatchSize_ = value;
3717 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3718 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3719 public bool HasInterleaveBatchSize {
3720 get {
return (_hasBits3 & 128) != 0; }
3723 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3724 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3725 public void ClearInterleaveBatchSize() {
3730 public const int ShareObjectiveBoundsFieldNumber = 113;
3731 private readonly
static bool ShareObjectiveBoundsDefaultValue =
true;
3733 private bool shareObjectiveBounds_;
3737 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3738 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3739 public bool ShareObjectiveBounds {
3740 get {
if ((_hasBits2 & 524288) != 0) {
return shareObjectiveBounds_; }
else {
return ShareObjectiveBoundsDefaultValue; } }
3742 _hasBits2 |= 524288;
3743 shareObjectiveBounds_ = value;
3747 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3748 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3749 public bool HasShareObjectiveBounds {
3750 get {
return (_hasBits2 & 524288) != 0; }
3753 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3754 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3755 public void ClearShareObjectiveBounds() {
3756 _hasBits2 &= ~524288;
3760 public const int ShareLevelZeroBoundsFieldNumber = 114;
3761 private readonly
static bool ShareLevelZeroBoundsDefaultValue =
true;
3763 private bool shareLevelZeroBounds_;
3767 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3768 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3769 public bool ShareLevelZeroBounds {
3770 get {
if ((_hasBits2 & 1048576) != 0) {
return shareLevelZeroBounds_; }
else {
return ShareLevelZeroBoundsDefaultValue; } }
3772 _hasBits2 |= 1048576;
3773 shareLevelZeroBounds_ = value;
3777 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3778 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3779 public bool HasShareLevelZeroBounds {
3780 get {
return (_hasBits2 & 1048576) != 0; }
3783 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3784 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3785 public void ClearShareLevelZeroBounds() {
3786 _hasBits2 &= ~1048576;
3790 public const int ShareBinaryClausesFieldNumber = 203;
3791 private readonly
static bool ShareBinaryClausesDefaultValue =
true;
3793 private bool shareBinaryClauses_;
3797 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3798 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3799 public bool ShareBinaryClauses {
3800 get {
if ((_hasBits5 & 4) != 0) {
return shareBinaryClauses_; }
else {
return ShareBinaryClausesDefaultValue; } }
3803 shareBinaryClauses_ = value;
3807 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3808 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3809 public bool HasShareBinaryClauses {
3810 get {
return (_hasBits5 & 4) != 0; }
3813 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3814 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3815 public void ClearShareBinaryClauses() {
3820 public const int ShareGlueClausesFieldNumber = 285;
3821 private readonly
static bool ShareGlueClausesDefaultValue =
false;
3823 private bool shareGlueClauses_;
3828 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3829 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3830 public bool ShareGlueClauses {
3831 get {
if ((_hasBits7 & 32) != 0) {
return shareGlueClauses_; }
else {
return ShareGlueClausesDefaultValue; } }
3834 shareGlueClauses_ = value;
3838 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3839 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3840 public bool HasShareGlueClauses {
3841 get {
return (_hasBits7 & 32) != 0; }
3844 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3845 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3846 public void ClearShareGlueClauses() {
3851 public const int DebugPostsolveWithFullSolverFieldNumber = 162;
3852 private readonly
static bool DebugPostsolveWithFullSolverDefaultValue =
false;
3854 private bool debugPostsolveWithFullSolver_;
3860 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3861 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3862 public bool DebugPostsolveWithFullSolver {
3863 get {
if ((_hasBits3 & 268435456) != 0) {
return debugPostsolveWithFullSolver_; }
else {
return DebugPostsolveWithFullSolverDefaultValue; } }
3865 _hasBits3 |= 268435456;
3866 debugPostsolveWithFullSolver_ = value;
3870 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3871 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3872 public bool HasDebugPostsolveWithFullSolver {
3873 get {
return (_hasBits3 & 268435456) != 0; }
3876 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3877 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3878 public void ClearDebugPostsolveWithFullSolver() {
3879 _hasBits3 &= ~268435456;
3883 public const int DebugMaxNumPresolveOperationsFieldNumber = 151;
3884 private readonly
static int DebugMaxNumPresolveOperationsDefaultValue = 0;
3886 private int debugMaxNumPresolveOperations_;
3891 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3892 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3893 public int DebugMaxNumPresolveOperations {
3894 get {
if ((_hasBits3 & 262144) != 0) {
return debugMaxNumPresolveOperations_; }
else {
return DebugMaxNumPresolveOperationsDefaultValue; } }
3896 _hasBits3 |= 262144;
3897 debugMaxNumPresolveOperations_ = value;
3901 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3902 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3903 public bool HasDebugMaxNumPresolveOperations {
3904 get {
return (_hasBits3 & 262144) != 0; }
3907 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3908 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3909 public void ClearDebugMaxNumPresolveOperations() {
3910 _hasBits3 &= ~262144;
3914 public const int DebugCrashOnBadHintFieldNumber = 195;
3915 private readonly
static bool DebugCrashOnBadHintDefaultValue =
false;
3917 private bool debugCrashOnBadHint_;
3921 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3922 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3923 public bool DebugCrashOnBadHint {
3924 get {
if ((_hasBits4 & 67108864) != 0) {
return debugCrashOnBadHint_; }
else {
return DebugCrashOnBadHintDefaultValue; } }
3926 _hasBits4 |= 67108864;
3927 debugCrashOnBadHint_ = value;
3931 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3932 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3933 public bool HasDebugCrashOnBadHint {
3934 get {
return (_hasBits4 & 67108864) != 0; }
3937 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3938 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3939 public void ClearDebugCrashOnBadHint() {
3940 _hasBits4 &= ~67108864;
3944 public const int UseOptimizationHintsFieldNumber = 35;
3945 private readonly
static bool UseOptimizationHintsDefaultValue =
true;
3947 private bool useOptimizationHints_;
3954 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3955 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3956 public bool UseOptimizationHints {
3957 get {
if ((_hasBits0 & 65536) != 0) {
return useOptimizationHints_; }
else {
return UseOptimizationHintsDefaultValue; } }
3960 useOptimizationHints_ = value;
3964 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3965 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3966 public bool HasUseOptimizationHints {
3967 get {
return (_hasBits0 & 65536) != 0; }
3970 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3971 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3972 public void ClearUseOptimizationHints() {
3973 _hasBits0 &= ~65536;
3977 public const int CoreMinimizationLevelFieldNumber = 50;
3978 private readonly
static int CoreMinimizationLevelDefaultValue = 2;
3980 private int coreMinimizationLevel_;
3987 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3988 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3989 public int CoreMinimizationLevel {
3990 get {
if ((_hasBits0 & 268435456) != 0) {
return coreMinimizationLevel_; }
else {
return CoreMinimizationLevelDefaultValue; } }
3992 _hasBits0 |= 268435456;
3993 coreMinimizationLevel_ = value;
3997 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3998 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3999 public bool HasCoreMinimizationLevel {
4000 get {
return (_hasBits0 & 268435456) != 0; }
4003 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4004 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4005 public void ClearCoreMinimizationLevel() {
4006 _hasBits0 &= ~268435456;
4010 public const int FindMultipleCoresFieldNumber = 84;
4011 private readonly
static bool FindMultipleCoresDefaultValue =
true;
4013 private bool findMultipleCores_;
4018 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4019 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4020 public bool FindMultipleCores {
4021 get {
if ((_hasBits1 & 134217728) != 0) {
return findMultipleCores_; }
else {
return FindMultipleCoresDefaultValue; } }
4023 _hasBits1 |= 134217728;
4024 findMultipleCores_ = value;
4028 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4029 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4030 public bool HasFindMultipleCores {
4031 get {
return (_hasBits1 & 134217728) != 0; }
4034 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4035 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4036 public void ClearFindMultipleCores() {
4037 _hasBits1 &= ~134217728;
4041 public const int CoverOptimizationFieldNumber = 89;
4042 private readonly
static bool CoverOptimizationDefaultValue =
true;
4044 private bool coverOptimization_;
4050 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4051 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4052 public bool CoverOptimization {
4053 get {
if ((_hasBits2 & 1) != 0) {
return coverOptimization_; }
else {
return CoverOptimizationDefaultValue; } }
4056 coverOptimization_ = value;
4060 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4061 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4062 public bool HasCoverOptimization {
4063 get {
return (_hasBits2 & 1) != 0; }
4066 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4067 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4068 public void ClearCoverOptimization() {
4073 public const int MaxSatAssumptionOrderFieldNumber = 51;
4074 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder MaxSatAssumptionOrderDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder.DefaultAssumptionOrder;
4076 private global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder maxSatAssumptionOrder_;
4077 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4078 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4079 public global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder MaxSatAssumptionOrder {
4080 get {
if ((_hasBits0 & 536870912) != 0) {
return maxSatAssumptionOrder_; }
else {
return MaxSatAssumptionOrderDefaultValue; } }
4082 _hasBits0 |= 536870912;
4083 maxSatAssumptionOrder_ = value;
4087 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4088 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4089 public bool HasMaxSatAssumptionOrder {
4090 get {
return (_hasBits0 & 536870912) != 0; }
4093 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4094 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4095 public void ClearMaxSatAssumptionOrder() {
4096 _hasBits0 &= ~536870912;
4100 public const int MaxSatReverseAssumptionOrderFieldNumber = 52;
4101 private readonly
static bool MaxSatReverseAssumptionOrderDefaultValue =
false;
4103 private bool maxSatReverseAssumptionOrder_;
4108 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4109 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4110 public bool MaxSatReverseAssumptionOrder {
4111 get {
if ((_hasBits0 & 1073741824) != 0) {
return maxSatReverseAssumptionOrder_; }
else {
return MaxSatReverseAssumptionOrderDefaultValue; } }
4113 _hasBits0 |= 1073741824;
4114 maxSatReverseAssumptionOrder_ = value;
4118 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4119 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4120 public bool HasMaxSatReverseAssumptionOrder {
4121 get {
return (_hasBits0 & 1073741824) != 0; }
4124 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4125 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4126 public void ClearMaxSatReverseAssumptionOrder() {
4127 _hasBits0 &= ~1073741824;
4131 public const int MaxSatStratificationFieldNumber = 53;
4132 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm MaxSatStratificationDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm.StratificationDescent;
4134 private global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm maxSatStratification_;
4135 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4136 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4137 public global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm MaxSatStratification {
4138 get {
if ((_hasBits0 & -2147483648) != 0) {
return maxSatStratification_; }
else {
return MaxSatStratificationDefaultValue; } }
4140 _hasBits0 |= -2147483648;
4141 maxSatStratification_ = value;
4145 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4146 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4147 public bool HasMaxSatStratification {
4148 get {
return (_hasBits0 & -2147483648) != 0; }
4151 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4152 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4153 public void ClearMaxSatStratification() {
4154 _hasBits0 &= ~-2147483648;
4158 public const int PropagationLoopDetectionFactorFieldNumber = 221;
4159 private readonly
static double PropagationLoopDetectionFactorDefaultValue = 10D;
4161 private double propagationLoopDetectionFactor_;
4173 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4174 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4175 public double PropagationLoopDetectionFactor {
4176 get {
if ((_hasBits5 & 4096) != 0) {
return propagationLoopDetectionFactor_; }
else {
return PropagationLoopDetectionFactorDefaultValue; } }
4179 propagationLoopDetectionFactor_ = value;
4183 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4184 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4185 public bool HasPropagationLoopDetectionFactor {
4186 get {
return (_hasBits5 & 4096) != 0; }
4189 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4190 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4191 public void ClearPropagationLoopDetectionFactor() {
4196 public const int UsePrecedencesInDisjunctiveConstraintFieldNumber = 74;
4197 private readonly
static bool UsePrecedencesInDisjunctiveConstraintDefaultValue =
true;
4199 private bool usePrecedencesInDisjunctiveConstraint_;
4211 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4212 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4213 public bool UsePrecedencesInDisjunctiveConstraint {
4214 get {
if ((_hasBits1 & 262144) != 0) {
return usePrecedencesInDisjunctiveConstraint_; }
else {
return UsePrecedencesInDisjunctiveConstraintDefaultValue; } }
4216 _hasBits1 |= 262144;
4217 usePrecedencesInDisjunctiveConstraint_ = value;
4221 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4222 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4223 public bool HasUsePrecedencesInDisjunctiveConstraint {
4224 get {
return (_hasBits1 & 262144) != 0; }
4227 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4228 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4229 public void ClearUsePrecedencesInDisjunctiveConstraint() {
4230 _hasBits1 &= ~262144;
4234 public const int MaxSizeToCreatePrecedenceLiteralsInDisjunctiveFieldNumber = 229;
4235 private readonly
static int MaxSizeToCreatePrecedenceLiteralsInDisjunctiveDefaultValue = 60;
4237 private int maxSizeToCreatePrecedenceLiteralsInDisjunctive_;
4245 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4246 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4247 public int MaxSizeToCreatePrecedenceLiteralsInDisjunctive {
4248 get {
if ((_hasBits5 & 1048576) != 0) {
return maxSizeToCreatePrecedenceLiteralsInDisjunctive_; }
else {
return MaxSizeToCreatePrecedenceLiteralsInDisjunctiveDefaultValue; } }
4250 _hasBits5 |= 1048576;
4251 maxSizeToCreatePrecedenceLiteralsInDisjunctive_ = value;
4255 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4256 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4257 public bool HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive {
4258 get {
return (_hasBits5 & 1048576) != 0; }
4261 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4262 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4263 public void ClearMaxSizeToCreatePrecedenceLiteralsInDisjunctive() {
4264 _hasBits5 &= ~1048576;
4268 public const int UseStrongPropagationInDisjunctiveFieldNumber = 230;
4269 private readonly
static bool UseStrongPropagationInDisjunctiveDefaultValue =
false;
4271 private bool useStrongPropagationInDisjunctive_;
4275 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4276 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4277 public bool UseStrongPropagationInDisjunctive {
4278 get {
if ((_hasBits5 & 2097152) != 0) {
return useStrongPropagationInDisjunctive_; }
else {
return UseStrongPropagationInDisjunctiveDefaultValue; } }
4280 _hasBits5 |= 2097152;
4281 useStrongPropagationInDisjunctive_ = value;
4285 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4286 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4287 public bool HasUseStrongPropagationInDisjunctive {
4288 get {
return (_hasBits5 & 2097152) != 0; }
4291 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4292 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4293 public void ClearUseStrongPropagationInDisjunctive() {
4294 _hasBits5 &= ~2097152;
4298 public const int UseDynamicPrecedenceInDisjunctiveFieldNumber = 263;
4299 private readonly
static bool UseDynamicPrecedenceInDisjunctiveDefaultValue =
false;
4301 private bool useDynamicPrecedenceInDisjunctive_;
4310 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4311 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4312 public bool UseDynamicPrecedenceInDisjunctive {
4313 get {
if ((_hasBits6 & 32768) != 0) {
return useDynamicPrecedenceInDisjunctive_; }
else {
return UseDynamicPrecedenceInDisjunctiveDefaultValue; } }
4316 useDynamicPrecedenceInDisjunctive_ = value;
4320 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4321 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4322 public bool HasUseDynamicPrecedenceInDisjunctive {
4323 get {
return (_hasBits6 & 32768) != 0; }
4326 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4327 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4328 public void ClearUseDynamicPrecedenceInDisjunctive() {
4329 _hasBits6 &= ~32768;
4333 public const int UseDynamicPrecedenceInCumulativeFieldNumber = 268;
4334 private readonly
static bool UseDynamicPrecedenceInCumulativeDefaultValue =
false;
4336 private bool useDynamicPrecedenceInCumulative_;
4337 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4338 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4339 public bool UseDynamicPrecedenceInCumulative {
4340 get {
if ((_hasBits6 & 1048576) != 0) {
return useDynamicPrecedenceInCumulative_; }
else {
return UseDynamicPrecedenceInCumulativeDefaultValue; } }
4342 _hasBits6 |= 1048576;
4343 useDynamicPrecedenceInCumulative_ = value;
4347 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4348 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4349 public bool HasUseDynamicPrecedenceInCumulative {
4350 get {
return (_hasBits6 & 1048576) != 0; }
4353 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4354 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4355 public void ClearUseDynamicPrecedenceInCumulative() {
4356 _hasBits6 &= ~1048576;
4360 public const int UseOverloadCheckerInCumulativeFieldNumber = 78;
4361 private readonly
static bool UseOverloadCheckerInCumulativeDefaultValue =
false;
4363 private bool useOverloadCheckerInCumulative_;
4373 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4374 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4375 public bool UseOverloadCheckerInCumulative {
4376 get {
if ((_hasBits1 & 4194304) != 0) {
return useOverloadCheckerInCumulative_; }
else {
return UseOverloadCheckerInCumulativeDefaultValue; } }
4378 _hasBits1 |= 4194304;
4379 useOverloadCheckerInCumulative_ = value;
4383 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4384 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4385 public bool HasUseOverloadCheckerInCumulative {
4386 get {
return (_hasBits1 & 4194304) != 0; }
4389 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4390 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4391 public void ClearUseOverloadCheckerInCumulative() {
4392 _hasBits1 &= ~4194304;
4396 public const int UseConservativeScaleOverloadCheckerFieldNumber = 286;
4397 private readonly
static bool UseConservativeScaleOverloadCheckerDefaultValue =
false;
4399 private bool useConservativeScaleOverloadChecker_;
4409 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4410 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4411 public bool UseConservativeScaleOverloadChecker {
4412 get {
if ((_hasBits7 & 64) != 0) {
return useConservativeScaleOverloadChecker_; }
else {
return UseConservativeScaleOverloadCheckerDefaultValue; } }
4415 useConservativeScaleOverloadChecker_ = value;
4419 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4420 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4421 public bool HasUseConservativeScaleOverloadChecker {
4422 get {
return (_hasBits7 & 64) != 0; }
4425 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4426 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4427 public void ClearUseConservativeScaleOverloadChecker() {
4432 public const int UseTimetableEdgeFindingInCumulativeFieldNumber = 79;
4433 private readonly
static bool UseTimetableEdgeFindingInCumulativeDefaultValue =
false;
4435 private bool useTimetableEdgeFindingInCumulative_;
4445 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4446 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4447 public bool UseTimetableEdgeFindingInCumulative {
4448 get {
if ((_hasBits1 & 8388608) != 0) {
return useTimetableEdgeFindingInCumulative_; }
else {
return UseTimetableEdgeFindingInCumulativeDefaultValue; } }
4450 _hasBits1 |= 8388608;
4451 useTimetableEdgeFindingInCumulative_ = value;
4455 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4456 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4457 public bool HasUseTimetableEdgeFindingInCumulative {
4458 get {
return (_hasBits1 & 8388608) != 0; }
4461 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4462 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4463 public void ClearUseTimetableEdgeFindingInCumulative() {
4464 _hasBits1 &= ~8388608;
4468 public const int MaxNumIntervalsForTimetableEdgeFindingFieldNumber = 260;
4469 private readonly
static int MaxNumIntervalsForTimetableEdgeFindingDefaultValue = 100;
4471 private int maxNumIntervalsForTimetableEdgeFinding_;
4476 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4477 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4478 public int MaxNumIntervalsForTimetableEdgeFinding {
4479 get {
if ((_hasBits6 & 4096) != 0) {
return maxNumIntervalsForTimetableEdgeFinding_; }
else {
return MaxNumIntervalsForTimetableEdgeFindingDefaultValue; } }
4482 maxNumIntervalsForTimetableEdgeFinding_ = value;
4486 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4487 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4488 public bool HasMaxNumIntervalsForTimetableEdgeFinding {
4489 get {
return (_hasBits6 & 4096) != 0; }
4492 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4493 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4494 public void ClearMaxNumIntervalsForTimetableEdgeFinding() {
4499 public const int UseHardPrecedencesInCumulativeFieldNumber = 215;
4500 private readonly
static bool UseHardPrecedencesInCumulativeDefaultValue =
false;
4502 private bool useHardPrecedencesInCumulative_;
4511 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4512 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4513 public bool UseHardPrecedencesInCumulative {
4514 get {
if ((_hasBits5 & 256) != 0) {
return useHardPrecedencesInCumulative_; }
else {
return UseHardPrecedencesInCumulativeDefaultValue; } }
4517 useHardPrecedencesInCumulative_ = value;
4521 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4522 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4523 public bool HasUseHardPrecedencesInCumulative {
4524 get {
return (_hasBits5 & 256) != 0; }
4527 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4528 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4529 public void ClearUseHardPrecedencesInCumulative() {
4534 public const int ExploitAllPrecedencesFieldNumber = 220;
4535 private readonly
static bool ExploitAllPrecedencesDefaultValue =
false;
4537 private bool exploitAllPrecedences_;
4538 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4539 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4540 public bool ExploitAllPrecedences {
4541 get {
if ((_hasBits5 & 2048) != 0) {
return exploitAllPrecedences_; }
else {
return ExploitAllPrecedencesDefaultValue; } }
4544 exploitAllPrecedences_ = value;
4548 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4549 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4550 public bool HasExploitAllPrecedences {
4551 get {
return (_hasBits5 & 2048) != 0; }
4554 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4555 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4556 public void ClearExploitAllPrecedences() {
4561 public const int UseDisjunctiveConstraintInCumulativeFieldNumber = 80;
4562 private readonly
static bool UseDisjunctiveConstraintInCumulativeDefaultValue =
true;
4564 private bool useDisjunctiveConstraintInCumulative_;
4577 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4578 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4579 public bool UseDisjunctiveConstraintInCumulative {
4580 get {
if ((_hasBits1 & 16777216) != 0) {
return useDisjunctiveConstraintInCumulative_; }
else {
return UseDisjunctiveConstraintInCumulativeDefaultValue; } }
4582 _hasBits1 |= 16777216;
4583 useDisjunctiveConstraintInCumulative_ = value;
4587 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4588 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4589 public bool HasUseDisjunctiveConstraintInCumulative {
4590 get {
return (_hasBits1 & 16777216) != 0; }
4593 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4594 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4595 public void ClearUseDisjunctiveConstraintInCumulative() {
4596 _hasBits1 &= ~16777216;
4600 public const int UseTimetablingInNoOverlap2DFieldNumber = 200;
4601 private readonly
static bool UseTimetablingInNoOverlap2DDefaultValue =
false;
4603 private bool useTimetablingInNoOverlap2D_;
4611 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4612 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4613 public bool UseTimetablingInNoOverlap2D {
4614 get {
if ((_hasBits4 & -2147483648) != 0) {
return useTimetablingInNoOverlap2D_; }
else {
return UseTimetablingInNoOverlap2DDefaultValue; } }
4616 _hasBits4 |= -2147483648;
4617 useTimetablingInNoOverlap2D_ = value;
4621 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4622 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4623 public bool HasUseTimetablingInNoOverlap2D {
4624 get {
return (_hasBits4 & -2147483648) != 0; }
4627 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4628 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4629 public void ClearUseTimetablingInNoOverlap2D() {
4630 _hasBits4 &= ~-2147483648;
4634 public const int UseEnergeticReasoningInNoOverlap2DFieldNumber = 213;
4635 private readonly
static bool UseEnergeticReasoningInNoOverlap2DDefaultValue =
false;
4637 private bool useEnergeticReasoningInNoOverlap2D_;
4643 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4644 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4645 public bool UseEnergeticReasoningInNoOverlap2D {
4646 get {
if ((_hasBits5 & 64) != 0) {
return useEnergeticReasoningInNoOverlap2D_; }
else {
return UseEnergeticReasoningInNoOverlap2DDefaultValue; } }
4649 useEnergeticReasoningInNoOverlap2D_ = value;
4653 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4654 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4655 public bool HasUseEnergeticReasoningInNoOverlap2D {
4656 get {
return (_hasBits5 & 64) != 0; }
4659 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4660 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4661 public void ClearUseEnergeticReasoningInNoOverlap2D() {
4666 public const int UseAreaEnergeticReasoningInNoOverlap2DFieldNumber = 271;
4667 private readonly
static bool UseAreaEnergeticReasoningInNoOverlap2DDefaultValue =
false;
4669 private bool useAreaEnergeticReasoningInNoOverlap2D_;
4675 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4676 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4677 public bool UseAreaEnergeticReasoningInNoOverlap2D {
4678 get {
if ((_hasBits6 & 8388608) != 0) {
return useAreaEnergeticReasoningInNoOverlap2D_; }
else {
return UseAreaEnergeticReasoningInNoOverlap2DDefaultValue; } }
4680 _hasBits6 |= 8388608;
4681 useAreaEnergeticReasoningInNoOverlap2D_ = value;
4685 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4686 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4687 public bool HasUseAreaEnergeticReasoningInNoOverlap2D {
4688 get {
return (_hasBits6 & 8388608) != 0; }
4691 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4692 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4693 public void ClearUseAreaEnergeticReasoningInNoOverlap2D() {
4694 _hasBits6 &= ~8388608;
4698 public const int MaxPairsPairwiseReasoningInNoOverlap2DFieldNumber = 276;
4699 private readonly
static int MaxPairsPairwiseReasoningInNoOverlap2DDefaultValue = 1250;
4701 private int maxPairsPairwiseReasoningInNoOverlap2D_;
4707 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4708 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4709 public int MaxPairsPairwiseReasoningInNoOverlap2D {
4710 get {
if ((_hasBits6 & 268435456) != 0) {
return maxPairsPairwiseReasoningInNoOverlap2D_; }
else {
return MaxPairsPairwiseReasoningInNoOverlap2DDefaultValue; } }
4712 _hasBits6 |= 268435456;
4713 maxPairsPairwiseReasoningInNoOverlap2D_ = value;
4717 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4718 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4719 public bool HasMaxPairsPairwiseReasoningInNoOverlap2D {
4720 get {
return (_hasBits6 & 268435456) != 0; }
4723 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4724 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4725 public void ClearMaxPairsPairwiseReasoningInNoOverlap2D() {
4726 _hasBits6 &= ~268435456;
4730 public const int UseDualSchedulingHeuristicsFieldNumber = 214;
4731 private readonly
static bool UseDualSchedulingHeuristicsDefaultValue =
true;
4733 private bool useDualSchedulingHeuristics_;
4739 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4740 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4741 public bool UseDualSchedulingHeuristics {
4742 get {
if ((_hasBits5 & 128) != 0) {
return useDualSchedulingHeuristics_; }
else {
return UseDualSchedulingHeuristicsDefaultValue; } }
4745 useDualSchedulingHeuristics_ = value;
4749 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4750 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4751 public bool HasUseDualSchedulingHeuristics {
4752 get {
return (_hasBits5 & 128) != 0; }
4755 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4756 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4757 public void ClearUseDualSchedulingHeuristics() {
4762 public const int SearchBranchingFieldNumber = 82;
4763 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.SearchBranching SearchBranchingDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.SearchBranching.AutomaticSearch;
4765 private global::Google.OrTools.Sat.SatParameters.Types.SearchBranching searchBranching_;
4766 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4767 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4768 public global::Google.OrTools.Sat.SatParameters.Types.SearchBranching SearchBranching {
4769 get {
if ((_hasBits1 & 33554432) != 0) {
return searchBranching_; }
else {
return SearchBranchingDefaultValue; } }
4771 _hasBits1 |= 33554432;
4772 searchBranching_ = value;
4776 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4777 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4778 public bool HasSearchBranching {
4779 get {
return (_hasBits1 & 33554432) != 0; }
4782 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4783 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4784 public void ClearSearchBranching() {
4785 _hasBits1 &= ~33554432;
4789 public const int HintConflictLimitFieldNumber = 153;
4790 private readonly
static int HintConflictLimitDefaultValue = 10;
4792 private int hintConflictLimit_;
4796 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4797 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4798 public int HintConflictLimit {
4799 get {
if ((_hasBits3 & 1048576) != 0) {
return hintConflictLimit_; }
else {
return HintConflictLimitDefaultValue; } }
4801 _hasBits3 |= 1048576;
4802 hintConflictLimit_ = value;
4806 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4807 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4808 public bool HasHintConflictLimit {
4809 get {
return (_hasBits3 & 1048576) != 0; }
4812 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4813 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4814 public void ClearHintConflictLimit() {
4815 _hasBits3 &= ~1048576;
4819 public const int RepairHintFieldNumber = 167;
4820 private readonly
static bool RepairHintDefaultValue =
false;
4822 private bool repairHint_;
4829 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4830 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4831 public bool RepairHint {
4832 get {
if ((_hasBits4 & 2) != 0) {
return repairHint_; }
else {
return RepairHintDefaultValue; } }
4835 repairHint_ = value;
4839 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4840 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4841 public bool HasRepairHint {
4842 get {
return (_hasBits4 & 2) != 0; }
4845 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4846 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4847 public void ClearRepairHint() {
4852 public const int FixVariablesToTheirHintedValueFieldNumber = 192;
4853 private readonly
static bool FixVariablesToTheirHintedValueDefaultValue =
false;
4855 private bool fixVariablesToTheirHintedValue_;
4860 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4861 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4862 public bool FixVariablesToTheirHintedValue {
4863 get {
if ((_hasBits4 & 8388608) != 0) {
return fixVariablesToTheirHintedValue_; }
else {
return FixVariablesToTheirHintedValueDefaultValue; } }
4865 _hasBits4 |= 8388608;
4866 fixVariablesToTheirHintedValue_ = value;
4870 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4871 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4872 public bool HasFixVariablesToTheirHintedValue {
4873 get {
return (_hasBits4 & 8388608) != 0; }
4876 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4877 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4878 public void ClearFixVariablesToTheirHintedValue() {
4879 _hasBits4 &= ~8388608;
4883 public const int UseProbingSearchFieldNumber = 176;
4884 private readonly
static bool UseProbingSearchDefaultValue =
false;
4886 private bool useProbingSearch_;
4892 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4893 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4894 public bool UseProbingSearch {
4895 get {
if ((_hasBits4 & 512) != 0) {
return useProbingSearch_; }
else {
return UseProbingSearchDefaultValue; } }
4898 useProbingSearch_ = value;
4902 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4903 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4904 public bool HasUseProbingSearch {
4905 get {
return (_hasBits4 & 512) != 0; }
4908 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4909 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4910 public void ClearUseProbingSearch() {
4915 public const int UseExtendedProbingFieldNumber = 269;
4916 private readonly
static bool UseExtendedProbingDefaultValue =
true;
4918 private bool useExtendedProbing_;
4922 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4923 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4924 public bool UseExtendedProbing {
4925 get {
if ((_hasBits6 & 2097152) != 0) {
return useExtendedProbing_; }
else {
return UseExtendedProbingDefaultValue; } }
4927 _hasBits6 |= 2097152;
4928 useExtendedProbing_ = value;
4932 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4933 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4934 public bool HasUseExtendedProbing {
4935 get {
return (_hasBits6 & 2097152) != 0; }
4938 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4939 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4940 public void ClearUseExtendedProbing() {
4941 _hasBits6 &= ~2097152;
4945 public const int ProbingNumCombinationsLimitFieldNumber = 272;
4946 private readonly
static int ProbingNumCombinationsLimitDefaultValue = 20000;
4948 private int probingNumCombinationsLimit_;
4952 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4953 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4954 public int ProbingNumCombinationsLimit {
4955 get {
if ((_hasBits6 & 16777216) != 0) {
return probingNumCombinationsLimit_; }
else {
return ProbingNumCombinationsLimitDefaultValue; } }
4957 _hasBits6 |= 16777216;
4958 probingNumCombinationsLimit_ = value;
4962 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4963 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4964 public bool HasProbingNumCombinationsLimit {
4965 get {
return (_hasBits6 & 16777216) != 0; }
4968 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4969 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4970 public void ClearProbingNumCombinationsLimit() {
4971 _hasBits6 &= ~16777216;
4975 public const int UseShavingInProbingSearchFieldNumber = 204;
4976 private readonly
static bool UseShavingInProbingSearchDefaultValue =
true;
4978 private bool useShavingInProbingSearch_;
4983 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4984 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4985 public bool UseShavingInProbingSearch {
4986 get {
if ((_hasBits5 & 8) != 0) {
return useShavingInProbingSearch_; }
else {
return UseShavingInProbingSearchDefaultValue; } }
4989 useShavingInProbingSearch_ = value;
4993 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4994 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4995 public bool HasUseShavingInProbingSearch {
4996 get {
return (_hasBits5 & 8) != 0; }
4999 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5000 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5001 public void ClearUseShavingInProbingSearch() {
5006 public const int ShavingSearchDeterministicTimeFieldNumber = 205;
5007 private readonly
static double ShavingSearchDeterministicTimeDefaultValue = 0.001D;
5009 private double shavingSearchDeterministicTime_;
5014 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5015 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5016 public double ShavingSearchDeterministicTime {
5017 get {
if ((_hasBits5 & 16) != 0) {
return shavingSearchDeterministicTime_; }
else {
return ShavingSearchDeterministicTimeDefaultValue; } }
5020 shavingSearchDeterministicTime_ = value;
5024 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5025 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5026 public bool HasShavingSearchDeterministicTime {
5027 get {
return (_hasBits5 & 16) != 0; }
5030 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5031 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5032 public void ClearShavingSearchDeterministicTime() {
5037 public const int ShavingSearchThresholdFieldNumber = 290;
5038 private readonly
static long ShavingSearchThresholdDefaultValue = 64L;
5040 private long shavingSearchThreshold_;
5047 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5048 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5049 public long ShavingSearchThreshold {
5050 get {
if ((_hasBits7 & 1024) != 0) {
return shavingSearchThreshold_; }
else {
return ShavingSearchThresholdDefaultValue; } }
5053 shavingSearchThreshold_ = value;
5057 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5058 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5059 public bool HasShavingSearchThreshold {
5060 get {
return (_hasBits7 & 1024) != 0; }
5063 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5064 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5065 public void ClearShavingSearchThreshold() {
5070 public const int UseObjectiveLbSearchFieldNumber = 228;
5071 private readonly
static bool UseObjectiveLbSearchDefaultValue =
false;
5073 private bool useObjectiveLbSearch_;
5078 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5079 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5080 public bool UseObjectiveLbSearch {
5081 get {
if ((_hasBits5 & 524288) != 0) {
return useObjectiveLbSearch_; }
else {
return UseObjectiveLbSearchDefaultValue; } }
5083 _hasBits5 |= 524288;
5084 useObjectiveLbSearch_ = value;
5088 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5089 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5090 public bool HasUseObjectiveLbSearch {
5091 get {
return (_hasBits5 & 524288) != 0; }
5094 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5095 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5096 public void ClearUseObjectiveLbSearch() {
5097 _hasBits5 &= ~524288;
5101 public const int UseObjectiveShavingSearchFieldNumber = 253;
5102 private readonly
static bool UseObjectiveShavingSearchDefaultValue =
false;
5104 private bool useObjectiveShavingSearch_;
5110 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5111 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5112 public bool UseObjectiveShavingSearch {
5113 get {
if ((_hasBits6 & 64) != 0) {
return useObjectiveShavingSearch_; }
else {
return UseObjectiveShavingSearchDefaultValue; } }
5116 useObjectiveShavingSearch_ = value;
5120 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5121 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5122 public bool HasUseObjectiveShavingSearch {
5123 get {
return (_hasBits6 & 64) != 0; }
5126 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5127 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5128 public void ClearUseObjectiveShavingSearch() {
5133 public const int UseVariablesShavingSearchFieldNumber = 289;
5134 private readonly
static bool UseVariablesShavingSearchDefaultValue =
false;
5136 private bool useVariablesShavingSearch_;
5141 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5142 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5143 public bool UseVariablesShavingSearch {
5144 get {
if ((_hasBits7 & 512) != 0) {
return useVariablesShavingSearch_; }
else {
return UseVariablesShavingSearchDefaultValue; } }
5147 useVariablesShavingSearch_ = value;
5151 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5152 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5153 public bool HasUseVariablesShavingSearch {
5154 get {
return (_hasBits7 & 512) != 0; }
5157 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5158 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5159 public void ClearUseVariablesShavingSearch() {
5164 public const int PseudoCostReliabilityThresholdFieldNumber = 123;
5165 private readonly
static long PseudoCostReliabilityThresholdDefaultValue = 100L;
5167 private long pseudoCostReliabilityThreshold_;
5172 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5173 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5174 public long PseudoCostReliabilityThreshold {
5175 get {
if ((_hasBits2 & 268435456) != 0) {
return pseudoCostReliabilityThreshold_; }
else {
return PseudoCostReliabilityThresholdDefaultValue; } }
5177 _hasBits2 |= 268435456;
5178 pseudoCostReliabilityThreshold_ = value;
5182 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5183 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5184 public bool HasPseudoCostReliabilityThreshold {
5185 get {
return (_hasBits2 & 268435456) != 0; }
5188 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5189 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5190 public void ClearPseudoCostReliabilityThreshold() {
5191 _hasBits2 &= ~268435456;
5195 public const int OptimizeWithCoreFieldNumber = 83;
5196 private readonly
static bool OptimizeWithCoreDefaultValue =
false;
5198 private bool optimizeWithCore_;
5205 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5206 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5207 public bool OptimizeWithCore {
5208 get {
if ((_hasBits1 & 67108864) != 0) {
return optimizeWithCore_; }
else {
return OptimizeWithCoreDefaultValue; } }
5210 _hasBits1 |= 67108864;
5211 optimizeWithCore_ = value;
5215 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5216 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5217 public bool HasOptimizeWithCore {
5218 get {
return (_hasBits1 & 67108864) != 0; }
5221 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5222 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5223 public void ClearOptimizeWithCore() {
5224 _hasBits1 &= ~67108864;
5228 public const int OptimizeWithLbTreeSearchFieldNumber = 188;
5229 private readonly
static bool OptimizeWithLbTreeSearchDefaultValue =
false;
5231 private bool optimizeWithLbTreeSearch_;
5239 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5240 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5241 public bool OptimizeWithLbTreeSearch {
5242 get {
if ((_hasBits4 & 524288) != 0) {
return optimizeWithLbTreeSearch_; }
else {
return OptimizeWithLbTreeSearchDefaultValue; } }
5244 _hasBits4 |= 524288;
5245 optimizeWithLbTreeSearch_ = value;
5249 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5250 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5251 public bool HasOptimizeWithLbTreeSearch {
5252 get {
return (_hasBits4 & 524288) != 0; }
5255 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5256 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5257 public void ClearOptimizeWithLbTreeSearch() {
5258 _hasBits4 &= ~524288;
5262 public const int SaveLpBasisInLbTreeSearchFieldNumber = 284;
5263 private readonly
static bool SaveLpBasisInLbTreeSearchDefaultValue =
false;
5265 private bool saveLpBasisInLbTreeSearch_;
5274 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5275 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5276 public bool SaveLpBasisInLbTreeSearch {
5277 get {
if ((_hasBits7 & 16) != 0) {
return saveLpBasisInLbTreeSearch_; }
else {
return SaveLpBasisInLbTreeSearchDefaultValue; } }
5280 saveLpBasisInLbTreeSearch_ = value;
5284 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5285 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5286 public bool HasSaveLpBasisInLbTreeSearch {
5287 get {
return (_hasBits7 & 16) != 0; }
5290 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5291 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5292 public void ClearSaveLpBasisInLbTreeSearch() {
5297 public const int BinarySearchNumConflictsFieldNumber = 99;
5298 private readonly
static int BinarySearchNumConflictsDefaultValue = -1;
5300 private int binarySearchNumConflicts_;
5307 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5308 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5309 public int BinarySearchNumConflicts {
5310 get {
if ((_hasBits2 & 256) != 0) {
return binarySearchNumConflicts_; }
else {
return BinarySearchNumConflictsDefaultValue; } }
5313 binarySearchNumConflicts_ = value;
5317 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5318 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5319 public bool HasBinarySearchNumConflicts {
5320 get {
return (_hasBits2 & 256) != 0; }
5323 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5324 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5325 public void ClearBinarySearchNumConflicts() {
5330 public const int OptimizeWithMaxHsFieldNumber = 85;
5331 private readonly
static bool OptimizeWithMaxHsDefaultValue =
false;
5333 private bool optimizeWithMaxHs_;
5342 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5343 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5344 public bool OptimizeWithMaxHs {
5345 get {
if ((_hasBits1 & 268435456) != 0) {
return optimizeWithMaxHs_; }
else {
return OptimizeWithMaxHsDefaultValue; } }
5347 _hasBits1 |= 268435456;
5348 optimizeWithMaxHs_ = value;
5352 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5353 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5354 public bool HasOptimizeWithMaxHs {
5355 get {
return (_hasBits1 & 268435456) != 0; }
5358 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5359 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5360 public void ClearOptimizeWithMaxHs() {
5361 _hasBits1 &= ~268435456;
5365 public const int UseFeasibilityJumpFieldNumber = 265;
5366 private readonly
static bool UseFeasibilityJumpDefaultValue =
true;
5368 private bool useFeasibilityJump_;
5374 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5375 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5376 public bool UseFeasibilityJump {
5377 get {
if ((_hasBits6 & 131072) != 0) {
return useFeasibilityJump_; }
else {
return UseFeasibilityJumpDefaultValue; } }
5379 _hasBits6 |= 131072;
5380 useFeasibilityJump_ = value;
5384 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5385 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5386 public bool HasUseFeasibilityJump {
5387 get {
return (_hasBits6 & 131072) != 0; }
5390 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5391 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5392 public void ClearUseFeasibilityJump() {
5393 _hasBits6 &= ~131072;
5397 public const int UseLsOnlyFieldNumber = 240;
5398 private readonly
static bool UseLsOnlyDefaultValue =
false;
5400 private bool useLsOnly_;
5405 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5406 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5407 public bool UseLsOnly {
5408 get {
if ((_hasBits5 & 1073741824) != 0) {
return useLsOnly_; }
else {
return UseLsOnlyDefaultValue; } }
5410 _hasBits5 |= 1073741824;
5415 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5416 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5417 public bool HasUseLsOnly {
5418 get {
return (_hasBits5 & 1073741824) != 0; }
5421 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5422 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5423 public void ClearUseLsOnly() {
5424 _hasBits5 &= ~1073741824;
5428 public const int FeasibilityJumpDecayFieldNumber = 242;
5429 private readonly
static double FeasibilityJumpDecayDefaultValue = 0.95D;
5431 private double feasibilityJumpDecay_;
5436 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5437 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5438 public double FeasibilityJumpDecay {
5439 get {
if ((_hasBits5 & -2147483648) != 0) {
return feasibilityJumpDecay_; }
else {
return FeasibilityJumpDecayDefaultValue; } }
5441 _hasBits5 |= -2147483648;
5442 feasibilityJumpDecay_ = value;
5446 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5447 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5448 public bool HasFeasibilityJumpDecay {
5449 get {
return (_hasBits5 & -2147483648) != 0; }
5452 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5453 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5454 public void ClearFeasibilityJumpDecay() {
5455 _hasBits5 &= ~-2147483648;
5459 public const int FeasibilityJumpLinearizationLevelFieldNumber = 257;
5460 private readonly
static int FeasibilityJumpLinearizationLevelDefaultValue = 2;
5462 private int feasibilityJumpLinearizationLevel_;
5466 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5467 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5468 public int FeasibilityJumpLinearizationLevel {
5469 get {
if ((_hasBits6 & 512) != 0) {
return feasibilityJumpLinearizationLevel_; }
else {
return FeasibilityJumpLinearizationLevelDefaultValue; } }
5472 feasibilityJumpLinearizationLevel_ = value;
5476 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5477 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5478 public bool HasFeasibilityJumpLinearizationLevel {
5479 get {
return (_hasBits6 & 512) != 0; }
5482 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5483 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5484 public void ClearFeasibilityJumpLinearizationLevel() {
5489 public const int FeasibilityJumpRestartFactorFieldNumber = 258;
5490 private readonly
static int FeasibilityJumpRestartFactorDefaultValue = 1;
5492 private int feasibilityJumpRestartFactor_;
5497 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5498 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5499 public int FeasibilityJumpRestartFactor {
5500 get {
if ((_hasBits6 & 1024) != 0) {
return feasibilityJumpRestartFactor_; }
else {
return FeasibilityJumpRestartFactorDefaultValue; } }
5503 feasibilityJumpRestartFactor_ = value;
5507 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5508 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5509 public bool HasFeasibilityJumpRestartFactor {
5510 get {
return (_hasBits6 & 1024) != 0; }
5513 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5514 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5515 public void ClearFeasibilityJumpRestartFactor() {
5520 public const int FeasibilityJumpBatchDtimeFieldNumber = 292;
5521 private readonly
static double FeasibilityJumpBatchDtimeDefaultValue = 0.1D;
5523 private double feasibilityJumpBatchDtime_;
5527 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5528 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5529 public double FeasibilityJumpBatchDtime {
5530 get {
if ((_hasBits7 & 4096) != 0) {
return feasibilityJumpBatchDtime_; }
else {
return FeasibilityJumpBatchDtimeDefaultValue; } }
5533 feasibilityJumpBatchDtime_ = value;
5537 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5538 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5539 public bool HasFeasibilityJumpBatchDtime {
5540 get {
return (_hasBits7 & 4096) != 0; }
5543 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5544 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5545 public void ClearFeasibilityJumpBatchDtime() {
5550 public const int FeasibilityJumpVarRandomizationProbabilityFieldNumber = 247;
5551 private readonly
static double FeasibilityJumpVarRandomizationProbabilityDefaultValue = 0.05D;
5553 private double feasibilityJumpVarRandomizationProbability_;
5558 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5559 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5560 public double FeasibilityJumpVarRandomizationProbability {
5561 get {
if ((_hasBits6 & 2) != 0) {
return feasibilityJumpVarRandomizationProbability_; }
else {
return FeasibilityJumpVarRandomizationProbabilityDefaultValue; } }
5564 feasibilityJumpVarRandomizationProbability_ = value;
5568 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5569 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5570 public bool HasFeasibilityJumpVarRandomizationProbability {
5571 get {
return (_hasBits6 & 2) != 0; }
5574 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5575 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5576 public void ClearFeasibilityJumpVarRandomizationProbability() {
5581 public const int FeasibilityJumpVarPerburbationRangeRatioFieldNumber = 248;
5582 private readonly
static double FeasibilityJumpVarPerburbationRangeRatioDefaultValue = 0.2D;
5584 private double feasibilityJumpVarPerburbationRangeRatio_;
5589 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5590 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5591 public double FeasibilityJumpVarPerburbationRangeRatio {
5592 get {
if ((_hasBits6 & 4) != 0) {
return feasibilityJumpVarPerburbationRangeRatio_; }
else {
return FeasibilityJumpVarPerburbationRangeRatioDefaultValue; } }
5595 feasibilityJumpVarPerburbationRangeRatio_ = value;
5599 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5600 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5601 public bool HasFeasibilityJumpVarPerburbationRangeRatio {
5602 get {
return (_hasBits6 & 4) != 0; }
5605 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5606 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5607 public void ClearFeasibilityJumpVarPerburbationRangeRatio() {
5612 public const int FeasibilityJumpEnableRestartsFieldNumber = 250;
5613 private readonly
static bool FeasibilityJumpEnableRestartsDefaultValue =
true;
5615 private bool feasibilityJumpEnableRestarts_;
5621 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5622 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5623 public bool FeasibilityJumpEnableRestarts {
5624 get {
if ((_hasBits6 & 16) != 0) {
return feasibilityJumpEnableRestarts_; }
else {
return FeasibilityJumpEnableRestartsDefaultValue; } }
5627 feasibilityJumpEnableRestarts_ = value;
5631 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5632 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5633 public bool HasFeasibilityJumpEnableRestarts {
5634 get {
return (_hasBits6 & 16) != 0; }
5637 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5638 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5639 public void ClearFeasibilityJumpEnableRestarts() {
5644 public const int FeasibilityJumpMaxExpandedConstraintSizeFieldNumber = 264;
5645 private readonly
static int FeasibilityJumpMaxExpandedConstraintSizeDefaultValue = 500;
5647 private int feasibilityJumpMaxExpandedConstraintSize_;
5654 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5655 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5656 public int FeasibilityJumpMaxExpandedConstraintSize {
5657 get {
if ((_hasBits6 & 65536) != 0) {
return feasibilityJumpMaxExpandedConstraintSize_; }
else {
return FeasibilityJumpMaxExpandedConstraintSizeDefaultValue; } }
5660 feasibilityJumpMaxExpandedConstraintSize_ = value;
5664 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5665 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5666 public bool HasFeasibilityJumpMaxExpandedConstraintSize {
5667 get {
return (_hasBits6 & 65536) != 0; }
5670 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5671 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5672 public void ClearFeasibilityJumpMaxExpandedConstraintSize() {
5673 _hasBits6 &= ~65536;
5677 public const int NumViolationLsFieldNumber = 244;
5678 private readonly
static int NumViolationLsDefaultValue = 0;
5680 private int numViolationLs_;
5686 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5687 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5688 public int NumViolationLs {
5689 get {
if ((_hasBits6 & 1) != 0) {
return numViolationLs_; }
else {
return NumViolationLsDefaultValue; } }
5692 numViolationLs_ = value;
5696 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5697 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5698 public bool HasNumViolationLs {
5699 get {
return (_hasBits6 & 1) != 0; }
5702 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5703 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5704 public void ClearNumViolationLs() {
5709 public const int ViolationLsPerturbationPeriodFieldNumber = 249;
5710 private readonly
static int ViolationLsPerturbationPeriodDefaultValue = 100;
5712 private int violationLsPerturbationPeriod_;
5716 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5717 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5718 public int ViolationLsPerturbationPeriod {
5719 get {
if ((_hasBits6 & 8) != 0) {
return violationLsPerturbationPeriod_; }
else {
return ViolationLsPerturbationPeriodDefaultValue; } }
5722 violationLsPerturbationPeriod_ = value;
5726 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5727 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5728 public bool HasViolationLsPerturbationPeriod {
5729 get {
return (_hasBits6 & 8) != 0; }
5732 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5733 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5734 public void ClearViolationLsPerturbationPeriod() {
5739 public const int ViolationLsCompoundMoveProbabilityFieldNumber = 259;
5740 private readonly
static double ViolationLsCompoundMoveProbabilityDefaultValue = 0.5D;
5742 private double violationLsCompoundMoveProbability_;
5747 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5748 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5749 public double ViolationLsCompoundMoveProbability {
5750 get {
if ((_hasBits6 & 2048) != 0) {
return violationLsCompoundMoveProbability_; }
else {
return ViolationLsCompoundMoveProbabilityDefaultValue; } }
5753 violationLsCompoundMoveProbability_ = value;
5757 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5758 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5759 public bool HasViolationLsCompoundMoveProbability {
5760 get {
return (_hasBits6 & 2048) != 0; }
5763 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5764 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5765 public void ClearViolationLsCompoundMoveProbability() {
5770 public const int SharedTreeNumWorkersFieldNumber = 235;
5771 private readonly
static int SharedTreeNumWorkersDefaultValue = 0;
5773 private int sharedTreeNumWorkers_;
5781 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5782 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5783 public int SharedTreeNumWorkers {
5784 get {
if ((_hasBits5 & 33554432) != 0) {
return sharedTreeNumWorkers_; }
else {
return SharedTreeNumWorkersDefaultValue; } }
5786 _hasBits5 |= 33554432;
5787 sharedTreeNumWorkers_ = value;
5791 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5792 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5793 public bool HasSharedTreeNumWorkers {
5794 get {
return (_hasBits5 & 33554432) != 0; }
5797 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5798 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5799 public void ClearSharedTreeNumWorkers() {
5800 _hasBits5 &= ~33554432;
5804 public const int UseSharedTreeSearchFieldNumber = 236;
5805 private readonly
static bool UseSharedTreeSearchDefaultValue =
false;
5807 private bool useSharedTreeSearch_;
5811 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5812 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5813 public bool UseSharedTreeSearch {
5814 get {
if ((_hasBits5 & 67108864) != 0) {
return useSharedTreeSearch_; }
else {
return UseSharedTreeSearchDefaultValue; } }
5816 _hasBits5 |= 67108864;
5817 useSharedTreeSearch_ = value;
5821 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5822 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5823 public bool HasUseSharedTreeSearch {
5824 get {
return (_hasBits5 & 67108864) != 0; }
5827 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5828 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5829 public void ClearUseSharedTreeSearch() {
5830 _hasBits5 &= ~67108864;
5834 public const int SharedTreeWorkerObjectiveSplitProbabilityFieldNumber = 237;
5835 private readonly
static double SharedTreeWorkerObjectiveSplitProbabilityDefaultValue = 0.5D;
5837 private double sharedTreeWorkerObjectiveSplitProbability_;
5843 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5844 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5845 public double SharedTreeWorkerObjectiveSplitProbability {
5846 get {
if ((_hasBits5 & 134217728) != 0) {
return sharedTreeWorkerObjectiveSplitProbability_; }
else {
return SharedTreeWorkerObjectiveSplitProbabilityDefaultValue; } }
5848 _hasBits5 |= 134217728;
5849 sharedTreeWorkerObjectiveSplitProbability_ = value;
5853 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5854 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5855 public bool HasSharedTreeWorkerObjectiveSplitProbability {
5856 get {
return (_hasBits5 & 134217728) != 0; }
5859 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5860 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5861 public void ClearSharedTreeWorkerObjectiveSplitProbability() {
5862 _hasBits5 &= ~134217728;
5866 public const int SharedTreeWorkerMinRestartsPerSubtreeFieldNumber = 282;
5867 private readonly
static int SharedTreeWorkerMinRestartsPerSubtreeDefaultValue = 1;
5869 private int sharedTreeWorkerMinRestartsPerSubtree_;
5874 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5875 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5876 public int SharedTreeWorkerMinRestartsPerSubtree {
5877 get {
if ((_hasBits7 & 4) != 0) {
return sharedTreeWorkerMinRestartsPerSubtree_; }
else {
return SharedTreeWorkerMinRestartsPerSubtreeDefaultValue; } }
5880 sharedTreeWorkerMinRestartsPerSubtree_ = value;
5884 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5885 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5886 public bool HasSharedTreeWorkerMinRestartsPerSubtree {
5887 get {
return (_hasBits7 & 4) != 0; }
5890 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5891 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5892 public void ClearSharedTreeWorkerMinRestartsPerSubtree() {
5897 public const int SharedTreeWorkerEnableTrailSharingFieldNumber = 295;
5898 private readonly
static bool SharedTreeWorkerEnableTrailSharingDefaultValue =
true;
5900 private bool sharedTreeWorkerEnableTrailSharing_;
5907 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5908 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5909 public bool SharedTreeWorkerEnableTrailSharing {
5910 get {
if ((_hasBits7 & 16384) != 0) {
return sharedTreeWorkerEnableTrailSharing_; }
else {
return SharedTreeWorkerEnableTrailSharingDefaultValue; } }
5913 sharedTreeWorkerEnableTrailSharing_ = value;
5917 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5918 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5919 public bool HasSharedTreeWorkerEnableTrailSharing {
5920 get {
return (_hasBits7 & 16384) != 0; }
5923 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5924 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5925 public void ClearSharedTreeWorkerEnableTrailSharing() {
5926 _hasBits7 &= ~16384;
5930 public const int SharedTreeOpenLeavesPerWorkerFieldNumber = 281;
5931 private readonly
static double SharedTreeOpenLeavesPerWorkerDefaultValue = 2D;
5933 private double sharedTreeOpenLeavesPerWorker_;
5937 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5938 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5939 public double SharedTreeOpenLeavesPerWorker {
5940 get {
if ((_hasBits7 & 2) != 0) {
return sharedTreeOpenLeavesPerWorker_; }
else {
return SharedTreeOpenLeavesPerWorkerDefaultValue; } }
5943 sharedTreeOpenLeavesPerWorker_ = value;
5947 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5948 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5949 public bool HasSharedTreeOpenLeavesPerWorker {
5950 get {
return (_hasBits7 & 2) != 0; }
5953 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5954 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5955 public void ClearSharedTreeOpenLeavesPerWorker() {
5960 public const int SharedTreeMaxNodesPerWorkerFieldNumber = 238;
5961 private readonly
static int SharedTreeMaxNodesPerWorkerDefaultValue = 100000;
5963 private int sharedTreeMaxNodesPerWorker_;
5970 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5971 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5972 public int SharedTreeMaxNodesPerWorker {
5973 get {
if ((_hasBits5 & 268435456) != 0) {
return sharedTreeMaxNodesPerWorker_; }
else {
return SharedTreeMaxNodesPerWorkerDefaultValue; } }
5975 _hasBits5 |= 268435456;
5976 sharedTreeMaxNodesPerWorker_ = value;
5980 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5981 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5982 public bool HasSharedTreeMaxNodesPerWorker {
5983 get {
return (_hasBits5 & 268435456) != 0; }
5986 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5987 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5988 public void ClearSharedTreeMaxNodesPerWorker() {
5989 _hasBits5 &= ~268435456;
5993 public const int SharedTreeSplitStrategyFieldNumber = 239;
5994 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy SharedTreeSplitStrategyDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy.SplitStrategyAuto;
5996 private global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy sharedTreeSplitStrategy_;
5997 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5998 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5999 public global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy SharedTreeSplitStrategy {
6000 get {
if ((_hasBits5 & 536870912) != 0) {
return sharedTreeSplitStrategy_; }
else {
return SharedTreeSplitStrategyDefaultValue; } }
6002 _hasBits5 |= 536870912;
6003 sharedTreeSplitStrategy_ = value;
6007 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6008 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6009 public bool HasSharedTreeSplitStrategy {
6010 get {
return (_hasBits5 & 536870912) != 0; }
6013 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6014 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6015 public void ClearSharedTreeSplitStrategy() {
6016 _hasBits5 &= ~536870912;
6020 public const int EnumerateAllSolutionsFieldNumber = 87;
6021 private readonly
static bool EnumerateAllSolutionsDefaultValue =
false;
6023 private bool enumerateAllSolutions_;
6033 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6034 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6035 public bool EnumerateAllSolutions {
6036 get {
if ((_hasBits1 & 1073741824) != 0) {
return enumerateAllSolutions_; }
else {
return EnumerateAllSolutionsDefaultValue; } }
6038 _hasBits1 |= 1073741824;
6039 enumerateAllSolutions_ = value;
6043 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6044 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6045 public bool HasEnumerateAllSolutions {
6046 get {
return (_hasBits1 & 1073741824) != 0; }
6049 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6050 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6051 public void ClearEnumerateAllSolutions() {
6052 _hasBits1 &= ~1073741824;
6056 public const int KeepAllFeasibleSolutionsInPresolveFieldNumber = 173;
6057 private readonly
static bool KeepAllFeasibleSolutionsInPresolveDefaultValue =
false;
6059 private bool keepAllFeasibleSolutionsInPresolve_;
6070 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6071 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6072 public bool KeepAllFeasibleSolutionsInPresolve {
6073 get {
if ((_hasBits4 & 64) != 0) {
return keepAllFeasibleSolutionsInPresolve_; }
else {
return KeepAllFeasibleSolutionsInPresolveDefaultValue; } }
6076 keepAllFeasibleSolutionsInPresolve_ = value;
6080 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6081 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6082 public bool HasKeepAllFeasibleSolutionsInPresolve {
6083 get {
return (_hasBits4 & 64) != 0; }
6086 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6087 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6088 public void ClearKeepAllFeasibleSolutionsInPresolve() {
6093 public const int FillTightenedDomainsInResponseFieldNumber = 132;
6094 private readonly
static bool FillTightenedDomainsInResponseDefaultValue =
false;
6096 private bool fillTightenedDomainsInResponse_;
6104 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6105 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6106 public bool FillTightenedDomainsInResponse {
6107 get {
if ((_hasBits3 & 32) != 0) {
return fillTightenedDomainsInResponse_; }
else {
return FillTightenedDomainsInResponseDefaultValue; } }
6110 fillTightenedDomainsInResponse_ = value;
6114 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6115 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6116 public bool HasFillTightenedDomainsInResponse {
6117 get {
return (_hasBits3 & 32) != 0; }
6120 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6121 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6122 public void ClearFillTightenedDomainsInResponse() {
6127 public const int FillAdditionalSolutionsInResponseFieldNumber = 194;
6128 private readonly
static bool FillAdditionalSolutionsInResponseDefaultValue =
false;
6130 private bool fillAdditionalSolutionsInResponse_;
6143 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6144 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6145 public bool FillAdditionalSolutionsInResponse {
6146 get {
if ((_hasBits4 & 33554432) != 0) {
return fillAdditionalSolutionsInResponse_; }
else {
return FillAdditionalSolutionsInResponseDefaultValue; } }
6148 _hasBits4 |= 33554432;
6149 fillAdditionalSolutionsInResponse_ = value;
6153 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6154 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6155 public bool HasFillAdditionalSolutionsInResponse {
6156 get {
return (_hasBits4 & 33554432) != 0; }
6159 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6160 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6161 public void ClearFillAdditionalSolutionsInResponse() {
6162 _hasBits4 &= ~33554432;
6166 public const int InstantiateAllVariablesFieldNumber = 106;
6167 private readonly
static bool InstantiateAllVariablesDefaultValue =
true;
6169 private bool instantiateAllVariables_;
6176 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6177 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6178 public bool InstantiateAllVariables {
6179 get {
if ((_hasBits2 & 8192) != 0) {
return instantiateAllVariables_; }
else {
return InstantiateAllVariablesDefaultValue; } }
6182 instantiateAllVariables_ = value;
6186 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6187 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6188 public bool HasInstantiateAllVariables {
6189 get {
return (_hasBits2 & 8192) != 0; }
6192 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6193 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6194 public void ClearInstantiateAllVariables() {
6199 public const int AutoDetectGreaterThanAtLeastOneOfFieldNumber = 95;
6200 private readonly
static bool AutoDetectGreaterThanAtLeastOneOfDefaultValue =
true;
6202 private bool autoDetectGreaterThanAtLeastOneOf_;
6209 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6210 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6211 public bool AutoDetectGreaterThanAtLeastOneOf {
6212 get {
if ((_hasBits2 & 64) != 0) {
return autoDetectGreaterThanAtLeastOneOf_; }
else {
return AutoDetectGreaterThanAtLeastOneOfDefaultValue; } }
6215 autoDetectGreaterThanAtLeastOneOf_ = value;
6219 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6220 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6221 public bool HasAutoDetectGreaterThanAtLeastOneOf {
6222 get {
return (_hasBits2 & 64) != 0; }
6225 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6226 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6227 public void ClearAutoDetectGreaterThanAtLeastOneOf() {
6232 public const int StopAfterFirstSolutionFieldNumber = 98;
6233 private readonly
static bool StopAfterFirstSolutionDefaultValue =
false;
6235 private bool stopAfterFirstSolution_;
6239 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6240 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6241 public bool StopAfterFirstSolution {
6242 get {
if ((_hasBits2 & 128) != 0) {
return stopAfterFirstSolution_; }
else {
return StopAfterFirstSolutionDefaultValue; } }
6245 stopAfterFirstSolution_ = value;
6249 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6250 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6251 public bool HasStopAfterFirstSolution {
6252 get {
return (_hasBits2 & 128) != 0; }
6255 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6256 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6257 public void ClearStopAfterFirstSolution() {
6262 public const int StopAfterPresolveFieldNumber = 149;
6263 private readonly
static bool StopAfterPresolveDefaultValue =
false;
6265 private bool stopAfterPresolve_;
6270 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6271 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6272 public bool StopAfterPresolve {
6273 get {
if ((_hasBits3 & 131072) != 0) {
return stopAfterPresolve_; }
else {
return StopAfterPresolveDefaultValue; } }
6275 _hasBits3 |= 131072;
6276 stopAfterPresolve_ = value;
6280 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6281 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6282 public bool HasStopAfterPresolve {
6283 get {
return (_hasBits3 & 131072) != 0; }
6286 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6287 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6288 public void ClearStopAfterPresolve() {
6289 _hasBits3 &= ~131072;
6293 public const int StopAfterRootPropagationFieldNumber = 252;
6294 private readonly
static bool StopAfterRootPropagationDefaultValue =
false;
6296 private bool stopAfterRootPropagation_;
6297 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6298 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6299 public bool StopAfterRootPropagation {
6300 get {
if ((_hasBits6 & 32) != 0) {
return stopAfterRootPropagation_; }
else {
return StopAfterRootPropagationDefaultValue; } }
6303 stopAfterRootPropagation_ = value;
6307 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6308 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6309 public bool HasStopAfterRootPropagation {
6310 get {
return (_hasBits6 & 32) != 0; }
6313 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6314 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6315 public void ClearStopAfterRootPropagation() {
6320 public const int UseLnsFieldNumber = 283;
6321 private readonly
static bool UseLnsDefaultValue =
true;
6323 private bool useLns_;
6327 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6328 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6329 public bool UseLns {
6330 get {
if ((_hasBits7 & 8) != 0) {
return useLns_; }
else {
return UseLnsDefaultValue; } }
6337 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6338 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6339 public bool HasUseLns {
6340 get {
return (_hasBits7 & 8) != 0; }
6343 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6344 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6345 public void ClearUseLns() {
6350 public const int UseLnsOnlyFieldNumber = 101;
6351 private readonly
static bool UseLnsOnlyDefaultValue =
false;
6353 private bool useLnsOnly_;
6357 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6358 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6359 public bool UseLnsOnly {
6360 get {
if ((_hasBits2 & 1024) != 0) {
return useLnsOnly_; }
else {
return UseLnsOnlyDefaultValue; } }
6363 useLnsOnly_ = value;
6367 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6368 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6369 public bool HasUseLnsOnly {
6370 get {
return (_hasBits2 & 1024) != 0; }
6373 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6374 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6375 public void ClearUseLnsOnly() {
6380 public const int SolutionPoolSizeFieldNumber = 193;
6381 private readonly
static int SolutionPoolSizeDefaultValue = 3;
6383 private int solutionPoolSize_;
6389 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6390 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6391 public int SolutionPoolSize {
6392 get {
if ((_hasBits4 & 16777216) != 0) {
return solutionPoolSize_; }
else {
return SolutionPoolSizeDefaultValue; } }
6394 _hasBits4 |= 16777216;
6395 solutionPoolSize_ = value;
6399 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6400 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6401 public bool HasSolutionPoolSize {
6402 get {
return (_hasBits4 & 16777216) != 0; }
6405 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6406 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6407 public void ClearSolutionPoolSize() {
6408 _hasBits4 &= ~16777216;
6412 public const int UseRinsLnsFieldNumber = 129;
6413 private readonly
static bool UseRinsLnsDefaultValue =
true;
6415 private bool useRinsLns_;
6419 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6420 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6421 public bool UseRinsLns {
6422 get {
if ((_hasBits3 & 4) != 0) {
return useRinsLns_; }
else {
return UseRinsLnsDefaultValue; } }
6425 useRinsLns_ = value;
6429 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6430 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6431 public bool HasUseRinsLns {
6432 get {
return (_hasBits3 & 4) != 0; }
6435 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6436 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6437 public void ClearUseRinsLns() {
6442 public const int UseFeasibilityPumpFieldNumber = 164;
6443 private readonly
static bool UseFeasibilityPumpDefaultValue =
true;
6445 private bool useFeasibilityPump_;
6449 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6450 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6451 public bool UseFeasibilityPump {
6452 get {
if ((_hasBits3 & 1073741824) != 0) {
return useFeasibilityPump_; }
else {
return UseFeasibilityPumpDefaultValue; } }
6454 _hasBits3 |= 1073741824;
6455 useFeasibilityPump_ = value;
6459 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6460 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6461 public bool HasUseFeasibilityPump {
6462 get {
return (_hasBits3 & 1073741824) != 0; }
6465 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6466 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6467 public void ClearUseFeasibilityPump() {
6468 _hasBits3 &= ~1073741824;
6472 public const int UseLbRelaxLnsFieldNumber = 255;
6473 private readonly
static bool UseLbRelaxLnsDefaultValue =
false;
6475 private bool useLbRelaxLns_;
6481 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6482 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6483 public bool UseLbRelaxLns {
6484 get {
if ((_hasBits6 & 128) != 0) {
return useLbRelaxLns_; }
else {
return UseLbRelaxLnsDefaultValue; } }
6487 useLbRelaxLns_ = value;
6491 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6492 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6493 public bool HasUseLbRelaxLns {
6494 get {
return (_hasBits6 & 128) != 0; }
6497 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6498 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6499 public void ClearUseLbRelaxLns() {
6504 public const int FpRoundingFieldNumber = 165;
6505 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod FpRoundingDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod.PropagationAssisted;
6507 private global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod fpRounding_;
6508 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6509 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6510 public global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod FpRounding {
6511 get {
if ((_hasBits3 & -2147483648) != 0) {
return fpRounding_; }
else {
return FpRoundingDefaultValue; } }
6513 _hasBits3 |= -2147483648;
6514 fpRounding_ = value;
6518 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6519 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6520 public bool HasFpRounding {
6521 get {
return (_hasBits3 & -2147483648) != 0; }
6524 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6525 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6526 public void ClearFpRounding() {
6527 _hasBits3 &= ~-2147483648;
6531 public const int DiversifyLnsParamsFieldNumber = 137;
6532 private readonly
static bool DiversifyLnsParamsDefaultValue =
false;
6534 private bool diversifyLnsParams_;
6538 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6539 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6540 public bool DiversifyLnsParams {
6541 get {
if ((_hasBits3 & 1024) != 0) {
return diversifyLnsParams_; }
else {
return DiversifyLnsParamsDefaultValue; } }
6544 diversifyLnsParams_ = value;
6548 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6549 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6550 public bool HasDiversifyLnsParams {
6551 get {
return (_hasBits3 & 1024) != 0; }
6554 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6555 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6556 public void ClearDiversifyLnsParams() {
6561 public const int RandomizeSearchFieldNumber = 103;
6562 private readonly
static bool RandomizeSearchDefaultValue =
false;
6564 private bool randomizeSearch_;
6568 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6569 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6570 public bool RandomizeSearch {
6571 get {
if ((_hasBits2 & 2048) != 0) {
return randomizeSearch_; }
else {
return RandomizeSearchDefaultValue; } }
6574 randomizeSearch_ = value;
6578 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6579 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6580 public bool HasRandomizeSearch {
6581 get {
return (_hasBits2 & 2048) != 0; }
6584 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6585 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6586 public void ClearRandomizeSearch() {
6591 public const int SearchRandomVariablePoolSizeFieldNumber = 104;
6592 private readonly
static long SearchRandomVariablePoolSizeDefaultValue = 0L;
6594 private long searchRandomVariablePoolSize_;
6600 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6601 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6602 public long SearchRandomVariablePoolSize {
6603 get {
if ((_hasBits2 & 4096) != 0) {
return searchRandomVariablePoolSize_; }
else {
return SearchRandomVariablePoolSizeDefaultValue; } }
6606 searchRandomVariablePoolSize_ = value;
6610 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6611 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6612 public bool HasSearchRandomVariablePoolSize {
6613 get {
return (_hasBits2 & 4096) != 0; }
6616 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6617 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6618 public void ClearSearchRandomVariablePoolSize() {
6623 public const int PushAllTasksTowardStartFieldNumber = 262;
6624 private readonly
static bool PushAllTasksTowardStartDefaultValue =
false;
6626 private bool pushAllTasksTowardStart_;
6631 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6632 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6633 public bool PushAllTasksTowardStart {
6634 get {
if ((_hasBits6 & 16384) != 0) {
return pushAllTasksTowardStart_; }
else {
return PushAllTasksTowardStartDefaultValue; } }
6637 pushAllTasksTowardStart_ = value;
6641 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6642 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6643 public bool HasPushAllTasksTowardStart {
6644 get {
return (_hasBits6 & 16384) != 0; }
6647 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6648 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6649 public void ClearPushAllTasksTowardStart() {
6650 _hasBits6 &= ~16384;
6654 public const int UseOptionalVariablesFieldNumber = 108;
6655 private readonly
static bool UseOptionalVariablesDefaultValue =
false;
6657 private bool useOptionalVariables_;
6666 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6667 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6668 public bool UseOptionalVariables {
6669 get {
if ((_hasBits2 & 32768) != 0) {
return useOptionalVariables_; }
else {
return UseOptionalVariablesDefaultValue; } }
6672 useOptionalVariables_ = value;
6676 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6677 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6678 public bool HasUseOptionalVariables {
6679 get {
return (_hasBits2 & 32768) != 0; }
6682 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6683 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6684 public void ClearUseOptionalVariables() {
6685 _hasBits2 &= ~32768;
6689 public const int UseExactLpReasonFieldNumber = 109;
6690 private readonly
static bool UseExactLpReasonDefaultValue =
true;
6692 private bool useExactLpReason_;
6699 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6700 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6701 public bool UseExactLpReason {
6702 get {
if ((_hasBits2 & 65536) != 0) {
return useExactLpReason_; }
else {
return UseExactLpReasonDefaultValue; } }
6705 useExactLpReason_ = value;
6709 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6710 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6711 public bool HasUseExactLpReason {
6712 get {
return (_hasBits2 & 65536) != 0; }
6715 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6716 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6717 public void ClearUseExactLpReason() {
6718 _hasBits2 &= ~65536;
6722 public const int UseCombinedNoOverlapFieldNumber = 133;
6723 private readonly
static bool UseCombinedNoOverlapDefaultValue =
false;
6725 private bool useCombinedNoOverlap_;
6731 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6732 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6733 public bool UseCombinedNoOverlap {
6734 get {
if ((_hasBits3 & 64) != 0) {
return useCombinedNoOverlap_; }
else {
return UseCombinedNoOverlapDefaultValue; } }
6737 useCombinedNoOverlap_ = value;
6741 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6742 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6743 public bool HasUseCombinedNoOverlap {
6744 get {
return (_hasBits3 & 64) != 0; }
6747 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6748 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6749 public void ClearUseCombinedNoOverlap() {
6754 public const int AtMostOneMaxExpansionSizeFieldNumber = 270;
6755 private readonly
static int AtMostOneMaxExpansionSizeDefaultValue = 3;
6757 private int atMostOneMaxExpansionSize_;
6762 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6763 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6764 public int AtMostOneMaxExpansionSize {
6765 get {
if ((_hasBits6 & 4194304) != 0) {
return atMostOneMaxExpansionSize_; }
else {
return AtMostOneMaxExpansionSizeDefaultValue; } }
6767 _hasBits6 |= 4194304;
6768 atMostOneMaxExpansionSize_ = value;
6772 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6773 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6774 public bool HasAtMostOneMaxExpansionSize {
6775 get {
return (_hasBits6 & 4194304) != 0; }
6778 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6779 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6780 public void ClearAtMostOneMaxExpansionSize() {
6781 _hasBits6 &= ~4194304;
6785 public const int CatchSigintSignalFieldNumber = 135;
6786 private readonly
static bool CatchSigintSignalDefaultValue =
true;
6788 private bool catchSigintSignal_;
6794 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6795 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6796 public bool CatchSigintSignal {
6797 get {
if ((_hasBits3 & 256) != 0) {
return catchSigintSignal_; }
else {
return CatchSigintSignalDefaultValue; } }
6800 catchSigintSignal_ = value;
6804 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6805 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6806 public bool HasCatchSigintSignal {
6807 get {
return (_hasBits3 & 256) != 0; }
6810 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6811 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6812 public void ClearCatchSigintSignal() {
6817 public const int UseImpliedBoundsFieldNumber = 144;
6818 private readonly
static bool UseImpliedBoundsDefaultValue =
true;
6820 private bool useImpliedBounds_;
6826 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6827 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6828 public bool UseImpliedBounds {
6829 get {
if ((_hasBits3 & 4096) != 0) {
return useImpliedBounds_; }
else {
return UseImpliedBoundsDefaultValue; } }
6832 useImpliedBounds_ = value;
6836 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6837 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6838 public bool HasUseImpliedBounds {
6839 get {
return (_hasBits3 & 4096) != 0; }
6842 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6843 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6844 public void ClearUseImpliedBounds() {
6849 public const int PolishLpSolutionFieldNumber = 175;
6850 private readonly
static bool PolishLpSolutionDefaultValue =
false;
6852 private bool polishLpSolution_;
6859 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6860 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6861 public bool PolishLpSolution {
6862 get {
if ((_hasBits4 & 256) != 0) {
return polishLpSolution_; }
else {
return PolishLpSolutionDefaultValue; } }
6865 polishLpSolution_ = value;
6869 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6870 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6871 public bool HasPolishLpSolution {
6872 get {
return (_hasBits4 & 256) != 0; }
6875 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6876 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6877 public void ClearPolishLpSolution() {
6882 public const int LpPrimalToleranceFieldNumber = 266;
6883 private readonly
static double LpPrimalToleranceDefaultValue = 1e-07D;
6885 private double lpPrimalTolerance_;
6893 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6894 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6895 public double LpPrimalTolerance {
6896 get {
if ((_hasBits6 & 262144) != 0) {
return lpPrimalTolerance_; }
else {
return LpPrimalToleranceDefaultValue; } }
6898 _hasBits6 |= 262144;
6899 lpPrimalTolerance_ = value;
6903 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6904 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6905 public bool HasLpPrimalTolerance {
6906 get {
return (_hasBits6 & 262144) != 0; }
6909 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6910 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6911 public void ClearLpPrimalTolerance() {
6912 _hasBits6 &= ~262144;
6916 public const int LpDualToleranceFieldNumber = 267;
6917 private readonly
static double LpDualToleranceDefaultValue = 1e-07D;
6919 private double lpDualTolerance_;
6920 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6921 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6922 public double LpDualTolerance {
6923 get {
if ((_hasBits6 & 524288) != 0) {
return lpDualTolerance_; }
else {
return LpDualToleranceDefaultValue; } }
6925 _hasBits6 |= 524288;
6926 lpDualTolerance_ = value;
6930 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6931 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6932 public bool HasLpDualTolerance {
6933 get {
return (_hasBits6 & 524288) != 0; }
6936 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6937 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6938 public void ClearLpDualTolerance() {
6939 _hasBits6 &= ~524288;
6943 public const int ConvertIntervalsFieldNumber = 177;
6944 private readonly
static bool ConvertIntervalsDefaultValue =
true;
6946 private bool convertIntervals_;
6952 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6953 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6954 public bool ConvertIntervals {
6955 get {
if ((_hasBits4 & 1024) != 0) {
return convertIntervals_; }
else {
return ConvertIntervalsDefaultValue; } }
6958 convertIntervals_ = value;
6962 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6963 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6964 public bool HasConvertIntervals {
6965 get {
return (_hasBits4 & 1024) != 0; }
6968 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6969 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6970 public void ClearConvertIntervals() {
6975 public const int SymmetryLevelFieldNumber = 183;
6976 private readonly
static int SymmetryLevelDefaultValue = 2;
6978 private int symmetryLevel_;
6987 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6988 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6989 public int SymmetryLevel {
6990 get {
if ((_hasBits4 & 65536) != 0) {
return symmetryLevel_; }
else {
return SymmetryLevelDefaultValue; } }
6993 symmetryLevel_ = value;
6997 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6998 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6999 public bool HasSymmetryLevel {
7000 get {
return (_hasBits4 & 65536) != 0; }
7003 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7004 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7005 public void ClearSymmetryLevel() {
7006 _hasBits4 &= ~65536;
7010 public const int NewLinearPropagationFieldNumber = 224;
7011 private readonly
static bool NewLinearPropagationDefaultValue =
true;
7013 private bool newLinearPropagation_;
7019 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7020 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7021 public bool NewLinearPropagation {
7022 get {
if ((_hasBits5 & 32768) != 0) {
return newLinearPropagation_; }
else {
return NewLinearPropagationDefaultValue; } }
7025 newLinearPropagation_ = value;
7029 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7030 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7031 public bool HasNewLinearPropagation {
7032 get {
return (_hasBits5 & 32768) != 0; }
7035 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7036 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7037 public void ClearNewLinearPropagation() {
7038 _hasBits5 &= ~32768;
7042 public const int LinearSplitSizeFieldNumber = 256;
7043 private readonly
static int LinearSplitSizeDefaultValue = 100;
7045 private int linearSplitSize_;
7051 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7052 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7053 public int LinearSplitSize {
7054 get {
if ((_hasBits6 & 256) != 0) {
return linearSplitSize_; }
else {
return LinearSplitSizeDefaultValue; } }
7057 linearSplitSize_ = value;
7061 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7062 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7063 public bool HasLinearSplitSize {
7064 get {
return (_hasBits6 & 256) != 0; }
7067 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7068 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7069 public void ClearLinearSplitSize() {
7074 public const int LinearizationLevelFieldNumber = 90;
7075 private readonly
static int LinearizationLevelDefaultValue = 1;
7077 private int linearizationLevel_;
7084 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7085 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7086 public int LinearizationLevel {
7087 get {
if ((_hasBits2 & 2) != 0) {
return linearizationLevel_; }
else {
return LinearizationLevelDefaultValue; } }
7090 linearizationLevel_ = value;
7094 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7095 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7096 public bool HasLinearizationLevel {
7097 get {
return (_hasBits2 & 2) != 0; }
7100 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7101 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7102 public void ClearLinearizationLevel() {
7107 public const int BooleanEncodingLevelFieldNumber = 107;
7108 private readonly
static int BooleanEncodingLevelDefaultValue = 1;
7110 private int booleanEncodingLevel_;
7115 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7116 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7117 public int BooleanEncodingLevel {
7118 get {
if ((_hasBits2 & 16384) != 0) {
return booleanEncodingLevel_; }
else {
return BooleanEncodingLevelDefaultValue; } }
7121 booleanEncodingLevel_ = value;
7125 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7126 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7127 public bool HasBooleanEncodingLevel {
7128 get {
return (_hasBits2 & 16384) != 0; }
7131 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7132 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7133 public void ClearBooleanEncodingLevel() {
7134 _hasBits2 &= ~16384;
7138 public const int MaxDomainSizeWhenEncodingEqNeqConstraintsFieldNumber = 191;
7139 private readonly
static int MaxDomainSizeWhenEncodingEqNeqConstraintsDefaultValue = 16;
7141 private int maxDomainSizeWhenEncodingEqNeqConstraints_;
7148 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7149 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7150 public int MaxDomainSizeWhenEncodingEqNeqConstraints {
7151 get {
if ((_hasBits4 & 4194304) != 0) {
return maxDomainSizeWhenEncodingEqNeqConstraints_; }
else {
return MaxDomainSizeWhenEncodingEqNeqConstraintsDefaultValue; } }
7153 _hasBits4 |= 4194304;
7154 maxDomainSizeWhenEncodingEqNeqConstraints_ = value;
7158 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7159 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7160 public bool HasMaxDomainSizeWhenEncodingEqNeqConstraints {
7161 get {
return (_hasBits4 & 4194304) != 0; }
7164 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7165 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7166 public void ClearMaxDomainSizeWhenEncodingEqNeqConstraints() {
7167 _hasBits4 &= ~4194304;
7171 public const int MaxNumCutsFieldNumber = 91;
7172 private readonly
static int MaxNumCutsDefaultValue = 10000;
7174 private int maxNumCuts_;
7182 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7183 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7184 public int MaxNumCuts {
7185 get {
if ((_hasBits2 & 4) != 0) {
return maxNumCuts_; }
else {
return MaxNumCutsDefaultValue; } }
7188 maxNumCuts_ = value;
7192 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7193 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7194 public bool HasMaxNumCuts {
7195 get {
return (_hasBits2 & 4) != 0; }
7198 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7199 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7200 public void ClearMaxNumCuts() {
7205 public const int CutLevelFieldNumber = 196;
7206 private readonly
static int CutLevelDefaultValue = 1;
7208 private int cutLevel_;
7214 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7215 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7216 public int CutLevel {
7217 get {
if ((_hasBits4 & 134217728) != 0) {
return cutLevel_; }
else {
return CutLevelDefaultValue; } }
7219 _hasBits4 |= 134217728;
7224 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7225 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7226 public bool HasCutLevel {
7227 get {
return (_hasBits4 & 134217728) != 0; }
7230 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7231 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7232 public void ClearCutLevel() {
7233 _hasBits4 &= ~134217728;
7237 public const int OnlyAddCutsAtLevelZeroFieldNumber = 92;
7238 private readonly
static bool OnlyAddCutsAtLevelZeroDefaultValue =
false;
7240 private bool onlyAddCutsAtLevelZero_;
7245 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7246 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7247 public bool OnlyAddCutsAtLevelZero {
7248 get {
if ((_hasBits2 & 8) != 0) {
return onlyAddCutsAtLevelZero_; }
else {
return OnlyAddCutsAtLevelZeroDefaultValue; } }
7251 onlyAddCutsAtLevelZero_ = value;
7255 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7256 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7257 public bool HasOnlyAddCutsAtLevelZero {
7258 get {
return (_hasBits2 & 8) != 0; }
7261 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7262 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7263 public void ClearOnlyAddCutsAtLevelZero() {
7268 public const int AddObjectiveCutFieldNumber = 197;
7269 private readonly
static bool AddObjectiveCutDefaultValue =
false;
7271 private bool addObjectiveCut_;
7279 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7280 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7281 public bool AddObjectiveCut {
7282 get {
if ((_hasBits4 & 268435456) != 0) {
return addObjectiveCut_; }
else {
return AddObjectiveCutDefaultValue; } }
7284 _hasBits4 |= 268435456;
7285 addObjectiveCut_ = value;
7289 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7290 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7291 public bool HasAddObjectiveCut {
7292 get {
return (_hasBits4 & 268435456) != 0; }
7295 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7296 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7297 public void ClearAddObjectiveCut() {
7298 _hasBits4 &= ~268435456;
7302 public const int AddCgCutsFieldNumber = 117;
7303 private readonly
static bool AddCgCutsDefaultValue =
true;
7305 private bool addCgCuts_;
7310 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7311 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7312 public bool AddCgCuts {
7313 get {
if ((_hasBits2 & 8388608) != 0) {
return addCgCuts_; }
else {
return AddCgCutsDefaultValue; } }
7315 _hasBits2 |= 8388608;
7320 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7321 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7322 public bool HasAddCgCuts {
7323 get {
return (_hasBits2 & 8388608) != 0; }
7326 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7327 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7328 public void ClearAddCgCuts() {
7329 _hasBits2 &= ~8388608;
7333 public const int AddMirCutsFieldNumber = 120;
7334 private readonly
static bool AddMirCutsDefaultValue =
true;
7336 private bool addMirCuts_;
7341 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7342 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7343 public bool AddMirCuts {
7344 get {
if ((_hasBits2 & 33554432) != 0) {
return addMirCuts_; }
else {
return AddMirCutsDefaultValue; } }
7346 _hasBits2 |= 33554432;
7347 addMirCuts_ = value;
7351 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7352 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7353 public bool HasAddMirCuts {
7354 get {
return (_hasBits2 & 33554432) != 0; }
7357 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7358 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7359 public void ClearAddMirCuts() {
7360 _hasBits2 &= ~33554432;
7364 public const int AddZeroHalfCutsFieldNumber = 169;
7365 private readonly
static bool AddZeroHalfCutsDefaultValue =
true;
7367 private bool addZeroHalfCuts_;
7372 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7373 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7374 public bool AddZeroHalfCuts {
7375 get {
if ((_hasBits4 & 8) != 0) {
return addZeroHalfCuts_; }
else {
return AddZeroHalfCutsDefaultValue; } }
7378 addZeroHalfCuts_ = value;
7382 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7383 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7384 public bool HasAddZeroHalfCuts {
7385 get {
return (_hasBits4 & 8) != 0; }
7388 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7389 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7390 public void ClearAddZeroHalfCuts() {
7395 public const int AddCliqueCutsFieldNumber = 172;
7396 private readonly
static bool AddCliqueCutsDefaultValue =
true;
7398 private bool addCliqueCuts_;
7404 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7405 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7406 public bool AddCliqueCuts {
7407 get {
if ((_hasBits4 & 32) != 0) {
return addCliqueCuts_; }
else {
return AddCliqueCutsDefaultValue; } }
7410 addCliqueCuts_ = value;
7414 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7415 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7416 public bool HasAddCliqueCuts {
7417 get {
return (_hasBits4 & 32) != 0; }
7420 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7421 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7422 public void ClearAddCliqueCuts() {
7427 public const int AddRltCutsFieldNumber = 279;
7428 private readonly
static bool AddRltCutsDefaultValue =
true;
7430 private bool addRltCuts_;
7435 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7436 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7437 public bool AddRltCuts {
7438 get {
if ((_hasBits6 & -2147483648) != 0) {
return addRltCuts_; }
else {
return AddRltCutsDefaultValue; } }
7440 _hasBits6 |= -2147483648;
7441 addRltCuts_ = value;
7445 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7446 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7447 public bool HasAddRltCuts {
7448 get {
return (_hasBits6 & -2147483648) != 0; }
7451 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7452 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7453 public void ClearAddRltCuts() {
7454 _hasBits6 &= ~-2147483648;
7458 public const int MaxAllDiffCutSizeFieldNumber = 148;
7459 private readonly
static int MaxAllDiffCutSizeDefaultValue = 64;
7461 private int maxAllDiffCutSize_;
7467 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7468 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7469 public int MaxAllDiffCutSize {
7470 get {
if ((_hasBits3 & 65536) != 0) {
return maxAllDiffCutSize_; }
else {
return MaxAllDiffCutSizeDefaultValue; } }
7473 maxAllDiffCutSize_ = value;
7477 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7478 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7479 public bool HasMaxAllDiffCutSize {
7480 get {
return (_hasBits3 & 65536) != 0; }
7483 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7484 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7485 public void ClearMaxAllDiffCutSize() {
7486 _hasBits3 &= ~65536;
7490 public const int AddLinMaxCutsFieldNumber = 152;
7491 private readonly
static bool AddLinMaxCutsDefaultValue =
true;
7493 private bool addLinMaxCuts_;
7499 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7500 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7501 public bool AddLinMaxCuts {
7502 get {
if ((_hasBits3 & 524288) != 0) {
return addLinMaxCuts_; }
else {
return AddLinMaxCutsDefaultValue; } }
7504 _hasBits3 |= 524288;
7505 addLinMaxCuts_ = value;
7509 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7510 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7511 public bool HasAddLinMaxCuts {
7512 get {
return (_hasBits3 & 524288) != 0; }
7515 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7516 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7517 public void ClearAddLinMaxCuts() {
7518 _hasBits3 &= ~524288;
7522 public const int MaxIntegerRoundingScalingFieldNumber = 119;
7523 private readonly
static int MaxIntegerRoundingScalingDefaultValue = 600;
7525 private int maxIntegerRoundingScaling_;
7536 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7537 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7538 public int MaxIntegerRoundingScaling {
7539 get {
if ((_hasBits2 & 16777216) != 0) {
return maxIntegerRoundingScaling_; }
else {
return MaxIntegerRoundingScalingDefaultValue; } }
7541 _hasBits2 |= 16777216;
7542 maxIntegerRoundingScaling_ = value;
7546 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7547 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7548 public bool HasMaxIntegerRoundingScaling {
7549 get {
return (_hasBits2 & 16777216) != 0; }
7552 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7553 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7554 public void ClearMaxIntegerRoundingScaling() {
7555 _hasBits2 &= ~16777216;
7559 public const int AddLpConstraintsLazilyFieldNumber = 112;
7560 private readonly
static bool AddLpConstraintsLazilyDefaultValue =
true;
7562 private bool addLpConstraintsLazily_;
7569 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7570 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7571 public bool AddLpConstraintsLazily {
7572 get {
if ((_hasBits2 & 262144) != 0) {
return addLpConstraintsLazily_; }
else {
return AddLpConstraintsLazilyDefaultValue; } }
7574 _hasBits2 |= 262144;
7575 addLpConstraintsLazily_ = value;
7579 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7580 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7581 public bool HasAddLpConstraintsLazily {
7582 get {
return (_hasBits2 & 262144) != 0; }
7585 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7586 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7587 public void ClearAddLpConstraintsLazily() {
7588 _hasBits2 &= ~262144;
7592 public const int RootLpIterationsFieldNumber = 227;
7593 private readonly
static int RootLpIterationsDefaultValue = 2000;
7595 private int rootLpIterations_;
7602 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7603 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7604 public int RootLpIterations {
7605 get {
if ((_hasBits5 & 262144) != 0) {
return rootLpIterations_; }
else {
return RootLpIterationsDefaultValue; } }
7607 _hasBits5 |= 262144;
7608 rootLpIterations_ = value;
7612 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7613 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7614 public bool HasRootLpIterations {
7615 get {
return (_hasBits5 & 262144) != 0; }
7618 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7619 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7620 public void ClearRootLpIterations() {
7621 _hasBits5 &= ~262144;
7625 public const int MinOrthogonalityForLpConstraintsFieldNumber = 115;
7626 private readonly
static double MinOrthogonalityForLpConstraintsDefaultValue = 0.05D;
7628 private double minOrthogonalityForLpConstraints_;
7636 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7637 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7638 public double MinOrthogonalityForLpConstraints {
7639 get {
if ((_hasBits2 & 2097152) != 0) {
return minOrthogonalityForLpConstraints_; }
else {
return MinOrthogonalityForLpConstraintsDefaultValue; } }
7641 _hasBits2 |= 2097152;
7642 minOrthogonalityForLpConstraints_ = value;
7646 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7647 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7648 public bool HasMinOrthogonalityForLpConstraints {
7649 get {
return (_hasBits2 & 2097152) != 0; }
7652 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7653 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7654 public void ClearMinOrthogonalityForLpConstraints() {
7655 _hasBits2 &= ~2097152;
7659 public const int MaxCutRoundsAtLevelZeroFieldNumber = 154;
7660 private readonly
static int MaxCutRoundsAtLevelZeroDefaultValue = 1;
7662 private int maxCutRoundsAtLevelZero_;
7666 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7667 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7668 public int MaxCutRoundsAtLevelZero {
7669 get {
if ((_hasBits3 & 2097152) != 0) {
return maxCutRoundsAtLevelZero_; }
else {
return MaxCutRoundsAtLevelZeroDefaultValue; } }
7671 _hasBits3 |= 2097152;
7672 maxCutRoundsAtLevelZero_ = value;
7676 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7677 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7678 public bool HasMaxCutRoundsAtLevelZero {
7679 get {
return (_hasBits3 & 2097152) != 0; }
7682 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7683 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7684 public void ClearMaxCutRoundsAtLevelZero() {
7685 _hasBits3 &= ~2097152;
7689 public const int MaxConsecutiveInactiveCountFieldNumber = 121;
7690 private readonly
static int MaxConsecutiveInactiveCountDefaultValue = 100;
7692 private int maxConsecutiveInactiveCount_;
7698 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7699 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7700 public int MaxConsecutiveInactiveCount {
7701 get {
if ((_hasBits2 & 67108864) != 0) {
return maxConsecutiveInactiveCount_; }
else {
return MaxConsecutiveInactiveCountDefaultValue; } }
7703 _hasBits2 |= 67108864;
7704 maxConsecutiveInactiveCount_ = value;
7708 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7709 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7710 public bool HasMaxConsecutiveInactiveCount {
7711 get {
return (_hasBits2 & 67108864) != 0; }
7714 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7715 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7716 public void ClearMaxConsecutiveInactiveCount() {
7717 _hasBits2 &= ~67108864;
7721 public const int CutMaxActiveCountValueFieldNumber = 155;
7722 private readonly
static double CutMaxActiveCountValueDefaultValue = 1e+10D;
7724 private double cutMaxActiveCountValue_;
7730 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7731 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7732 public double CutMaxActiveCountValue {
7733 get {
if ((_hasBits3 & 4194304) != 0) {
return cutMaxActiveCountValue_; }
else {
return CutMaxActiveCountValueDefaultValue; } }
7735 _hasBits3 |= 4194304;
7736 cutMaxActiveCountValue_ = value;
7740 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7741 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7742 public bool HasCutMaxActiveCountValue {
7743 get {
return (_hasBits3 & 4194304) != 0; }
7746 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7747 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7748 public void ClearCutMaxActiveCountValue() {
7749 _hasBits3 &= ~4194304;
7753 public const int CutActiveCountDecayFieldNumber = 156;
7754 private readonly
static double CutActiveCountDecayDefaultValue = 0.8D;
7756 private double cutActiveCountDecay_;
7757 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7758 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7759 public double CutActiveCountDecay {
7760 get {
if ((_hasBits3 & 8388608) != 0) {
return cutActiveCountDecay_; }
else {
return CutActiveCountDecayDefaultValue; } }
7762 _hasBits3 |= 8388608;
7763 cutActiveCountDecay_ = value;
7767 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7768 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7769 public bool HasCutActiveCountDecay {
7770 get {
return (_hasBits3 & 8388608) != 0; }
7773 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7774 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7775 public void ClearCutActiveCountDecay() {
7776 _hasBits3 &= ~8388608;
7780 public const int CutCleanupTargetFieldNumber = 157;
7781 private readonly
static int CutCleanupTargetDefaultValue = 1000;
7783 private int cutCleanupTarget_;
7787 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7788 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7789 public int CutCleanupTarget {
7790 get {
if ((_hasBits3 & 16777216) != 0) {
return cutCleanupTarget_; }
else {
return CutCleanupTargetDefaultValue; } }
7792 _hasBits3 |= 16777216;
7793 cutCleanupTarget_ = value;
7797 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7798 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7799 public bool HasCutCleanupTarget {
7800 get {
return (_hasBits3 & 16777216) != 0; }
7803 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7804 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7805 public void ClearCutCleanupTarget() {
7806 _hasBits3 &= ~16777216;
7810 public const int NewConstraintsBatchSizeFieldNumber = 122;
7811 private readonly
static int NewConstraintsBatchSizeDefaultValue = 50;
7813 private int newConstraintsBatchSize_;
7818 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7819 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7820 public int NewConstraintsBatchSize {
7821 get {
if ((_hasBits2 & 134217728) != 0) {
return newConstraintsBatchSize_; }
else {
return NewConstraintsBatchSizeDefaultValue; } }
7823 _hasBits2 |= 134217728;
7824 newConstraintsBatchSize_ = value;
7828 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7829 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7830 public bool HasNewConstraintsBatchSize {
7831 get {
return (_hasBits2 & 134217728) != 0; }
7834 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7835 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7836 public void ClearNewConstraintsBatchSize() {
7837 _hasBits2 &= ~134217728;
7841 public const int ExploitIntegerLpSolutionFieldNumber = 94;
7842 private readonly
static bool ExploitIntegerLpSolutionDefaultValue =
true;
7844 private bool exploitIntegerLpSolution_;
7851 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7852 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7853 public bool ExploitIntegerLpSolution {
7854 get {
if ((_hasBits2 & 32) != 0) {
return exploitIntegerLpSolution_; }
else {
return ExploitIntegerLpSolutionDefaultValue; } }
7857 exploitIntegerLpSolution_ = value;
7861 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7862 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7863 public bool HasExploitIntegerLpSolution {
7864 get {
return (_hasBits2 & 32) != 0; }
7867 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7868 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7869 public void ClearExploitIntegerLpSolution() {
7874 public const int ExploitAllLpSolutionFieldNumber = 116;
7875 private readonly
static bool ExploitAllLpSolutionDefaultValue =
true;
7877 private bool exploitAllLpSolution_;
7883 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7884 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7885 public bool ExploitAllLpSolution {
7886 get {
if ((_hasBits2 & 4194304) != 0) {
return exploitAllLpSolution_; }
else {
return ExploitAllLpSolutionDefaultValue; } }
7888 _hasBits2 |= 4194304;
7889 exploitAllLpSolution_ = value;
7893 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7894 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7895 public bool HasExploitAllLpSolution {
7896 get {
return (_hasBits2 & 4194304) != 0; }
7899 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7900 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7901 public void ClearExploitAllLpSolution() {
7902 _hasBits2 &= ~4194304;
7906 public const int ExploitBestSolutionFieldNumber = 130;
7907 private readonly
static bool ExploitBestSolutionDefaultValue =
false;
7909 private bool exploitBestSolution_;
7913 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7914 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7915 public bool ExploitBestSolution {
7916 get {
if ((_hasBits3 & 8) != 0) {
return exploitBestSolution_; }
else {
return ExploitBestSolutionDefaultValue; } }
7919 exploitBestSolution_ = value;
7923 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7924 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7925 public bool HasExploitBestSolution {
7926 get {
return (_hasBits3 & 8) != 0; }
7929 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7930 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7931 public void ClearExploitBestSolution() {
7936 public const int ExploitRelaxationSolutionFieldNumber = 161;
7937 private readonly
static bool ExploitRelaxationSolutionDefaultValue =
false;
7939 private bool exploitRelaxationSolution_;
7945 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7946 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7947 public bool ExploitRelaxationSolution {
7948 get {
if ((_hasBits3 & 134217728) != 0) {
return exploitRelaxationSolution_; }
else {
return ExploitRelaxationSolutionDefaultValue; } }
7950 _hasBits3 |= 134217728;
7951 exploitRelaxationSolution_ = value;
7955 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7956 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7957 public bool HasExploitRelaxationSolution {
7958 get {
return (_hasBits3 & 134217728) != 0; }
7961 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7962 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7963 public void ClearExploitRelaxationSolution() {
7964 _hasBits3 &= ~134217728;
7968 public const int ExploitObjectiveFieldNumber = 131;
7969 private readonly
static bool ExploitObjectiveDefaultValue =
true;
7971 private bool exploitObjective_;
7976 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7977 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7978 public bool ExploitObjective {
7979 get {
if ((_hasBits3 & 16) != 0) {
return exploitObjective_; }
else {
return ExploitObjectiveDefaultValue; } }
7982 exploitObjective_ = value;
7986 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7987 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7988 public bool HasExploitObjective {
7989 get {
return (_hasBits3 & 16) != 0; }
7992 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7993 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7994 public void ClearExploitObjective() {
7999 public const int DetectLinearizedProductFieldNumber = 277;
8000 private readonly
static bool DetectLinearizedProductDefaultValue =
false;
8002 private bool detectLinearizedProduct_;
8008 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8009 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8010 public bool DetectLinearizedProduct {
8011 get {
if ((_hasBits6 & 536870912) != 0) {
return detectLinearizedProduct_; }
else {
return DetectLinearizedProductDefaultValue; } }
8013 _hasBits6 |= 536870912;
8014 detectLinearizedProduct_ = value;
8018 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8019 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8020 public bool HasDetectLinearizedProduct {
8021 get {
return (_hasBits6 & 536870912) != 0; }
8024 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8025 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8026 public void ClearDetectLinearizedProduct() {
8027 _hasBits6 &= ~536870912;
8031 public const int MipMaxBoundFieldNumber = 124;
8032 private readonly
static double MipMaxBoundDefaultValue = 1e+07D;
8034 private double mipMaxBound_;
8040 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8041 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8042 public double MipMaxBound {
8043 get {
if ((_hasBits2 & 536870912) != 0) {
return mipMaxBound_; }
else {
return MipMaxBoundDefaultValue; } }
8045 _hasBits2 |= 536870912;
8046 mipMaxBound_ = value;
8050 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8051 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8052 public bool HasMipMaxBound {
8053 get {
return (_hasBits2 & 536870912) != 0; }
8056 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8057 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8058 public void ClearMipMaxBound() {
8059 _hasBits2 &= ~536870912;
8063 public const int MipVarScalingFieldNumber = 125;
8064 private readonly
static double MipVarScalingDefaultValue = 1D;
8066 private double mipVarScaling_;
8072 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8073 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8074 public double MipVarScaling {
8075 get {
if ((_hasBits2 & 1073741824) != 0) {
return mipVarScaling_; }
else {
return MipVarScalingDefaultValue; } }
8077 _hasBits2 |= 1073741824;
8078 mipVarScaling_ = value;
8082 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8083 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8084 public bool HasMipVarScaling {
8085 get {
return (_hasBits2 & 1073741824) != 0; }
8088 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8089 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8090 public void ClearMipVarScaling() {
8091 _hasBits2 &= ~1073741824;
8095 public const int MipScaleLargeDomainFieldNumber = 225;
8096 private readonly
static bool MipScaleLargeDomainDefaultValue =
false;
8098 private bool mipScaleLargeDomain_;
8104 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8105 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8106 public bool MipScaleLargeDomain {
8107 get {
if ((_hasBits5 & 65536) != 0) {
return mipScaleLargeDomain_; }
else {
return MipScaleLargeDomainDefaultValue; } }
8110 mipScaleLargeDomain_ = value;
8114 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8115 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8116 public bool HasMipScaleLargeDomain {
8117 get {
return (_hasBits5 & 65536) != 0; }
8120 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8121 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8122 public void ClearMipScaleLargeDomain() {
8123 _hasBits5 &= ~65536;
8127 public const int MipAutomaticallyScaleVariablesFieldNumber = 166;
8128 private readonly
static bool MipAutomaticallyScaleVariablesDefaultValue =
true;
8130 private bool mipAutomaticallyScaleVariables_;
8138 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8139 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8140 public bool MipAutomaticallyScaleVariables {
8141 get {
if ((_hasBits4 & 1) != 0) {
return mipAutomaticallyScaleVariables_; }
else {
return MipAutomaticallyScaleVariablesDefaultValue; } }
8144 mipAutomaticallyScaleVariables_ = value;
8148 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8149 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8150 public bool HasMipAutomaticallyScaleVariables {
8151 get {
return (_hasBits4 & 1) != 0; }
8154 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8155 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8156 public void ClearMipAutomaticallyScaleVariables() {
8161 public const int OnlySolveIpFieldNumber = 222;
8162 private readonly
static bool OnlySolveIpDefaultValue =
false;
8164 private bool onlySolveIp_;
8179 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8180 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8181 public bool OnlySolveIp {
8182 get {
if ((_hasBits5 & 8192) != 0) {
return onlySolveIp_; }
else {
return OnlySolveIpDefaultValue; } }
8185 onlySolveIp_ = value;
8189 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8190 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8191 public bool HasOnlySolveIp {
8192 get {
return (_hasBits5 & 8192) != 0; }
8195 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8196 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8197 public void ClearOnlySolveIp() {
8202 public const int MipWantedPrecisionFieldNumber = 126;
8203 private readonly
static double MipWantedPrecisionDefaultValue = 1e-06D;
8205 private double mipWantedPrecision_;
8225 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8226 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8227 public double MipWantedPrecision {
8228 get {
if ((_hasBits2 & -2147483648) != 0) {
return mipWantedPrecision_; }
else {
return MipWantedPrecisionDefaultValue; } }
8230 _hasBits2 |= -2147483648;
8231 mipWantedPrecision_ = value;
8235 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8236 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8237 public bool HasMipWantedPrecision {
8238 get {
return (_hasBits2 & -2147483648) != 0; }
8241 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8242 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8243 public void ClearMipWantedPrecision() {
8244 _hasBits2 &= ~-2147483648;
8248 public const int MipMaxActivityExponentFieldNumber = 127;
8249 private readonly
static int MipMaxActivityExponentDefaultValue = 53;
8251 private int mipMaxActivityExponent_;
8262 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8263 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8264 public int MipMaxActivityExponent {
8265 get {
if ((_hasBits3 & 1) != 0) {
return mipMaxActivityExponent_; }
else {
return MipMaxActivityExponentDefaultValue; } }
8268 mipMaxActivityExponent_ = value;
8272 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8273 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8274 public bool HasMipMaxActivityExponent {
8275 get {
return (_hasBits3 & 1) != 0; }
8278 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8279 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8280 public void ClearMipMaxActivityExponent() {
8285 public const int MipCheckPrecisionFieldNumber = 128;
8286 private readonly
static double MipCheckPrecisionDefaultValue = 0.0001D;
8288 private double mipCheckPrecision_;
8294 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8295 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8296 public double MipCheckPrecision {
8297 get {
if ((_hasBits3 & 2) != 0) {
return mipCheckPrecision_; }
else {
return MipCheckPrecisionDefaultValue; } }
8300 mipCheckPrecision_ = value;
8304 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8305 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8306 public bool HasMipCheckPrecision {
8307 get {
return (_hasBits3 & 2) != 0; }
8310 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8311 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8312 public void ClearMipCheckPrecision() {
8317 public const int MipComputeTrueObjectiveBoundFieldNumber = 198;
8318 private readonly
static bool MipComputeTrueObjectiveBoundDefaultValue =
true;
8320 private bool mipComputeTrueObjectiveBound_;
8328 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8329 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8330 public bool MipComputeTrueObjectiveBound {
8331 get {
if ((_hasBits4 & 536870912) != 0) {
return mipComputeTrueObjectiveBound_; }
else {
return MipComputeTrueObjectiveBoundDefaultValue; } }
8333 _hasBits4 |= 536870912;
8334 mipComputeTrueObjectiveBound_ = value;
8338 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8339 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8340 public bool HasMipComputeTrueObjectiveBound {
8341 get {
return (_hasBits4 & 536870912) != 0; }
8344 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8345 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8346 public void ClearMipComputeTrueObjectiveBound() {
8347 _hasBits4 &= ~536870912;
8351 public const int MipMaxValidMagnitudeFieldNumber = 199;
8352 private readonly
static double MipMaxValidMagnitudeDefaultValue = 1e+20D;
8354 private double mipMaxValidMagnitude_;
8362 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8363 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8364 public double MipMaxValidMagnitude {
8365 get {
if ((_hasBits4 & 1073741824) != 0) {
return mipMaxValidMagnitude_; }
else {
return MipMaxValidMagnitudeDefaultValue; } }
8367 _hasBits4 |= 1073741824;
8368 mipMaxValidMagnitude_ = value;
8372 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8373 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8374 public bool HasMipMaxValidMagnitude {
8375 get {
return (_hasBits4 & 1073741824) != 0; }
8378 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8379 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8380 public void ClearMipMaxValidMagnitude() {
8381 _hasBits4 &= ~1073741824;
8385 public const int MipTreatHighMagnitudeBoundsAsInfinityFieldNumber = 278;
8386 private readonly
static bool MipTreatHighMagnitudeBoundsAsInfinityDefaultValue =
false;
8388 private bool mipTreatHighMagnitudeBoundsAsInfinity_;
8397 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8398 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8399 public bool MipTreatHighMagnitudeBoundsAsInfinity {
8400 get {
if ((_hasBits6 & 1073741824) != 0) {
return mipTreatHighMagnitudeBoundsAsInfinity_; }
else {
return MipTreatHighMagnitudeBoundsAsInfinityDefaultValue; } }
8402 _hasBits6 |= 1073741824;
8403 mipTreatHighMagnitudeBoundsAsInfinity_ = value;
8407 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8408 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8409 public bool HasMipTreatHighMagnitudeBoundsAsInfinity {
8410 get {
return (_hasBits6 & 1073741824) != 0; }
8413 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8414 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8415 public void ClearMipTreatHighMagnitudeBoundsAsInfinity() {
8416 _hasBits6 &= ~1073741824;
8420 public const int MipDropToleranceFieldNumber = 232;
8421 private readonly
static double MipDropToleranceDefaultValue = 1e-16D;
8423 private double mipDropTolerance_;
8428 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8429 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8430 public double MipDropTolerance {
8431 get {
if ((_hasBits5 & 4194304) != 0) {
return mipDropTolerance_; }
else {
return MipDropToleranceDefaultValue; } }
8433 _hasBits5 |= 4194304;
8434 mipDropTolerance_ = value;
8438 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8439 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8440 public bool HasMipDropTolerance {
8441 get {
return (_hasBits5 & 4194304) != 0; }
8444 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8445 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8446 public void ClearMipDropTolerance() {
8447 _hasBits5 &= ~4194304;
8451 public const int MipPresolveLevelFieldNumber = 261;
8452 private readonly
static int MipPresolveLevelDefaultValue = 2;
8454 private int mipPresolveLevel_;
8461 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8462 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8463 public int MipPresolveLevel {
8464 get {
if ((_hasBits6 & 8192) != 0) {
return mipPresolveLevel_; }
else {
return MipPresolveLevelDefaultValue; } }
8467 mipPresolveLevel_ = value;
8471 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8472 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8473 public bool HasMipPresolveLevel {
8474 get {
return (_hasBits6 & 8192) != 0; }
8477 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8478 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8479 public void ClearMipPresolveLevel() {
8483 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8484 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8485 public override bool Equals(
object other) {
8489 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8490 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8492 if (ReferenceEquals(other,
null)) {
8495 if (ReferenceEquals(other,
this)) {
8498 if (Name != other.
Name)
return false;
8503 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RandomPolarityRatio, other.
RandomPolarityRatio))
return false;
8504 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RandomBranchesRatio, other.
RandomBranchesRatio))
return false;
8506 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(InitialVariablesActivity, other.
InitialVariablesActivity))
return false;
8513 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ClauseCleanupRatio, other.
ClauseCleanupRatio))
return false;
8518 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(PbCleanupRatio, other.
PbCleanupRatio))
return false;
8519 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(VariableActivityDecay, other.
VariableActivityDecay))
return false;
8520 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MaxVariableActivityValue, other.
MaxVariableActivityValue))
return false;
8521 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(GlucoseMaxDecay, other.
GlucoseMaxDecay))
return false;
8522 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(GlucoseDecayIncrement, other.
GlucoseDecayIncrement))
return false;
8524 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ClauseActivityDecay, other.
ClauseActivityDecay))
return false;
8525 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MaxClauseActivityValue, other.
MaxClauseActivityValue))
return false;
8526 if(!restartAlgorithms_.Equals(other.restartAlgorithms_))
return false;
8530 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RestartDlAverageRatio, other.
RestartDlAverageRatio))
return false;
8531 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RestartLbdAverageRatio, other.
RestartLbdAverageRatio))
return false;
8534 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(BlockingRestartMultiplier, other.
BlockingRestartMultiplier))
return false;
8536 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(StrategyChangeIncreaseRatio, other.
StrategyChangeIncreaseRatio))
return false;
8537 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MaxTimeInSeconds, other.
MaxTimeInSeconds))
return false;
8538 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MaxDeterministicTime, other.
MaxDeterministicTime))
return false;
8542 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(AbsoluteGapLimit, other.
AbsoluteGapLimit))
return false;
8543 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RelativeGapLimit, other.
RelativeGapLimit))
return false;
8544 if (RandomSeed != other.
RandomSeed)
return false;
8550 if (LogPrefix != other.
LogPrefix)
return false;
8551 if (LogToStdout != other.
LogToStdout)
return false;
8558 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ProbingDeterministicTimeLimit, other.
ProbingDeterministicTimeLimit))
return false;
8576 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MergeNoOverlapWorkLimit, other.
MergeNoOverlapWorkLimit))
return false;
8577 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MergeAtMostOneWorkLimit, other.
MergeAtMostOneWorkLimit))
return false;
8581 if (IgnoreNames != other.
IgnoreNames)
return false;
8585 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(InprocessingDtimeRatio, other.
InprocessingDtimeRatio))
return false;
8586 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(InprocessingProbingDtime, other.
InprocessingProbingDtime))
return false;
8587 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(InprocessingMinimizationDtime, other.
InprocessingMinimizationDtime))
return false;
8588 if (NumWorkers != other.
NumWorkers)
return false;
8591 if(!subsolvers_.Equals(other.subsolvers_))
return false;
8592 if(!extraSubsolvers_.Equals(other.extraSubsolvers_))
return false;
8593 if(!ignoreSubsolvers_.Equals(other.ignoreSubsolvers_))
return false;
8594 if(!filterSubsolvers_.Equals(other.filterSubsolvers_))
return false;
8595 if(!subsolverParams_.Equals(other.subsolverParams_))
return false;
8612 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(PropagationLoopDetectionFactor, other.
PropagationLoopDetectionFactor))
return false;
8632 if (RepairHint != other.
RepairHint)
return false;
8638 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ShavingSearchDeterministicTime, other.
ShavingSearchDeterministicTime))
return false;
8650 if (UseLsOnly != other.
UseLsOnly)
return false;
8651 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(FeasibilityJumpDecay, other.
FeasibilityJumpDecay))
return false;
8654 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(FeasibilityJumpBatchDtime, other.
FeasibilityJumpBatchDtime))
return false;
8661 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ViolationLsCompoundMoveProbability, other.
ViolationLsCompoundMoveProbability))
return false;
8667 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(SharedTreeOpenLeavesPerWorker, other.
SharedTreeOpenLeavesPerWorker))
return false;
8679 if (UseLns != other.
UseLns)
return false;
8680 if (UseLnsOnly != other.
UseLnsOnly)
return false;
8682 if (UseRinsLns != other.
UseRinsLns)
return false;
8685 if (FpRounding != other.
FpRounding)
return false;
8697 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(LpPrimalTolerance, other.
LpPrimalTolerance))
return false;
8698 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(LpDualTolerance, other.
LpDualTolerance))
return false;
8706 if (MaxNumCuts != other.
MaxNumCuts)
return false;
8707 if (CutLevel != other.
CutLevel)
return false;
8710 if (AddCgCuts != other.
AddCgCuts)
return false;
8711 if (AddMirCuts != other.
AddMirCuts)
return false;
8714 if (AddRltCuts != other.
AddRltCuts)
return false;
8720 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MinOrthogonalityForLpConstraints, other.
MinOrthogonalityForLpConstraints))
return false;
8723 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(CutMaxActiveCountValue, other.
CutMaxActiveCountValue))
return false;
8724 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(CutActiveCountDecay, other.
CutActiveCountDecay))
return false;
8733 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MipMaxBound, other.
MipMaxBound))
return false;
8734 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MipVarScaling, other.
MipVarScaling))
return false;
8737 if (OnlySolveIp != other.
OnlySolveIp)
return false;
8738 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MipWantedPrecision, other.
MipWantedPrecision))
return false;
8740 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MipCheckPrecision, other.
MipCheckPrecision))
return false;
8742 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MipMaxValidMagnitude, other.
MipMaxValidMagnitude))
return false;
8744 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MipDropTolerance, other.
MipDropTolerance))
return false;
8746 return Equals(_unknownFields, other._unknownFields);
8749 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8750 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8751 public override int GetHashCode() {
8753 if (HasName) hash ^= Name.GetHashCode();
8754 if (HasPreferredVariableOrder) hash ^= PreferredVariableOrder.GetHashCode();
8755 if (HasInitialPolarity) hash ^= InitialPolarity.GetHashCode();
8756 if (HasUsePhaseSaving) hash ^= UsePhaseSaving.GetHashCode();
8757 if (HasPolarityRephaseIncrement) hash ^= PolarityRephaseIncrement.GetHashCode();
8758 if (HasRandomPolarityRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RandomPolarityRatio);
8759 if (HasRandomBranchesRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RandomBranchesRatio);
8760 if (HasUseErwaHeuristic) hash ^= UseErwaHeuristic.GetHashCode();
8761 if (HasInitialVariablesActivity) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(InitialVariablesActivity);
8762 if (HasAlsoBumpVariablesInConflictReasons) hash ^= AlsoBumpVariablesInConflictReasons.GetHashCode();
8763 if (HasMinimizationAlgorithm) hash ^= MinimizationAlgorithm.GetHashCode();
8764 if (HasBinaryMinimizationAlgorithm) hash ^= BinaryMinimizationAlgorithm.GetHashCode();
8765 if (HasSubsumptionDuringConflictAnalysis) hash ^= SubsumptionDuringConflictAnalysis.GetHashCode();
8766 if (HasClauseCleanupPeriod) hash ^= ClauseCleanupPeriod.GetHashCode();
8767 if (HasClauseCleanupTarget) hash ^= ClauseCleanupTarget.GetHashCode();
8768 if (HasClauseCleanupRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ClauseCleanupRatio);
8769 if (HasClauseCleanupProtection) hash ^= ClauseCleanupProtection.GetHashCode();
8770 if (HasClauseCleanupLbdBound) hash ^= ClauseCleanupLbdBound.GetHashCode();
8771 if (HasClauseCleanupOrdering) hash ^= ClauseCleanupOrdering.GetHashCode();
8772 if (HasPbCleanupIncrement) hash ^= PbCleanupIncrement.GetHashCode();
8773 if (HasPbCleanupRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PbCleanupRatio);
8774 if (HasVariableActivityDecay) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(VariableActivityDecay);
8775 if (HasMaxVariableActivityValue) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxVariableActivityValue);
8776 if (HasGlucoseMaxDecay) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(GlucoseMaxDecay);
8777 if (HasGlucoseDecayIncrement) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(GlucoseDecayIncrement);
8778 if (HasGlucoseDecayIncrementPeriod) hash ^= GlucoseDecayIncrementPeriod.GetHashCode();
8779 if (HasClauseActivityDecay) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ClauseActivityDecay);
8780 if (HasMaxClauseActivityValue) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxClauseActivityValue);
8781 hash ^= restartAlgorithms_.GetHashCode();
8782 if (HasDefaultRestartAlgorithms) hash ^= DefaultRestartAlgorithms.GetHashCode();
8783 if (HasRestartPeriod) hash ^= RestartPeriod.GetHashCode();
8784 if (HasRestartRunningWindowSize) hash ^= RestartRunningWindowSize.GetHashCode();
8785 if (HasRestartDlAverageRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RestartDlAverageRatio);
8786 if (HasRestartLbdAverageRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RestartLbdAverageRatio);
8787 if (HasUseBlockingRestart) hash ^= UseBlockingRestart.GetHashCode();
8788 if (HasBlockingRestartWindowSize) hash ^= BlockingRestartWindowSize.GetHashCode();
8789 if (HasBlockingRestartMultiplier) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(BlockingRestartMultiplier);
8790 if (HasNumConflictsBeforeStrategyChanges) hash ^= NumConflictsBeforeStrategyChanges.GetHashCode();
8791 if (HasStrategyChangeIncreaseRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(StrategyChangeIncreaseRatio);
8792 if (HasMaxTimeInSeconds) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxTimeInSeconds);
8793 if (HasMaxDeterministicTime) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxDeterministicTime);
8794 if (HasMaxNumDeterministicBatches) hash ^= MaxNumDeterministicBatches.GetHashCode();
8795 if (HasMaxNumberOfConflicts) hash ^= MaxNumberOfConflicts.GetHashCode();
8796 if (HasMaxMemoryInMb) hash ^= MaxMemoryInMb.GetHashCode();
8797 if (HasAbsoluteGapLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(AbsoluteGapLimit);
8798 if (HasRelativeGapLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RelativeGapLimit);
8799 if (HasRandomSeed) hash ^= RandomSeed.GetHashCode();
8800 if (HasPermuteVariableRandomly) hash ^= PermuteVariableRandomly.GetHashCode();
8801 if (HasPermutePresolveConstraintOrder) hash ^= PermutePresolveConstraintOrder.GetHashCode();
8802 if (HasUseAbslRandom) hash ^= UseAbslRandom.GetHashCode();
8803 if (HasLogSearchProgress) hash ^= LogSearchProgress.GetHashCode();
8804 if (HasLogSubsolverStatistics) hash ^= LogSubsolverStatistics.GetHashCode();
8805 if (HasLogPrefix) hash ^= LogPrefix.GetHashCode();
8806 if (HasLogToStdout) hash ^= LogToStdout.GetHashCode();
8807 if (HasLogToResponse) hash ^= LogToResponse.GetHashCode();
8808 if (HasUsePbResolution) hash ^= UsePbResolution.GetHashCode();
8809 if (HasMinimizeReductionDuringPbResolution) hash ^= MinimizeReductionDuringPbResolution.GetHashCode();
8810 if (HasCountAssumptionLevelsInLbd) hash ^= CountAssumptionLevelsInLbd.GetHashCode();
8811 if (HasPresolveBveThreshold) hash ^= PresolveBveThreshold.GetHashCode();
8812 if (HasPresolveBveClauseWeight) hash ^= PresolveBveClauseWeight.GetHashCode();
8813 if (HasProbingDeterministicTimeLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ProbingDeterministicTimeLimit);
8814 if (HasPresolveProbingDeterministicTimeLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PresolveProbingDeterministicTimeLimit);
8815 if (HasPresolveBlockedClause) hash ^= PresolveBlockedClause.GetHashCode();
8816 if (HasPresolveUseBva) hash ^= PresolveUseBva.GetHashCode();
8817 if (HasPresolveBvaThreshold) hash ^= PresolveBvaThreshold.GetHashCode();
8818 if (HasMaxPresolveIterations) hash ^= MaxPresolveIterations.GetHashCode();
8819 if (HasCpModelPresolve) hash ^= CpModelPresolve.GetHashCode();
8820 if (HasCpModelProbingLevel) hash ^= CpModelProbingLevel.GetHashCode();
8821 if (HasCpModelUseSatPresolve) hash ^= CpModelUseSatPresolve.GetHashCode();
8822 if (HasDetectTableWithCost) hash ^= DetectTableWithCost.GetHashCode();
8823 if (HasTableCompressionLevel) hash ^= TableCompressionLevel.GetHashCode();
8824 if (HasExpandAlldiffConstraints) hash ^= ExpandAlldiffConstraints.GetHashCode();
8825 if (HasExpandReservoirConstraints) hash ^= ExpandReservoirConstraints.GetHashCode();
8826 if (HasExpandReservoirUsingCircuit) hash ^= ExpandReservoirUsingCircuit.GetHashCode();
8827 if (HasEncodeCumulativeAsReservoir) hash ^= EncodeCumulativeAsReservoir.GetHashCode();
8828 if (HasMaxLinMaxSizeForExpansion) hash ^= MaxLinMaxSizeForExpansion.GetHashCode();
8829 if (HasDisableConstraintExpansion) hash ^= DisableConstraintExpansion.GetHashCode();
8830 if (HasEncodeComplexLinearConstraintWithInteger) hash ^= EncodeComplexLinearConstraintWithInteger.GetHashCode();
8831 if (HasMergeNoOverlapWorkLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MergeNoOverlapWorkLimit);
8832 if (HasMergeAtMostOneWorkLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MergeAtMostOneWorkLimit);
8833 if (HasPresolveSubstitutionLevel) hash ^= PresolveSubstitutionLevel.GetHashCode();
8834 if (HasPresolveExtractIntegerEnforcement) hash ^= PresolveExtractIntegerEnforcement.GetHashCode();
8835 if (HasPresolveInclusionWorkLimit) hash ^= PresolveInclusionWorkLimit.GetHashCode();
8836 if (HasIgnoreNames) hash ^= IgnoreNames.GetHashCode();
8837 if (HasInferAllDiffs) hash ^= InferAllDiffs.GetHashCode();
8838 if (HasFindBigLinearOverlap) hash ^= FindBigLinearOverlap.GetHashCode();
8839 if (HasUseSatInprocessing) hash ^= UseSatInprocessing.GetHashCode();
8840 if (HasInprocessingDtimeRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(InprocessingDtimeRatio);
8841 if (HasInprocessingProbingDtime) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(InprocessingProbingDtime);
8842 if (HasInprocessingMinimizationDtime) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(InprocessingMinimizationDtime);
8843 if (HasNumWorkers) hash ^= NumWorkers.GetHashCode();
8844 if (HasNumSearchWorkers) hash ^= NumSearchWorkers.GetHashCode();
8845 if (HasNumFullSubsolvers) hash ^= NumFullSubsolvers.GetHashCode();
8846 hash ^= subsolvers_.GetHashCode();
8847 hash ^= extraSubsolvers_.GetHashCode();
8848 hash ^= ignoreSubsolvers_.GetHashCode();
8849 hash ^= filterSubsolvers_.GetHashCode();
8850 hash ^= subsolverParams_.GetHashCode();
8851 if (HasInterleaveSearch) hash ^= InterleaveSearch.GetHashCode();
8852 if (HasInterleaveBatchSize) hash ^= InterleaveBatchSize.GetHashCode();
8853 if (HasShareObjectiveBounds) hash ^= ShareObjectiveBounds.GetHashCode();
8854 if (HasShareLevelZeroBounds) hash ^= ShareLevelZeroBounds.GetHashCode();
8855 if (HasShareBinaryClauses) hash ^= ShareBinaryClauses.GetHashCode();
8856 if (HasShareGlueClauses) hash ^= ShareGlueClauses.GetHashCode();
8857 if (HasDebugPostsolveWithFullSolver) hash ^= DebugPostsolveWithFullSolver.GetHashCode();
8858 if (HasDebugMaxNumPresolveOperations) hash ^= DebugMaxNumPresolveOperations.GetHashCode();
8859 if (HasDebugCrashOnBadHint) hash ^= DebugCrashOnBadHint.GetHashCode();
8860 if (HasUseOptimizationHints) hash ^= UseOptimizationHints.GetHashCode();
8861 if (HasCoreMinimizationLevel) hash ^= CoreMinimizationLevel.GetHashCode();
8862 if (HasFindMultipleCores) hash ^= FindMultipleCores.GetHashCode();
8863 if (HasCoverOptimization) hash ^= CoverOptimization.GetHashCode();
8864 if (HasMaxSatAssumptionOrder) hash ^= MaxSatAssumptionOrder.GetHashCode();
8865 if (HasMaxSatReverseAssumptionOrder) hash ^= MaxSatReverseAssumptionOrder.GetHashCode();
8866 if (HasMaxSatStratification) hash ^= MaxSatStratification.GetHashCode();
8867 if (HasPropagationLoopDetectionFactor) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PropagationLoopDetectionFactor);
8868 if (HasUsePrecedencesInDisjunctiveConstraint) hash ^= UsePrecedencesInDisjunctiveConstraint.GetHashCode();
8869 if (HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) hash ^= MaxSizeToCreatePrecedenceLiteralsInDisjunctive.GetHashCode();
8870 if (HasUseStrongPropagationInDisjunctive) hash ^= UseStrongPropagationInDisjunctive.GetHashCode();
8871 if (HasUseDynamicPrecedenceInDisjunctive) hash ^= UseDynamicPrecedenceInDisjunctive.GetHashCode();
8872 if (HasUseDynamicPrecedenceInCumulative) hash ^= UseDynamicPrecedenceInCumulative.GetHashCode();
8873 if (HasUseOverloadCheckerInCumulative) hash ^= UseOverloadCheckerInCumulative.GetHashCode();
8874 if (HasUseConservativeScaleOverloadChecker) hash ^= UseConservativeScaleOverloadChecker.GetHashCode();
8875 if (HasUseTimetableEdgeFindingInCumulative) hash ^= UseTimetableEdgeFindingInCumulative.GetHashCode();
8876 if (HasMaxNumIntervalsForTimetableEdgeFinding) hash ^= MaxNumIntervalsForTimetableEdgeFinding.GetHashCode();
8877 if (HasUseHardPrecedencesInCumulative) hash ^= UseHardPrecedencesInCumulative.GetHashCode();
8878 if (HasExploitAllPrecedences) hash ^= ExploitAllPrecedences.GetHashCode();
8879 if (HasUseDisjunctiveConstraintInCumulative) hash ^= UseDisjunctiveConstraintInCumulative.GetHashCode();
8880 if (HasUseTimetablingInNoOverlap2D) hash ^= UseTimetablingInNoOverlap2D.GetHashCode();
8881 if (HasUseEnergeticReasoningInNoOverlap2D) hash ^= UseEnergeticReasoningInNoOverlap2D.GetHashCode();
8882 if (HasUseAreaEnergeticReasoningInNoOverlap2D) hash ^= UseAreaEnergeticReasoningInNoOverlap2D.GetHashCode();
8883 if (HasMaxPairsPairwiseReasoningInNoOverlap2D) hash ^= MaxPairsPairwiseReasoningInNoOverlap2D.GetHashCode();
8884 if (HasUseDualSchedulingHeuristics) hash ^= UseDualSchedulingHeuristics.GetHashCode();
8885 if (HasSearchBranching) hash ^= SearchBranching.GetHashCode();
8886 if (HasHintConflictLimit) hash ^= HintConflictLimit.GetHashCode();
8887 if (HasRepairHint) hash ^= RepairHint.GetHashCode();
8888 if (HasFixVariablesToTheirHintedValue) hash ^= FixVariablesToTheirHintedValue.GetHashCode();
8889 if (HasUseProbingSearch) hash ^= UseProbingSearch.GetHashCode();
8890 if (HasUseExtendedProbing) hash ^= UseExtendedProbing.GetHashCode();
8891 if (HasProbingNumCombinationsLimit) hash ^= ProbingNumCombinationsLimit.GetHashCode();
8892 if (HasUseShavingInProbingSearch) hash ^= UseShavingInProbingSearch.GetHashCode();
8893 if (HasShavingSearchDeterministicTime) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ShavingSearchDeterministicTime);
8894 if (HasShavingSearchThreshold) hash ^= ShavingSearchThreshold.GetHashCode();
8895 if (HasUseObjectiveLbSearch) hash ^= UseObjectiveLbSearch.GetHashCode();
8896 if (HasUseObjectiveShavingSearch) hash ^= UseObjectiveShavingSearch.GetHashCode();
8897 if (HasUseVariablesShavingSearch) hash ^= UseVariablesShavingSearch.GetHashCode();
8898 if (HasPseudoCostReliabilityThreshold) hash ^= PseudoCostReliabilityThreshold.GetHashCode();
8899 if (HasOptimizeWithCore) hash ^= OptimizeWithCore.GetHashCode();
8900 if (HasOptimizeWithLbTreeSearch) hash ^= OptimizeWithLbTreeSearch.GetHashCode();
8901 if (HasSaveLpBasisInLbTreeSearch) hash ^= SaveLpBasisInLbTreeSearch.GetHashCode();
8902 if (HasBinarySearchNumConflicts) hash ^= BinarySearchNumConflicts.GetHashCode();
8903 if (HasOptimizeWithMaxHs) hash ^= OptimizeWithMaxHs.GetHashCode();
8904 if (HasUseFeasibilityJump) hash ^= UseFeasibilityJump.GetHashCode();
8905 if (HasUseLsOnly) hash ^= UseLsOnly.GetHashCode();
8906 if (HasFeasibilityJumpDecay) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(FeasibilityJumpDecay);
8907 if (HasFeasibilityJumpLinearizationLevel) hash ^= FeasibilityJumpLinearizationLevel.GetHashCode();
8908 if (HasFeasibilityJumpRestartFactor) hash ^= FeasibilityJumpRestartFactor.GetHashCode();
8909 if (HasFeasibilityJumpBatchDtime) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(FeasibilityJumpBatchDtime);
8910 if (HasFeasibilityJumpVarRandomizationProbability) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(FeasibilityJumpVarRandomizationProbability);
8911 if (HasFeasibilityJumpVarPerburbationRangeRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(FeasibilityJumpVarPerburbationRangeRatio);
8912 if (HasFeasibilityJumpEnableRestarts) hash ^= FeasibilityJumpEnableRestarts.GetHashCode();
8913 if (HasFeasibilityJumpMaxExpandedConstraintSize) hash ^= FeasibilityJumpMaxExpandedConstraintSize.GetHashCode();
8914 if (HasNumViolationLs) hash ^= NumViolationLs.GetHashCode();
8915 if (HasViolationLsPerturbationPeriod) hash ^= ViolationLsPerturbationPeriod.GetHashCode();
8916 if (HasViolationLsCompoundMoveProbability) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ViolationLsCompoundMoveProbability);
8917 if (HasSharedTreeNumWorkers) hash ^= SharedTreeNumWorkers.GetHashCode();
8918 if (HasUseSharedTreeSearch) hash ^= UseSharedTreeSearch.GetHashCode();
8919 if (HasSharedTreeWorkerObjectiveSplitProbability) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(SharedTreeWorkerObjectiveSplitProbability);
8920 if (HasSharedTreeWorkerMinRestartsPerSubtree) hash ^= SharedTreeWorkerMinRestartsPerSubtree.GetHashCode();
8921 if (HasSharedTreeWorkerEnableTrailSharing) hash ^= SharedTreeWorkerEnableTrailSharing.GetHashCode();
8922 if (HasSharedTreeOpenLeavesPerWorker) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(SharedTreeOpenLeavesPerWorker);
8923 if (HasSharedTreeMaxNodesPerWorker) hash ^= SharedTreeMaxNodesPerWorker.GetHashCode();
8924 if (HasSharedTreeSplitStrategy) hash ^= SharedTreeSplitStrategy.GetHashCode();
8925 if (HasEnumerateAllSolutions) hash ^= EnumerateAllSolutions.GetHashCode();
8926 if (HasKeepAllFeasibleSolutionsInPresolve) hash ^= KeepAllFeasibleSolutionsInPresolve.GetHashCode();
8927 if (HasFillTightenedDomainsInResponse) hash ^= FillTightenedDomainsInResponse.GetHashCode();
8928 if (HasFillAdditionalSolutionsInResponse) hash ^= FillAdditionalSolutionsInResponse.GetHashCode();
8929 if (HasInstantiateAllVariables) hash ^= InstantiateAllVariables.GetHashCode();
8930 if (HasAutoDetectGreaterThanAtLeastOneOf) hash ^= AutoDetectGreaterThanAtLeastOneOf.GetHashCode();
8931 if (HasStopAfterFirstSolution) hash ^= StopAfterFirstSolution.GetHashCode();
8932 if (HasStopAfterPresolve) hash ^= StopAfterPresolve.GetHashCode();
8933 if (HasStopAfterRootPropagation) hash ^= StopAfterRootPropagation.GetHashCode();
8934 if (HasUseLns) hash ^= UseLns.GetHashCode();
8935 if (HasUseLnsOnly) hash ^= UseLnsOnly.GetHashCode();
8936 if (HasSolutionPoolSize) hash ^= SolutionPoolSize.GetHashCode();
8937 if (HasUseRinsLns) hash ^= UseRinsLns.GetHashCode();
8938 if (HasUseFeasibilityPump) hash ^= UseFeasibilityPump.GetHashCode();
8939 if (HasUseLbRelaxLns) hash ^= UseLbRelaxLns.GetHashCode();
8940 if (HasFpRounding) hash ^= FpRounding.GetHashCode();
8941 if (HasDiversifyLnsParams) hash ^= DiversifyLnsParams.GetHashCode();
8942 if (HasRandomizeSearch) hash ^= RandomizeSearch.GetHashCode();
8943 if (HasSearchRandomVariablePoolSize) hash ^= SearchRandomVariablePoolSize.GetHashCode();
8944 if (HasPushAllTasksTowardStart) hash ^= PushAllTasksTowardStart.GetHashCode();
8945 if (HasUseOptionalVariables) hash ^= UseOptionalVariables.GetHashCode();
8946 if (HasUseExactLpReason) hash ^= UseExactLpReason.GetHashCode();
8947 if (HasUseCombinedNoOverlap) hash ^= UseCombinedNoOverlap.GetHashCode();
8948 if (HasAtMostOneMaxExpansionSize) hash ^= AtMostOneMaxExpansionSize.GetHashCode();
8949 if (HasCatchSigintSignal) hash ^= CatchSigintSignal.GetHashCode();
8950 if (HasUseImpliedBounds) hash ^= UseImpliedBounds.GetHashCode();
8951 if (HasPolishLpSolution) hash ^= PolishLpSolution.GetHashCode();
8952 if (HasLpPrimalTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(LpPrimalTolerance);
8953 if (HasLpDualTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(LpDualTolerance);
8954 if (HasConvertIntervals) hash ^= ConvertIntervals.GetHashCode();
8955 if (HasSymmetryLevel) hash ^= SymmetryLevel.GetHashCode();
8956 if (HasNewLinearPropagation) hash ^= NewLinearPropagation.GetHashCode();
8957 if (HasLinearSplitSize) hash ^= LinearSplitSize.GetHashCode();
8958 if (HasLinearizationLevel) hash ^= LinearizationLevel.GetHashCode();
8959 if (HasBooleanEncodingLevel) hash ^= BooleanEncodingLevel.GetHashCode();
8960 if (HasMaxDomainSizeWhenEncodingEqNeqConstraints) hash ^= MaxDomainSizeWhenEncodingEqNeqConstraints.GetHashCode();
8961 if (HasMaxNumCuts) hash ^= MaxNumCuts.GetHashCode();
8962 if (HasCutLevel) hash ^= CutLevel.GetHashCode();
8963 if (HasOnlyAddCutsAtLevelZero) hash ^= OnlyAddCutsAtLevelZero.GetHashCode();
8964 if (HasAddObjectiveCut) hash ^= AddObjectiveCut.GetHashCode();
8965 if (HasAddCgCuts) hash ^= AddCgCuts.GetHashCode();
8966 if (HasAddMirCuts) hash ^= AddMirCuts.GetHashCode();
8967 if (HasAddZeroHalfCuts) hash ^= AddZeroHalfCuts.GetHashCode();
8968 if (HasAddCliqueCuts) hash ^= AddCliqueCuts.GetHashCode();
8969 if (HasAddRltCuts) hash ^= AddRltCuts.GetHashCode();
8970 if (HasMaxAllDiffCutSize) hash ^= MaxAllDiffCutSize.GetHashCode();
8971 if (HasAddLinMaxCuts) hash ^= AddLinMaxCuts.GetHashCode();
8972 if (HasMaxIntegerRoundingScaling) hash ^= MaxIntegerRoundingScaling.GetHashCode();
8973 if (HasAddLpConstraintsLazily) hash ^= AddLpConstraintsLazily.GetHashCode();
8974 if (HasRootLpIterations) hash ^= RootLpIterations.GetHashCode();
8975 if (HasMinOrthogonalityForLpConstraints) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MinOrthogonalityForLpConstraints);
8976 if (HasMaxCutRoundsAtLevelZero) hash ^= MaxCutRoundsAtLevelZero.GetHashCode();
8977 if (HasMaxConsecutiveInactiveCount) hash ^= MaxConsecutiveInactiveCount.GetHashCode();
8978 if (HasCutMaxActiveCountValue) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(CutMaxActiveCountValue);
8979 if (HasCutActiveCountDecay) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(CutActiveCountDecay);
8980 if (HasCutCleanupTarget) hash ^= CutCleanupTarget.GetHashCode();
8981 if (HasNewConstraintsBatchSize) hash ^= NewConstraintsBatchSize.GetHashCode();
8982 if (HasExploitIntegerLpSolution) hash ^= ExploitIntegerLpSolution.GetHashCode();
8983 if (HasExploitAllLpSolution) hash ^= ExploitAllLpSolution.GetHashCode();
8984 if (HasExploitBestSolution) hash ^= ExploitBestSolution.GetHashCode();
8985 if (HasExploitRelaxationSolution) hash ^= ExploitRelaxationSolution.GetHashCode();
8986 if (HasExploitObjective) hash ^= ExploitObjective.GetHashCode();
8987 if (HasDetectLinearizedProduct) hash ^= DetectLinearizedProduct.GetHashCode();
8988 if (HasMipMaxBound) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MipMaxBound);
8989 if (HasMipVarScaling) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MipVarScaling);
8990 if (HasMipScaleLargeDomain) hash ^= MipScaleLargeDomain.GetHashCode();
8991 if (HasMipAutomaticallyScaleVariables) hash ^= MipAutomaticallyScaleVariables.GetHashCode();
8992 if (HasOnlySolveIp) hash ^= OnlySolveIp.GetHashCode();
8993 if (HasMipWantedPrecision) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MipWantedPrecision);
8994 if (HasMipMaxActivityExponent) hash ^= MipMaxActivityExponent.GetHashCode();
8995 if (HasMipCheckPrecision) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MipCheckPrecision);
8996 if (HasMipComputeTrueObjectiveBound) hash ^= MipComputeTrueObjectiveBound.GetHashCode();
8997 if (HasMipMaxValidMagnitude) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MipMaxValidMagnitude);
8998 if (HasMipTreatHighMagnitudeBoundsAsInfinity) hash ^= MipTreatHighMagnitudeBoundsAsInfinity.GetHashCode();
8999 if (HasMipDropTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MipDropTolerance);
9000 if (HasMipPresolveLevel) hash ^= MipPresolveLevel.GetHashCode();
9001 if (_unknownFields !=
null) {
9002 hash ^= _unknownFields.GetHashCode();
9007 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9008 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9009 public override string ToString() {
9010 return pb::JsonFormatter.ToDiagnosticString(
this);
9013 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9014 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9015 public void WriteTo(pb::CodedOutputStream output) {
9016 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
9017 output.WriteRawMessage(
this);
9019 if (HasPreferredVariableOrder) {
9020 output.WriteRawTag(8);
9021 output.WriteEnum((
int) PreferredVariableOrder);
9023 if (HasInitialPolarity) {
9024 output.WriteRawTag(16);
9025 output.WriteEnum((
int) InitialPolarity);
9027 if (HasMinimizationAlgorithm) {
9028 output.WriteRawTag(32);
9029 output.WriteEnum((
int) MinimizationAlgorithm);
9031 if (HasClauseCleanupPeriod) {
9032 output.WriteRawTag(88);
9033 output.WriteInt32(ClauseCleanupPeriod);
9035 if (HasClauseCleanupTarget) {
9036 output.WriteRawTag(104);
9037 output.WriteInt32(ClauseCleanupTarget);
9039 if (HasVariableActivityDecay) {
9040 output.WriteRawTag(121);
9041 output.WriteDouble(VariableActivityDecay);
9043 if (HasMaxVariableActivityValue) {
9044 output.WriteRawTag(129, 1);
9045 output.WriteDouble(MaxVariableActivityValue);
9047 if (HasClauseActivityDecay) {
9048 output.WriteRawTag(137, 1);
9049 output.WriteDouble(ClauseActivityDecay);
9051 if (HasMaxClauseActivityValue) {
9052 output.WriteRawTag(145, 1);
9053 output.WriteDouble(MaxClauseActivityValue);
9055 if (HasGlucoseMaxDecay) {
9056 output.WriteRawTag(177, 1);
9057 output.WriteDouble(GlucoseMaxDecay);
9059 if (HasGlucoseDecayIncrement) {
9060 output.WriteRawTag(185, 1);
9061 output.WriteDouble(GlucoseDecayIncrement);
9063 if (HasGlucoseDecayIncrementPeriod) {
9064 output.WriteRawTag(192, 1);
9065 output.WriteInt32(GlucoseDecayIncrementPeriod);
9067 if (HasRestartPeriod) {
9068 output.WriteRawTag(240, 1);
9069 output.WriteInt32(RestartPeriod);
9071 if (HasRandomSeed) {
9072 output.WriteRawTag(248, 1);
9073 output.WriteInt32(RandomSeed);
9075 if (HasRandomBranchesRatio) {
9076 output.WriteRawTag(129, 2);
9077 output.WriteDouble(RandomBranchesRatio);
9079 if (HasBinaryMinimizationAlgorithm) {
9080 output.WriteRawTag(144, 2);
9081 output.WriteEnum((
int) BinaryMinimizationAlgorithm);
9083 if (HasUseOptimizationHints) {
9084 output.WriteRawTag(152, 2);
9085 output.WriteBool(UseOptimizationHints);
9087 if (HasMaxTimeInSeconds) {
9088 output.WriteRawTag(161, 2);
9089 output.WriteDouble(MaxTimeInSeconds);
9091 if (HasMaxNumberOfConflicts) {
9092 output.WriteRawTag(168, 2);
9093 output.WriteInt64(MaxNumberOfConflicts);
9095 if (HasMaxMemoryInMb) {
9096 output.WriteRawTag(192, 2);
9097 output.WriteInt64(MaxMemoryInMb);
9099 if (HasLogSearchProgress) {
9100 output.WriteRawTag(200, 2);
9101 output.WriteBool(LogSearchProgress);
9103 if (HasUsePbResolution) {
9104 output.WriteRawTag(216, 2);
9105 output.WriteBool(UsePbResolution);
9107 if (HasUsePhaseSaving) {
9108 output.WriteRawTag(224, 2);
9109 output.WriteBool(UsePhaseSaving);
9111 if (HasRandomPolarityRatio) {
9112 output.WriteRawTag(233, 2);
9113 output.WriteDouble(RandomPolarityRatio);
9115 if (HasPbCleanupIncrement) {
9116 output.WriteRawTag(240, 2);
9117 output.WriteInt32(PbCleanupIncrement);
9119 if (HasPbCleanupRatio) {
9120 output.WriteRawTag(249, 2);
9121 output.WriteDouble(PbCleanupRatio);
9123 if (HasMinimizeReductionDuringPbResolution) {
9124 output.WriteRawTag(128, 3);
9125 output.WriteBool(MinimizeReductionDuringPbResolution);
9127 if (HasCountAssumptionLevelsInLbd) {
9128 output.WriteRawTag(136, 3);
9129 output.WriteBool(CountAssumptionLevelsInLbd);
9131 if (HasCoreMinimizationLevel) {
9132 output.WriteRawTag(144, 3);
9133 output.WriteInt32(CoreMinimizationLevel);
9135 if (HasMaxSatAssumptionOrder) {
9136 output.WriteRawTag(152, 3);
9137 output.WriteEnum((
int) MaxSatAssumptionOrder);
9139 if (HasMaxSatReverseAssumptionOrder) {
9140 output.WriteRawTag(160, 3);
9141 output.WriteBool(MaxSatReverseAssumptionOrder);
9143 if (HasMaxSatStratification) {
9144 output.WriteRawTag(168, 3);
9145 output.WriteEnum((
int) MaxSatStratification);
9147 if (HasPresolveBveThreshold) {
9148 output.WriteRawTag(176, 3);
9149 output.WriteInt32(PresolveBveThreshold);
9151 if (HasPresolveBveClauseWeight) {
9152 output.WriteRawTag(184, 3);
9153 output.WriteInt32(PresolveBveClauseWeight);
9155 if (HasSubsumptionDuringConflictAnalysis) {
9156 output.WriteRawTag(192, 3);
9157 output.WriteBool(SubsumptionDuringConflictAnalysis);
9159 if (HasPresolveProbingDeterministicTimeLimit) {
9160 output.WriteRawTag(201, 3);
9161 output.WriteDouble(PresolveProbingDeterministicTimeLimit);
9163 if (HasClauseCleanupProtection) {
9164 output.WriteRawTag(208, 3);
9165 output.WriteEnum((
int) ClauseCleanupProtection);
9167 if (HasClauseCleanupLbdBound) {
9168 output.WriteRawTag(216, 3);
9169 output.WriteInt32(ClauseCleanupLbdBound);
9171 if (HasClauseCleanupOrdering) {
9172 output.WriteRawTag(224, 3);
9173 output.WriteEnum((
int) ClauseCleanupOrdering);
9175 restartAlgorithms_.WriteTo(output, _repeated_restartAlgorithms_codec);
9176 if (HasRestartRunningWindowSize) {
9177 output.WriteRawTag(240, 3);
9178 output.WriteInt32(RestartRunningWindowSize);
9180 if (HasRestartDlAverageRatio) {
9181 output.WriteRawTag(249, 3);
9182 output.WriteDouble(RestartDlAverageRatio);
9184 if (HasUseBlockingRestart) {
9185 output.WriteRawTag(128, 4);
9186 output.WriteBool(UseBlockingRestart);
9188 if (HasBlockingRestartWindowSize) {
9189 output.WriteRawTag(136, 4);
9190 output.WriteInt32(BlockingRestartWindowSize);
9192 if (HasBlockingRestartMultiplier) {
9193 output.WriteRawTag(145, 4);
9194 output.WriteDouble(BlockingRestartMultiplier);
9196 if (HasMaxDeterministicTime) {
9197 output.WriteRawTag(153, 4);
9198 output.WriteDouble(MaxDeterministicTime);
9200 if (HasNumConflictsBeforeStrategyChanges) {
9201 output.WriteRawTag(160, 4);
9202 output.WriteInt32(NumConflictsBeforeStrategyChanges);
9204 if (HasStrategyChangeIncreaseRatio) {
9205 output.WriteRawTag(169, 4);
9206 output.WriteDouble(StrategyChangeIncreaseRatio);
9208 if (HasDefaultRestartAlgorithms) {
9209 output.WriteRawTag(178, 4);
9210 output.WriteString(DefaultRestartAlgorithms);
9212 if (HasRestartLbdAverageRatio) {
9213 output.WriteRawTag(185, 4);
9214 output.WriteDouble(RestartLbdAverageRatio);
9216 if (HasPresolveUseBva) {
9217 output.WriteRawTag(192, 4);
9218 output.WriteBool(PresolveUseBva);
9220 if (HasPresolveBvaThreshold) {
9221 output.WriteRawTag(200, 4);
9222 output.WriteInt32(PresolveBvaThreshold);
9224 if (HasUsePrecedencesInDisjunctiveConstraint) {
9225 output.WriteRawTag(208, 4);
9226 output.WriteBool(UsePrecedencesInDisjunctiveConstraint);
9228 if (HasUseErwaHeuristic) {
9229 output.WriteRawTag(216, 4);
9230 output.WriteBool(UseErwaHeuristic);
9232 if (HasInitialVariablesActivity) {
9233 output.WriteRawTag(225, 4);
9234 output.WriteDouble(InitialVariablesActivity);
9236 if (HasAlsoBumpVariablesInConflictReasons) {
9237 output.WriteRawTag(232, 4);
9238 output.WriteBool(AlsoBumpVariablesInConflictReasons);
9240 if (HasUseOverloadCheckerInCumulative) {
9241 output.WriteRawTag(240, 4);
9242 output.WriteBool(UseOverloadCheckerInCumulative);
9244 if (HasUseTimetableEdgeFindingInCumulative) {
9245 output.WriteRawTag(248, 4);
9246 output.WriteBool(UseTimetableEdgeFindingInCumulative);
9248 if (HasUseDisjunctiveConstraintInCumulative) {
9249 output.WriteRawTag(128, 5);
9250 output.WriteBool(UseDisjunctiveConstraintInCumulative);
9252 if (HasSearchBranching) {
9253 output.WriteRawTag(144, 5);
9254 output.WriteEnum((
int) SearchBranching);
9256 if (HasOptimizeWithCore) {
9257 output.WriteRawTag(152, 5);
9258 output.WriteBool(OptimizeWithCore);
9260 if (HasFindMultipleCores) {
9261 output.WriteRawTag(160, 5);
9262 output.WriteBool(FindMultipleCores);
9264 if (HasOptimizeWithMaxHs) {
9265 output.WriteRawTag(168, 5);
9266 output.WriteBool(OptimizeWithMaxHs);
9268 if (HasCpModelPresolve) {
9269 output.WriteRawTag(176, 5);
9270 output.WriteBool(CpModelPresolve);
9272 if (HasEnumerateAllSolutions) {
9273 output.WriteRawTag(184, 5);
9274 output.WriteBool(EnumerateAllSolutions);
9276 if (HasPresolveBlockedClause) {
9277 output.WriteRawTag(192, 5);
9278 output.WriteBool(PresolveBlockedClause);
9280 if (HasCoverOptimization) {
9281 output.WriteRawTag(200, 5);
9282 output.WriteBool(CoverOptimization);
9284 if (HasLinearizationLevel) {
9285 output.WriteRawTag(208, 5);
9286 output.WriteInt32(LinearizationLevel);
9288 if (HasMaxNumCuts) {
9289 output.WriteRawTag(216, 5);
9290 output.WriteInt32(MaxNumCuts);
9292 if (HasOnlyAddCutsAtLevelZero) {
9293 output.WriteRawTag(224, 5);
9294 output.WriteBool(OnlyAddCutsAtLevelZero);
9296 if (HasCpModelUseSatPresolve) {
9297 output.WriteRawTag(232, 5);
9298 output.WriteBool(CpModelUseSatPresolve);
9300 if (HasExploitIntegerLpSolution) {
9301 output.WriteRawTag(240, 5);
9302 output.WriteBool(ExploitIntegerLpSolution);
9304 if (HasAutoDetectGreaterThanAtLeastOneOf) {
9305 output.WriteRawTag(248, 5);
9306 output.WriteBool(AutoDetectGreaterThanAtLeastOneOf);
9308 if (HasStopAfterFirstSolution) {
9309 output.WriteRawTag(144, 6);
9310 output.WriteBool(StopAfterFirstSolution);
9312 if (HasBinarySearchNumConflicts) {
9313 output.WriteRawTag(152, 6);
9314 output.WriteInt32(BinarySearchNumConflicts);
9316 if (HasNumSearchWorkers) {
9317 output.WriteRawTag(160, 6);
9318 output.WriteInt32(NumSearchWorkers);
9320 if (HasUseLnsOnly) {
9321 output.WriteRawTag(168, 6);
9322 output.WriteBool(UseLnsOnly);
9324 if (HasRandomizeSearch) {
9325 output.WriteRawTag(184, 6);
9326 output.WriteBool(RandomizeSearch);
9328 if (HasSearchRandomVariablePoolSize) {
9329 output.WriteRawTag(192, 6);
9330 output.WriteInt64(SearchRandomVariablePoolSize);
9332 if (HasInstantiateAllVariables) {
9333 output.WriteRawTag(208, 6);
9334 output.WriteBool(InstantiateAllVariables);
9336 if (HasBooleanEncodingLevel) {
9337 output.WriteRawTag(216, 6);
9338 output.WriteInt32(BooleanEncodingLevel);
9340 if (HasUseOptionalVariables) {
9341 output.WriteRawTag(224, 6);
9342 output.WriteBool(UseOptionalVariables);
9344 if (HasUseExactLpReason) {
9345 output.WriteRawTag(232, 6);
9346 output.WriteBool(UseExactLpReason);
9348 if (HasCpModelProbingLevel) {
9349 output.WriteRawTag(240, 6);
9350 output.WriteInt32(CpModelProbingLevel);
9352 if (HasAddLpConstraintsLazily) {
9353 output.WriteRawTag(128, 7);
9354 output.WriteBool(AddLpConstraintsLazily);
9356 if (HasShareObjectiveBounds) {
9357 output.WriteRawTag(136, 7);
9358 output.WriteBool(ShareObjectiveBounds);
9360 if (HasShareLevelZeroBounds) {
9361 output.WriteRawTag(144, 7);
9362 output.WriteBool(ShareLevelZeroBounds);
9364 if (HasMinOrthogonalityForLpConstraints) {
9365 output.WriteRawTag(153, 7);
9366 output.WriteDouble(MinOrthogonalityForLpConstraints);
9368 if (HasExploitAllLpSolution) {
9369 output.WriteRawTag(160, 7);
9370 output.WriteBool(ExploitAllLpSolution);
9373 output.WriteRawTag(168, 7);
9374 output.WriteBool(AddCgCuts);
9376 if (HasMaxIntegerRoundingScaling) {
9377 output.WriteRawTag(184, 7);
9378 output.WriteInt32(MaxIntegerRoundingScaling);
9380 if (HasAddMirCuts) {
9381 output.WriteRawTag(192, 7);
9382 output.WriteBool(AddMirCuts);
9384 if (HasMaxConsecutiveInactiveCount) {
9385 output.WriteRawTag(200, 7);
9386 output.WriteInt32(MaxConsecutiveInactiveCount);
9388 if (HasNewConstraintsBatchSize) {
9389 output.WriteRawTag(208, 7);
9390 output.WriteInt32(NewConstraintsBatchSize);
9392 if (HasPseudoCostReliabilityThreshold) {
9393 output.WriteRawTag(216, 7);
9394 output.WriteInt64(PseudoCostReliabilityThreshold);
9396 if (HasMipMaxBound) {
9397 output.WriteRawTag(225, 7);
9398 output.WriteDouble(MipMaxBound);
9400 if (HasMipVarScaling) {
9401 output.WriteRawTag(233, 7);
9402 output.WriteDouble(MipVarScaling);
9404 if (HasMipWantedPrecision) {
9405 output.WriteRawTag(241, 7);
9406 output.WriteDouble(MipWantedPrecision);
9408 if (HasMipMaxActivityExponent) {
9409 output.WriteRawTag(248, 7);
9410 output.WriteInt32(MipMaxActivityExponent);
9412 if (HasMipCheckPrecision) {
9413 output.WriteRawTag(129, 8);
9414 output.WriteDouble(MipCheckPrecision);
9416 if (HasUseRinsLns) {
9417 output.WriteRawTag(136, 8);
9418 output.WriteBool(UseRinsLns);
9420 if (HasExploitBestSolution) {
9421 output.WriteRawTag(144, 8);
9422 output.WriteBool(ExploitBestSolution);
9424 if (HasExploitObjective) {
9425 output.WriteRawTag(152, 8);
9426 output.WriteBool(ExploitObjective);
9428 if (HasFillTightenedDomainsInResponse) {
9429 output.WriteRawTag(160, 8);
9430 output.WriteBool(FillTightenedDomainsInResponse);
9432 if (HasUseCombinedNoOverlap) {
9433 output.WriteRawTag(168, 8);
9434 output.WriteBool(UseCombinedNoOverlap);
9436 if (HasInterleaveBatchSize) {
9437 output.WriteRawTag(176, 8);
9438 output.WriteInt32(InterleaveBatchSize);
9440 if (HasCatchSigintSignal) {
9441 output.WriteRawTag(184, 8);
9442 output.WriteBool(CatchSigintSignal);
9444 if (HasInterleaveSearch) {
9445 output.WriteRawTag(192, 8);
9446 output.WriteBool(InterleaveSearch);
9448 if (HasDiversifyLnsParams) {
9449 output.WriteRawTag(200, 8);
9450 output.WriteBool(DiversifyLnsParams);
9452 if (HasMaxPresolveIterations) {
9453 output.WriteRawTag(208, 8);
9454 output.WriteInt32(MaxPresolveIterations);
9456 if (HasUseImpliedBounds) {
9457 output.WriteRawTag(128, 9);
9458 output.WriteBool(UseImpliedBounds);
9460 if (HasMergeNoOverlapWorkLimit) {
9461 output.WriteRawTag(137, 9);
9462 output.WriteDouble(MergeNoOverlapWorkLimit);
9464 if (HasMergeAtMostOneWorkLimit) {
9465 output.WriteRawTag(145, 9);
9466 output.WriteDouble(MergeAtMostOneWorkLimit);
9468 if (HasPresolveSubstitutionLevel) {
9469 output.WriteRawTag(152, 9);
9470 output.WriteInt32(PresolveSubstitutionLevel);
9472 if (HasMaxAllDiffCutSize) {
9473 output.WriteRawTag(160, 9);
9474 output.WriteInt32(MaxAllDiffCutSize);
9476 if (HasStopAfterPresolve) {
9477 output.WriteRawTag(168, 9);
9478 output.WriteBool(StopAfterPresolve);
9480 if (HasDebugMaxNumPresolveOperations) {
9481 output.WriteRawTag(184, 9);
9482 output.WriteInt32(DebugMaxNumPresolveOperations);
9484 if (HasAddLinMaxCuts) {
9485 output.WriteRawTag(192, 9);
9486 output.WriteBool(AddLinMaxCuts);
9488 if (HasHintConflictLimit) {
9489 output.WriteRawTag(200, 9);
9490 output.WriteInt32(HintConflictLimit);
9492 if (HasMaxCutRoundsAtLevelZero) {
9493 output.WriteRawTag(208, 9);
9494 output.WriteInt32(MaxCutRoundsAtLevelZero);
9496 if (HasCutMaxActiveCountValue) {
9497 output.WriteRawTag(217, 9);
9498 output.WriteDouble(CutMaxActiveCountValue);
9500 if (HasCutActiveCountDecay) {
9501 output.WriteRawTag(225, 9);
9502 output.WriteDouble(CutActiveCountDecay);
9504 if (HasCutCleanupTarget) {
9505 output.WriteRawTag(232, 9);
9506 output.WriteInt32(CutCleanupTarget);
9508 if (HasAbsoluteGapLimit) {
9509 output.WriteRawTag(249, 9);
9510 output.WriteDouble(AbsoluteGapLimit);
9512 if (HasRelativeGapLimit) {
9513 output.WriteRawTag(129, 10);
9514 output.WriteDouble(RelativeGapLimit);
9516 if (HasExploitRelaxationSolution) {
9517 output.WriteRawTag(136, 10);
9518 output.WriteBool(ExploitRelaxationSolution);
9520 if (HasDebugPostsolveWithFullSolver) {
9521 output.WriteRawTag(144, 10);
9522 output.WriteBool(DebugPostsolveWithFullSolver);
9524 if (HasUseSatInprocessing) {
9525 output.WriteRawTag(152, 10);
9526 output.WriteBool(UseSatInprocessing);
9528 if (HasUseFeasibilityPump) {
9529 output.WriteRawTag(160, 10);
9530 output.WriteBool(UseFeasibilityPump);
9532 if (HasFpRounding) {
9533 output.WriteRawTag(168, 10);
9534 output.WriteEnum((
int) FpRounding);
9536 if (HasMipAutomaticallyScaleVariables) {
9537 output.WriteRawTag(176, 10);
9538 output.WriteBool(MipAutomaticallyScaleVariables);
9540 if (HasRepairHint) {
9541 output.WriteRawTag(184, 10);
9542 output.WriteBool(RepairHint);
9544 if (HasPolarityRephaseIncrement) {
9545 output.WriteRawTag(192, 10);
9546 output.WriteInt32(PolarityRephaseIncrement);
9548 if (HasAddZeroHalfCuts) {
9549 output.WriteRawTag(200, 10);
9550 output.WriteBool(AddZeroHalfCuts);
9552 if (HasExpandAlldiffConstraints) {
9553 output.WriteRawTag(208, 10);
9554 output.WriteBool(ExpandAlldiffConstraints);
9557 output.WriteRawTag(218, 10);
9558 output.WriteString(Name);
9560 if (HasAddCliqueCuts) {
9561 output.WriteRawTag(224, 10);
9562 output.WriteBool(AddCliqueCuts);
9564 if (HasKeepAllFeasibleSolutionsInPresolve) {
9565 output.WriteRawTag(232, 10);
9566 output.WriteBool(KeepAllFeasibleSolutionsInPresolve);
9568 if (HasPresolveExtractIntegerEnforcement) {
9569 output.WriteRawTag(240, 10);
9570 output.WriteBool(PresolveExtractIntegerEnforcement);
9572 if (HasPolishLpSolution) {
9573 output.WriteRawTag(248, 10);
9574 output.WriteBool(PolishLpSolution);
9576 if (HasUseProbingSearch) {
9577 output.WriteRawTag(128, 11);
9578 output.WriteBool(UseProbingSearch);
9580 if (HasConvertIntervals) {
9581 output.WriteRawTag(136, 11);
9582 output.WriteBool(ConvertIntervals);
9584 if (HasPermuteVariableRandomly) {
9585 output.WriteRawTag(144, 11);
9586 output.WriteBool(PermuteVariableRandomly);
9588 if (HasPermutePresolveConstraintOrder) {
9589 output.WriteRawTag(152, 11);
9590 output.WriteBool(PermutePresolveConstraintOrder);
9592 if (HasUseAbslRandom) {
9593 output.WriteRawTag(160, 11);
9594 output.WriteBool(UseAbslRandom);
9596 if (HasDisableConstraintExpansion) {
9597 output.WriteRawTag(168, 11);
9598 output.WriteBool(DisableConstraintExpansion);
9600 if (HasExpandReservoirConstraints) {
9601 output.WriteRawTag(176, 11);
9602 output.WriteBool(ExpandReservoirConstraints);
9604 if (HasSymmetryLevel) {
9605 output.WriteRawTag(184, 11);
9606 output.WriteInt32(SymmetryLevel);
9609 output.WriteRawTag(202, 11);
9610 output.WriteString(LogPrefix);
9612 if (HasLogToStdout) {
9613 output.WriteRawTag(208, 11);
9614 output.WriteBool(LogToStdout);
9616 if (HasLogToResponse) {
9617 output.WriteRawTag(216, 11);
9618 output.WriteBool(LogToResponse);
9620 if (HasOptimizeWithLbTreeSearch) {
9621 output.WriteRawTag(224, 11);
9622 output.WriteBool(OptimizeWithLbTreeSearch);
9624 if (HasLogSubsolverStatistics) {
9625 output.WriteRawTag(232, 11);
9626 output.WriteBool(LogSubsolverStatistics);
9628 if (HasClauseCleanupRatio) {
9629 output.WriteRawTag(241, 11);
9630 output.WriteDouble(ClauseCleanupRatio);
9632 if (HasMaxDomainSizeWhenEncodingEqNeqConstraints) {
9633 output.WriteRawTag(248, 11);
9634 output.WriteInt32(MaxDomainSizeWhenEncodingEqNeqConstraints);
9636 if (HasFixVariablesToTheirHintedValue) {
9637 output.WriteRawTag(128, 12);
9638 output.WriteBool(FixVariablesToTheirHintedValue);
9640 if (HasSolutionPoolSize) {
9641 output.WriteRawTag(136, 12);
9642 output.WriteInt32(SolutionPoolSize);
9644 if (HasFillAdditionalSolutionsInResponse) {
9645 output.WriteRawTag(144, 12);
9646 output.WriteBool(FillAdditionalSolutionsInResponse);
9648 if (HasDebugCrashOnBadHint) {
9649 output.WriteRawTag(152, 12);
9650 output.WriteBool(DebugCrashOnBadHint);
9653 output.WriteRawTag(160, 12);
9654 output.WriteInt32(CutLevel);
9656 if (HasAddObjectiveCut) {
9657 output.WriteRawTag(168, 12);
9658 output.WriteBool(AddObjectiveCut);
9660 if (HasMipComputeTrueObjectiveBound) {
9661 output.WriteRawTag(176, 12);
9662 output.WriteBool(MipComputeTrueObjectiveBound);
9664 if (HasMipMaxValidMagnitude) {
9665 output.WriteRawTag(185, 12);
9666 output.WriteDouble(MipMaxValidMagnitude);
9668 if (HasUseTimetablingInNoOverlap2D) {
9669 output.WriteRawTag(192, 12);
9670 output.WriteBool(UseTimetablingInNoOverlap2D);
9672 if (HasPresolveInclusionWorkLimit) {
9673 output.WriteRawTag(200, 12);
9674 output.WriteInt64(PresolveInclusionWorkLimit);
9676 if (HasIgnoreNames) {
9677 output.WriteRawTag(208, 12);
9678 output.WriteBool(IgnoreNames);
9680 if (HasShareBinaryClauses) {
9681 output.WriteRawTag(216, 12);
9682 output.WriteBool(ShareBinaryClauses);
9684 if (HasUseShavingInProbingSearch) {
9685 output.WriteRawTag(224, 12);
9686 output.WriteBool(UseShavingInProbingSearch);
9688 if (HasShavingSearchDeterministicTime) {
9689 output.WriteRawTag(233, 12);
9690 output.WriteDouble(ShavingSearchDeterministicTime);
9692 if (HasNumWorkers) {
9693 output.WriteRawTag(240, 12);
9694 output.WriteInt32(NumWorkers);
9696 subsolvers_.WriteTo(output, _repeated_subsolvers_codec);
9697 ignoreSubsolvers_.WriteTo(output, _repeated_ignoreSubsolvers_codec);
9698 subsolverParams_.WriteTo(output, _repeated_subsolverParams_codec);
9699 if (HasUseEnergeticReasoningInNoOverlap2D) {
9700 output.WriteRawTag(168, 13);
9701 output.WriteBool(UseEnergeticReasoningInNoOverlap2D);
9703 if (HasUseDualSchedulingHeuristics) {
9704 output.WriteRawTag(176, 13);
9705 output.WriteBool(UseDualSchedulingHeuristics);
9707 if (HasUseHardPrecedencesInCumulative) {
9708 output.WriteRawTag(184, 13);
9709 output.WriteBool(UseHardPrecedencesInCumulative);
9711 if (HasDetectTableWithCost) {
9712 output.WriteRawTag(192, 13);
9713 output.WriteBool(DetectTableWithCost);
9715 if (HasTableCompressionLevel) {
9716 output.WriteRawTag(200, 13);
9717 output.WriteInt32(TableCompressionLevel);
9719 extraSubsolvers_.WriteTo(output, _repeated_extraSubsolvers_codec);
9720 if (HasExploitAllPrecedences) {
9721 output.WriteRawTag(224, 13);
9722 output.WriteBool(ExploitAllPrecedences);
9724 if (HasPropagationLoopDetectionFactor) {
9725 output.WriteRawTag(233, 13);
9726 output.WriteDouble(PropagationLoopDetectionFactor);
9728 if (HasOnlySolveIp) {
9729 output.WriteRawTag(240, 13);
9730 output.WriteBool(OnlySolveIp);
9732 if (HasEncodeComplexLinearConstraintWithInteger) {
9733 output.WriteRawTag(248, 13);
9734 output.WriteBool(EncodeComplexLinearConstraintWithInteger);
9736 if (HasNewLinearPropagation) {
9737 output.WriteRawTag(128, 14);
9738 output.WriteBool(NewLinearPropagation);
9740 if (HasMipScaleLargeDomain) {
9741 output.WriteRawTag(136, 14);
9742 output.WriteBool(MipScaleLargeDomain);
9744 if (HasProbingDeterministicTimeLimit) {
9745 output.WriteRawTag(145, 14);
9746 output.WriteDouble(ProbingDeterministicTimeLimit);
9748 if (HasRootLpIterations) {
9749 output.WriteRawTag(152, 14);
9750 output.WriteInt32(RootLpIterations);
9752 if (HasUseObjectiveLbSearch) {
9753 output.WriteRawTag(160, 14);
9754 output.WriteBool(UseObjectiveLbSearch);
9756 if (HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) {
9757 output.WriteRawTag(168, 14);
9758 output.WriteInt32(MaxSizeToCreatePrecedenceLiteralsInDisjunctive);
9760 if (HasUseStrongPropagationInDisjunctive) {
9761 output.WriteRawTag(176, 14);
9762 output.WriteBool(UseStrongPropagationInDisjunctive);
9764 if (HasMipDropTolerance) {
9765 output.WriteRawTag(193, 14);
9766 output.WriteDouble(MipDropTolerance);
9768 if (HasInferAllDiffs) {
9769 output.WriteRawTag(200, 14);
9770 output.WriteBool(InferAllDiffs);
9772 if (HasFindBigLinearOverlap) {
9773 output.WriteRawTag(208, 14);
9774 output.WriteBool(FindBigLinearOverlap);
9776 if (HasSharedTreeNumWorkers) {
9777 output.WriteRawTag(216, 14);
9778 output.WriteInt32(SharedTreeNumWorkers);
9780 if (HasUseSharedTreeSearch) {
9781 output.WriteRawTag(224, 14);
9782 output.WriteBool(UseSharedTreeSearch);
9784 if (HasSharedTreeWorkerObjectiveSplitProbability) {
9785 output.WriteRawTag(233, 14);
9786 output.WriteDouble(SharedTreeWorkerObjectiveSplitProbability);
9788 if (HasSharedTreeMaxNodesPerWorker) {
9789 output.WriteRawTag(240, 14);
9790 output.WriteInt32(SharedTreeMaxNodesPerWorker);
9792 if (HasSharedTreeSplitStrategy) {
9793 output.WriteRawTag(248, 14);
9794 output.WriteEnum((
int) SharedTreeSplitStrategy);
9797 output.WriteRawTag(128, 15);
9798 output.WriteBool(UseLsOnly);
9800 if (HasFeasibilityJumpDecay) {
9801 output.WriteRawTag(145, 15);
9802 output.WriteDouble(FeasibilityJumpDecay);
9804 if (HasNumViolationLs) {
9805 output.WriteRawTag(160, 15);
9806 output.WriteInt32(NumViolationLs);
9808 if (HasFeasibilityJumpVarRandomizationProbability) {
9809 output.WriteRawTag(185, 15);
9810 output.WriteDouble(FeasibilityJumpVarRandomizationProbability);
9812 if (HasFeasibilityJumpVarPerburbationRangeRatio) {
9813 output.WriteRawTag(193, 15);
9814 output.WriteDouble(FeasibilityJumpVarPerburbationRangeRatio);
9816 if (HasViolationLsPerturbationPeriod) {
9817 output.WriteRawTag(200, 15);
9818 output.WriteInt32(ViolationLsPerturbationPeriod);
9820 if (HasFeasibilityJumpEnableRestarts) {
9821 output.WriteRawTag(208, 15);
9822 output.WriteBool(FeasibilityJumpEnableRestarts);
9824 if (HasStopAfterRootPropagation) {
9825 output.WriteRawTag(224, 15);
9826 output.WriteBool(StopAfterRootPropagation);
9828 if (HasUseObjectiveShavingSearch) {
9829 output.WriteRawTag(232, 15);
9830 output.WriteBool(UseObjectiveShavingSearch);
9832 if (HasUseLbRelaxLns) {
9833 output.WriteRawTag(248, 15);
9834 output.WriteBool(UseLbRelaxLns);
9836 if (HasLinearSplitSize) {
9837 output.WriteRawTag(128, 16);
9838 output.WriteInt32(LinearSplitSize);
9840 if (HasFeasibilityJumpLinearizationLevel) {
9841 output.WriteRawTag(136, 16);
9842 output.WriteInt32(FeasibilityJumpLinearizationLevel);
9844 if (HasFeasibilityJumpRestartFactor) {
9845 output.WriteRawTag(144, 16);
9846 output.WriteInt32(FeasibilityJumpRestartFactor);
9848 if (HasViolationLsCompoundMoveProbability) {
9849 output.WriteRawTag(153, 16);
9850 output.WriteDouble(ViolationLsCompoundMoveProbability);
9852 if (HasMaxNumIntervalsForTimetableEdgeFinding) {
9853 output.WriteRawTag(160, 16);
9854 output.WriteInt32(MaxNumIntervalsForTimetableEdgeFinding);
9856 if (HasMipPresolveLevel) {
9857 output.WriteRawTag(168, 16);
9858 output.WriteInt32(MipPresolveLevel);
9860 if (HasPushAllTasksTowardStart) {
9861 output.WriteRawTag(176, 16);
9862 output.WriteBool(PushAllTasksTowardStart);
9864 if (HasUseDynamicPrecedenceInDisjunctive) {
9865 output.WriteRawTag(184, 16);
9866 output.WriteBool(UseDynamicPrecedenceInDisjunctive);
9868 if (HasFeasibilityJumpMaxExpandedConstraintSize) {
9869 output.WriteRawTag(192, 16);
9870 output.WriteInt32(FeasibilityJumpMaxExpandedConstraintSize);
9872 if (HasUseFeasibilityJump) {
9873 output.WriteRawTag(200, 16);
9874 output.WriteBool(UseFeasibilityJump);
9876 if (HasLpPrimalTolerance) {
9877 output.WriteRawTag(209, 16);
9878 output.WriteDouble(LpPrimalTolerance);
9880 if (HasLpDualTolerance) {
9881 output.WriteRawTag(217, 16);
9882 output.WriteDouble(LpDualTolerance);
9884 if (HasUseDynamicPrecedenceInCumulative) {
9885 output.WriteRawTag(224, 16);
9886 output.WriteBool(UseDynamicPrecedenceInCumulative);
9888 if (HasUseExtendedProbing) {
9889 output.WriteRawTag(232, 16);
9890 output.WriteBool(UseExtendedProbing);
9892 if (HasAtMostOneMaxExpansionSize) {
9893 output.WriteRawTag(240, 16);
9894 output.WriteInt32(AtMostOneMaxExpansionSize);
9896 if (HasUseAreaEnergeticReasoningInNoOverlap2D) {
9897 output.WriteRawTag(248, 16);
9898 output.WriteBool(UseAreaEnergeticReasoningInNoOverlap2D);
9900 if (HasProbingNumCombinationsLimit) {
9901 output.WriteRawTag(128, 17);
9902 output.WriteInt32(ProbingNumCombinationsLimit);
9904 if (HasInprocessingDtimeRatio) {
9905 output.WriteRawTag(137, 17);
9906 output.WriteDouble(InprocessingDtimeRatio);
9908 if (HasInprocessingProbingDtime) {
9909 output.WriteRawTag(145, 17);
9910 output.WriteDouble(InprocessingProbingDtime);
9912 if (HasInprocessingMinimizationDtime) {
9913 output.WriteRawTag(153, 17);
9914 output.WriteDouble(InprocessingMinimizationDtime);
9916 if (HasMaxPairsPairwiseReasoningInNoOverlap2D) {
9917 output.WriteRawTag(160, 17);
9918 output.WriteInt32(MaxPairsPairwiseReasoningInNoOverlap2D);
9920 if (HasDetectLinearizedProduct) {
9921 output.WriteRawTag(168, 17);
9922 output.WriteBool(DetectLinearizedProduct);
9924 if (HasMipTreatHighMagnitudeBoundsAsInfinity) {
9925 output.WriteRawTag(176, 17);
9926 output.WriteBool(MipTreatHighMagnitudeBoundsAsInfinity);
9928 if (HasAddRltCuts) {
9929 output.WriteRawTag(184, 17);
9930 output.WriteBool(AddRltCuts);
9932 if (HasMaxLinMaxSizeForExpansion) {
9933 output.WriteRawTag(192, 17);
9934 output.WriteInt32(MaxLinMaxSizeForExpansion);
9936 if (HasSharedTreeOpenLeavesPerWorker) {
9937 output.WriteRawTag(201, 17);
9938 output.WriteDouble(SharedTreeOpenLeavesPerWorker);
9940 if (HasSharedTreeWorkerMinRestartsPerSubtree) {
9941 output.WriteRawTag(208, 17);
9942 output.WriteInt32(SharedTreeWorkerMinRestartsPerSubtree);
9945 output.WriteRawTag(216, 17);
9946 output.WriteBool(UseLns);
9948 if (HasSaveLpBasisInLbTreeSearch) {
9949 output.WriteRawTag(224, 17);
9950 output.WriteBool(SaveLpBasisInLbTreeSearch);
9952 if (HasShareGlueClauses) {
9953 output.WriteRawTag(232, 17);
9954 output.WriteBool(ShareGlueClauses);
9956 if (HasUseConservativeScaleOverloadChecker) {
9957 output.WriteRawTag(240, 17);
9958 output.WriteBool(UseConservativeScaleOverloadChecker);
9960 if (HasEncodeCumulativeAsReservoir) {
9961 output.WriteRawTag(248, 17);
9962 output.WriteBool(EncodeCumulativeAsReservoir);
9964 if (HasExpandReservoirUsingCircuit) {
9965 output.WriteRawTag(128, 18);
9966 output.WriteBool(ExpandReservoirUsingCircuit);
9968 if (HasUseVariablesShavingSearch) {
9969 output.WriteRawTag(136, 18);
9970 output.WriteBool(UseVariablesShavingSearch);
9972 if (HasShavingSearchThreshold) {
9973 output.WriteRawTag(144, 18);
9974 output.WriteInt64(ShavingSearchThreshold);
9976 if (HasMaxNumDeterministicBatches) {
9977 output.WriteRawTag(152, 18);
9978 output.WriteInt32(MaxNumDeterministicBatches);
9980 if (HasFeasibilityJumpBatchDtime) {
9981 output.WriteRawTag(161, 18);
9982 output.WriteDouble(FeasibilityJumpBatchDtime);
9984 filterSubsolvers_.WriteTo(output, _repeated_filterSubsolvers_codec);
9985 if (HasNumFullSubsolvers) {
9986 output.WriteRawTag(176, 18);
9987 output.WriteInt32(NumFullSubsolvers);
9989 if (HasSharedTreeWorkerEnableTrailSharing) {
9990 output.WriteRawTag(184, 18);
9991 output.WriteBool(SharedTreeWorkerEnableTrailSharing);
9993 if (_unknownFields !=
null) {
9994 _unknownFields.WriteTo(output);
9999 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
10000 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10001 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10002 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
10003 if (HasPreferredVariableOrder) {
10004 output.WriteRawTag(8);
10005 output.WriteEnum((
int) PreferredVariableOrder);
10007 if (HasInitialPolarity) {
10008 output.WriteRawTag(16);
10009 output.WriteEnum((
int) InitialPolarity);
10011 if (HasMinimizationAlgorithm) {
10012 output.WriteRawTag(32);
10013 output.WriteEnum((
int) MinimizationAlgorithm);
10015 if (HasClauseCleanupPeriod) {
10016 output.WriteRawTag(88);
10017 output.WriteInt32(ClauseCleanupPeriod);
10019 if (HasClauseCleanupTarget) {
10020 output.WriteRawTag(104);
10021 output.WriteInt32(ClauseCleanupTarget);
10023 if (HasVariableActivityDecay) {
10024 output.WriteRawTag(121);
10025 output.WriteDouble(VariableActivityDecay);
10027 if (HasMaxVariableActivityValue) {
10028 output.WriteRawTag(129, 1);
10029 output.WriteDouble(MaxVariableActivityValue);
10031 if (HasClauseActivityDecay) {
10032 output.WriteRawTag(137, 1);
10033 output.WriteDouble(ClauseActivityDecay);
10035 if (HasMaxClauseActivityValue) {
10036 output.WriteRawTag(145, 1);
10037 output.WriteDouble(MaxClauseActivityValue);
10039 if (HasGlucoseMaxDecay) {
10040 output.WriteRawTag(177, 1);
10041 output.WriteDouble(GlucoseMaxDecay);
10043 if (HasGlucoseDecayIncrement) {
10044 output.WriteRawTag(185, 1);
10045 output.WriteDouble(GlucoseDecayIncrement);
10047 if (HasGlucoseDecayIncrementPeriod) {
10048 output.WriteRawTag(192, 1);
10049 output.WriteInt32(GlucoseDecayIncrementPeriod);
10051 if (HasRestartPeriod) {
10052 output.WriteRawTag(240, 1);
10053 output.WriteInt32(RestartPeriod);
10055 if (HasRandomSeed) {
10056 output.WriteRawTag(248, 1);
10057 output.WriteInt32(RandomSeed);
10059 if (HasRandomBranchesRatio) {
10060 output.WriteRawTag(129, 2);
10061 output.WriteDouble(RandomBranchesRatio);
10063 if (HasBinaryMinimizationAlgorithm) {
10064 output.WriteRawTag(144, 2);
10065 output.WriteEnum((
int) BinaryMinimizationAlgorithm);
10067 if (HasUseOptimizationHints) {
10068 output.WriteRawTag(152, 2);
10069 output.WriteBool(UseOptimizationHints);
10071 if (HasMaxTimeInSeconds) {
10072 output.WriteRawTag(161, 2);
10073 output.WriteDouble(MaxTimeInSeconds);
10075 if (HasMaxNumberOfConflicts) {
10076 output.WriteRawTag(168, 2);
10077 output.WriteInt64(MaxNumberOfConflicts);
10079 if (HasMaxMemoryInMb) {
10080 output.WriteRawTag(192, 2);
10081 output.WriteInt64(MaxMemoryInMb);
10083 if (HasLogSearchProgress) {
10084 output.WriteRawTag(200, 2);
10085 output.WriteBool(LogSearchProgress);
10087 if (HasUsePbResolution) {
10088 output.WriteRawTag(216, 2);
10089 output.WriteBool(UsePbResolution);
10091 if (HasUsePhaseSaving) {
10092 output.WriteRawTag(224, 2);
10093 output.WriteBool(UsePhaseSaving);
10095 if (HasRandomPolarityRatio) {
10096 output.WriteRawTag(233, 2);
10097 output.WriteDouble(RandomPolarityRatio);
10099 if (HasPbCleanupIncrement) {
10100 output.WriteRawTag(240, 2);
10101 output.WriteInt32(PbCleanupIncrement);
10103 if (HasPbCleanupRatio) {
10104 output.WriteRawTag(249, 2);
10105 output.WriteDouble(PbCleanupRatio);
10107 if (HasMinimizeReductionDuringPbResolution) {
10108 output.WriteRawTag(128, 3);
10109 output.WriteBool(MinimizeReductionDuringPbResolution);
10111 if (HasCountAssumptionLevelsInLbd) {
10112 output.WriteRawTag(136, 3);
10113 output.WriteBool(CountAssumptionLevelsInLbd);
10115 if (HasCoreMinimizationLevel) {
10116 output.WriteRawTag(144, 3);
10117 output.WriteInt32(CoreMinimizationLevel);
10119 if (HasMaxSatAssumptionOrder) {
10120 output.WriteRawTag(152, 3);
10121 output.WriteEnum((
int) MaxSatAssumptionOrder);
10123 if (HasMaxSatReverseAssumptionOrder) {
10124 output.WriteRawTag(160, 3);
10125 output.WriteBool(MaxSatReverseAssumptionOrder);
10127 if (HasMaxSatStratification) {
10128 output.WriteRawTag(168, 3);
10129 output.WriteEnum((
int) MaxSatStratification);
10131 if (HasPresolveBveThreshold) {
10132 output.WriteRawTag(176, 3);
10133 output.WriteInt32(PresolveBveThreshold);
10135 if (HasPresolveBveClauseWeight) {
10136 output.WriteRawTag(184, 3);
10137 output.WriteInt32(PresolveBveClauseWeight);
10139 if (HasSubsumptionDuringConflictAnalysis) {
10140 output.WriteRawTag(192, 3);
10141 output.WriteBool(SubsumptionDuringConflictAnalysis);
10143 if (HasPresolveProbingDeterministicTimeLimit) {
10144 output.WriteRawTag(201, 3);
10145 output.WriteDouble(PresolveProbingDeterministicTimeLimit);
10147 if (HasClauseCleanupProtection) {
10148 output.WriteRawTag(208, 3);
10149 output.WriteEnum((
int) ClauseCleanupProtection);
10151 if (HasClauseCleanupLbdBound) {
10152 output.WriteRawTag(216, 3);
10153 output.WriteInt32(ClauseCleanupLbdBound);
10155 if (HasClauseCleanupOrdering) {
10156 output.WriteRawTag(224, 3);
10157 output.WriteEnum((
int) ClauseCleanupOrdering);
10159 restartAlgorithms_.WriteTo(ref output, _repeated_restartAlgorithms_codec);
10160 if (HasRestartRunningWindowSize) {
10161 output.WriteRawTag(240, 3);
10162 output.WriteInt32(RestartRunningWindowSize);
10164 if (HasRestartDlAverageRatio) {
10165 output.WriteRawTag(249, 3);
10166 output.WriteDouble(RestartDlAverageRatio);
10168 if (HasUseBlockingRestart) {
10169 output.WriteRawTag(128, 4);
10170 output.WriteBool(UseBlockingRestart);
10172 if (HasBlockingRestartWindowSize) {
10173 output.WriteRawTag(136, 4);
10174 output.WriteInt32(BlockingRestartWindowSize);
10176 if (HasBlockingRestartMultiplier) {
10177 output.WriteRawTag(145, 4);
10178 output.WriteDouble(BlockingRestartMultiplier);
10180 if (HasMaxDeterministicTime) {
10181 output.WriteRawTag(153, 4);
10182 output.WriteDouble(MaxDeterministicTime);
10184 if (HasNumConflictsBeforeStrategyChanges) {
10185 output.WriteRawTag(160, 4);
10186 output.WriteInt32(NumConflictsBeforeStrategyChanges);
10188 if (HasStrategyChangeIncreaseRatio) {
10189 output.WriteRawTag(169, 4);
10190 output.WriteDouble(StrategyChangeIncreaseRatio);
10192 if (HasDefaultRestartAlgorithms) {
10193 output.WriteRawTag(178, 4);
10194 output.WriteString(DefaultRestartAlgorithms);
10196 if (HasRestartLbdAverageRatio) {
10197 output.WriteRawTag(185, 4);
10198 output.WriteDouble(RestartLbdAverageRatio);
10200 if (HasPresolveUseBva) {
10201 output.WriteRawTag(192, 4);
10202 output.WriteBool(PresolveUseBva);
10204 if (HasPresolveBvaThreshold) {
10205 output.WriteRawTag(200, 4);
10206 output.WriteInt32(PresolveBvaThreshold);
10208 if (HasUsePrecedencesInDisjunctiveConstraint) {
10209 output.WriteRawTag(208, 4);
10210 output.WriteBool(UsePrecedencesInDisjunctiveConstraint);
10212 if (HasUseErwaHeuristic) {
10213 output.WriteRawTag(216, 4);
10214 output.WriteBool(UseErwaHeuristic);
10216 if (HasInitialVariablesActivity) {
10217 output.WriteRawTag(225, 4);
10218 output.WriteDouble(InitialVariablesActivity);
10220 if (HasAlsoBumpVariablesInConflictReasons) {
10221 output.WriteRawTag(232, 4);
10222 output.WriteBool(AlsoBumpVariablesInConflictReasons);
10224 if (HasUseOverloadCheckerInCumulative) {
10225 output.WriteRawTag(240, 4);
10226 output.WriteBool(UseOverloadCheckerInCumulative);
10228 if (HasUseTimetableEdgeFindingInCumulative) {
10229 output.WriteRawTag(248, 4);
10230 output.WriteBool(UseTimetableEdgeFindingInCumulative);
10232 if (HasUseDisjunctiveConstraintInCumulative) {
10233 output.WriteRawTag(128, 5);
10234 output.WriteBool(UseDisjunctiveConstraintInCumulative);
10236 if (HasSearchBranching) {
10237 output.WriteRawTag(144, 5);
10238 output.WriteEnum((
int) SearchBranching);
10240 if (HasOptimizeWithCore) {
10241 output.WriteRawTag(152, 5);
10242 output.WriteBool(OptimizeWithCore);
10244 if (HasFindMultipleCores) {
10245 output.WriteRawTag(160, 5);
10246 output.WriteBool(FindMultipleCores);
10248 if (HasOptimizeWithMaxHs) {
10249 output.WriteRawTag(168, 5);
10250 output.WriteBool(OptimizeWithMaxHs);
10252 if (HasCpModelPresolve) {
10253 output.WriteRawTag(176, 5);
10254 output.WriteBool(CpModelPresolve);
10256 if (HasEnumerateAllSolutions) {
10257 output.WriteRawTag(184, 5);
10258 output.WriteBool(EnumerateAllSolutions);
10260 if (HasPresolveBlockedClause) {
10261 output.WriteRawTag(192, 5);
10262 output.WriteBool(PresolveBlockedClause);
10264 if (HasCoverOptimization) {
10265 output.WriteRawTag(200, 5);
10266 output.WriteBool(CoverOptimization);
10268 if (HasLinearizationLevel) {
10269 output.WriteRawTag(208, 5);
10270 output.WriteInt32(LinearizationLevel);
10272 if (HasMaxNumCuts) {
10273 output.WriteRawTag(216, 5);
10274 output.WriteInt32(MaxNumCuts);
10276 if (HasOnlyAddCutsAtLevelZero) {
10277 output.WriteRawTag(224, 5);
10278 output.WriteBool(OnlyAddCutsAtLevelZero);
10280 if (HasCpModelUseSatPresolve) {
10281 output.WriteRawTag(232, 5);
10282 output.WriteBool(CpModelUseSatPresolve);
10284 if (HasExploitIntegerLpSolution) {
10285 output.WriteRawTag(240, 5);
10286 output.WriteBool(ExploitIntegerLpSolution);
10288 if (HasAutoDetectGreaterThanAtLeastOneOf) {
10289 output.WriteRawTag(248, 5);
10290 output.WriteBool(AutoDetectGreaterThanAtLeastOneOf);
10292 if (HasStopAfterFirstSolution) {
10293 output.WriteRawTag(144, 6);
10294 output.WriteBool(StopAfterFirstSolution);
10296 if (HasBinarySearchNumConflicts) {
10297 output.WriteRawTag(152, 6);
10298 output.WriteInt32(BinarySearchNumConflicts);
10300 if (HasNumSearchWorkers) {
10301 output.WriteRawTag(160, 6);
10302 output.WriteInt32(NumSearchWorkers);
10304 if (HasUseLnsOnly) {
10305 output.WriteRawTag(168, 6);
10306 output.WriteBool(UseLnsOnly);
10308 if (HasRandomizeSearch) {
10309 output.WriteRawTag(184, 6);
10310 output.WriteBool(RandomizeSearch);
10312 if (HasSearchRandomVariablePoolSize) {
10313 output.WriteRawTag(192, 6);
10314 output.WriteInt64(SearchRandomVariablePoolSize);
10316 if (HasInstantiateAllVariables) {
10317 output.WriteRawTag(208, 6);
10318 output.WriteBool(InstantiateAllVariables);
10320 if (HasBooleanEncodingLevel) {
10321 output.WriteRawTag(216, 6);
10322 output.WriteInt32(BooleanEncodingLevel);
10324 if (HasUseOptionalVariables) {
10325 output.WriteRawTag(224, 6);
10326 output.WriteBool(UseOptionalVariables);
10328 if (HasUseExactLpReason) {
10329 output.WriteRawTag(232, 6);
10330 output.WriteBool(UseExactLpReason);
10332 if (HasCpModelProbingLevel) {
10333 output.WriteRawTag(240, 6);
10334 output.WriteInt32(CpModelProbingLevel);
10336 if (HasAddLpConstraintsLazily) {
10337 output.WriteRawTag(128, 7);
10338 output.WriteBool(AddLpConstraintsLazily);
10340 if (HasShareObjectiveBounds) {
10341 output.WriteRawTag(136, 7);
10342 output.WriteBool(ShareObjectiveBounds);
10344 if (HasShareLevelZeroBounds) {
10345 output.WriteRawTag(144, 7);
10346 output.WriteBool(ShareLevelZeroBounds);
10348 if (HasMinOrthogonalityForLpConstraints) {
10349 output.WriteRawTag(153, 7);
10350 output.WriteDouble(MinOrthogonalityForLpConstraints);
10352 if (HasExploitAllLpSolution) {
10353 output.WriteRawTag(160, 7);
10354 output.WriteBool(ExploitAllLpSolution);
10356 if (HasAddCgCuts) {
10357 output.WriteRawTag(168, 7);
10358 output.WriteBool(AddCgCuts);
10360 if (HasMaxIntegerRoundingScaling) {
10361 output.WriteRawTag(184, 7);
10362 output.WriteInt32(MaxIntegerRoundingScaling);
10364 if (HasAddMirCuts) {
10365 output.WriteRawTag(192, 7);
10366 output.WriteBool(AddMirCuts);
10368 if (HasMaxConsecutiveInactiveCount) {
10369 output.WriteRawTag(200, 7);
10370 output.WriteInt32(MaxConsecutiveInactiveCount);
10372 if (HasNewConstraintsBatchSize) {
10373 output.WriteRawTag(208, 7);
10374 output.WriteInt32(NewConstraintsBatchSize);
10376 if (HasPseudoCostReliabilityThreshold) {
10377 output.WriteRawTag(216, 7);
10378 output.WriteInt64(PseudoCostReliabilityThreshold);
10380 if (HasMipMaxBound) {
10381 output.WriteRawTag(225, 7);
10382 output.WriteDouble(MipMaxBound);
10384 if (HasMipVarScaling) {
10385 output.WriteRawTag(233, 7);
10386 output.WriteDouble(MipVarScaling);
10388 if (HasMipWantedPrecision) {
10389 output.WriteRawTag(241, 7);
10390 output.WriteDouble(MipWantedPrecision);
10392 if (HasMipMaxActivityExponent) {
10393 output.WriteRawTag(248, 7);
10394 output.WriteInt32(MipMaxActivityExponent);
10396 if (HasMipCheckPrecision) {
10397 output.WriteRawTag(129, 8);
10398 output.WriteDouble(MipCheckPrecision);
10400 if (HasUseRinsLns) {
10401 output.WriteRawTag(136, 8);
10402 output.WriteBool(UseRinsLns);
10404 if (HasExploitBestSolution) {
10405 output.WriteRawTag(144, 8);
10406 output.WriteBool(ExploitBestSolution);
10408 if (HasExploitObjective) {
10409 output.WriteRawTag(152, 8);
10410 output.WriteBool(ExploitObjective);
10412 if (HasFillTightenedDomainsInResponse) {
10413 output.WriteRawTag(160, 8);
10414 output.WriteBool(FillTightenedDomainsInResponse);
10416 if (HasUseCombinedNoOverlap) {
10417 output.WriteRawTag(168, 8);
10418 output.WriteBool(UseCombinedNoOverlap);
10420 if (HasInterleaveBatchSize) {
10421 output.WriteRawTag(176, 8);
10422 output.WriteInt32(InterleaveBatchSize);
10424 if (HasCatchSigintSignal) {
10425 output.WriteRawTag(184, 8);
10426 output.WriteBool(CatchSigintSignal);
10428 if (HasInterleaveSearch) {
10429 output.WriteRawTag(192, 8);
10430 output.WriteBool(InterleaveSearch);
10432 if (HasDiversifyLnsParams) {
10433 output.WriteRawTag(200, 8);
10434 output.WriteBool(DiversifyLnsParams);
10436 if (HasMaxPresolveIterations) {
10437 output.WriteRawTag(208, 8);
10438 output.WriteInt32(MaxPresolveIterations);
10440 if (HasUseImpliedBounds) {
10441 output.WriteRawTag(128, 9);
10442 output.WriteBool(UseImpliedBounds);
10444 if (HasMergeNoOverlapWorkLimit) {
10445 output.WriteRawTag(137, 9);
10446 output.WriteDouble(MergeNoOverlapWorkLimit);
10448 if (HasMergeAtMostOneWorkLimit) {
10449 output.WriteRawTag(145, 9);
10450 output.WriteDouble(MergeAtMostOneWorkLimit);
10452 if (HasPresolveSubstitutionLevel) {
10453 output.WriteRawTag(152, 9);
10454 output.WriteInt32(PresolveSubstitutionLevel);
10456 if (HasMaxAllDiffCutSize) {
10457 output.WriteRawTag(160, 9);
10458 output.WriteInt32(MaxAllDiffCutSize);
10460 if (HasStopAfterPresolve) {
10461 output.WriteRawTag(168, 9);
10462 output.WriteBool(StopAfterPresolve);
10464 if (HasDebugMaxNumPresolveOperations) {
10465 output.WriteRawTag(184, 9);
10466 output.WriteInt32(DebugMaxNumPresolveOperations);
10468 if (HasAddLinMaxCuts) {
10469 output.WriteRawTag(192, 9);
10470 output.WriteBool(AddLinMaxCuts);
10472 if (HasHintConflictLimit) {
10473 output.WriteRawTag(200, 9);
10474 output.WriteInt32(HintConflictLimit);
10476 if (HasMaxCutRoundsAtLevelZero) {
10477 output.WriteRawTag(208, 9);
10478 output.WriteInt32(MaxCutRoundsAtLevelZero);
10480 if (HasCutMaxActiveCountValue) {
10481 output.WriteRawTag(217, 9);
10482 output.WriteDouble(CutMaxActiveCountValue);
10484 if (HasCutActiveCountDecay) {
10485 output.WriteRawTag(225, 9);
10486 output.WriteDouble(CutActiveCountDecay);
10488 if (HasCutCleanupTarget) {
10489 output.WriteRawTag(232, 9);
10490 output.WriteInt32(CutCleanupTarget);
10492 if (HasAbsoluteGapLimit) {
10493 output.WriteRawTag(249, 9);
10494 output.WriteDouble(AbsoluteGapLimit);
10496 if (HasRelativeGapLimit) {
10497 output.WriteRawTag(129, 10);
10498 output.WriteDouble(RelativeGapLimit);
10500 if (HasExploitRelaxationSolution) {
10501 output.WriteRawTag(136, 10);
10502 output.WriteBool(ExploitRelaxationSolution);
10504 if (HasDebugPostsolveWithFullSolver) {
10505 output.WriteRawTag(144, 10);
10506 output.WriteBool(DebugPostsolveWithFullSolver);
10508 if (HasUseSatInprocessing) {
10509 output.WriteRawTag(152, 10);
10510 output.WriteBool(UseSatInprocessing);
10512 if (HasUseFeasibilityPump) {
10513 output.WriteRawTag(160, 10);
10514 output.WriteBool(UseFeasibilityPump);
10516 if (HasFpRounding) {
10517 output.WriteRawTag(168, 10);
10518 output.WriteEnum((
int) FpRounding);
10520 if (HasMipAutomaticallyScaleVariables) {
10521 output.WriteRawTag(176, 10);
10522 output.WriteBool(MipAutomaticallyScaleVariables);
10524 if (HasRepairHint) {
10525 output.WriteRawTag(184, 10);
10526 output.WriteBool(RepairHint);
10528 if (HasPolarityRephaseIncrement) {
10529 output.WriteRawTag(192, 10);
10530 output.WriteInt32(PolarityRephaseIncrement);
10532 if (HasAddZeroHalfCuts) {
10533 output.WriteRawTag(200, 10);
10534 output.WriteBool(AddZeroHalfCuts);
10536 if (HasExpandAlldiffConstraints) {
10537 output.WriteRawTag(208, 10);
10538 output.WriteBool(ExpandAlldiffConstraints);
10541 output.WriteRawTag(218, 10);
10542 output.WriteString(Name);
10544 if (HasAddCliqueCuts) {
10545 output.WriteRawTag(224, 10);
10546 output.WriteBool(AddCliqueCuts);
10548 if (HasKeepAllFeasibleSolutionsInPresolve) {
10549 output.WriteRawTag(232, 10);
10550 output.WriteBool(KeepAllFeasibleSolutionsInPresolve);
10552 if (HasPresolveExtractIntegerEnforcement) {
10553 output.WriteRawTag(240, 10);
10554 output.WriteBool(PresolveExtractIntegerEnforcement);
10556 if (HasPolishLpSolution) {
10557 output.WriteRawTag(248, 10);
10558 output.WriteBool(PolishLpSolution);
10560 if (HasUseProbingSearch) {
10561 output.WriteRawTag(128, 11);
10562 output.WriteBool(UseProbingSearch);
10564 if (HasConvertIntervals) {
10565 output.WriteRawTag(136, 11);
10566 output.WriteBool(ConvertIntervals);
10568 if (HasPermuteVariableRandomly) {
10569 output.WriteRawTag(144, 11);
10570 output.WriteBool(PermuteVariableRandomly);
10572 if (HasPermutePresolveConstraintOrder) {
10573 output.WriteRawTag(152, 11);
10574 output.WriteBool(PermutePresolveConstraintOrder);
10576 if (HasUseAbslRandom) {
10577 output.WriteRawTag(160, 11);
10578 output.WriteBool(UseAbslRandom);
10580 if (HasDisableConstraintExpansion) {
10581 output.WriteRawTag(168, 11);
10582 output.WriteBool(DisableConstraintExpansion);
10584 if (HasExpandReservoirConstraints) {
10585 output.WriteRawTag(176, 11);
10586 output.WriteBool(ExpandReservoirConstraints);
10588 if (HasSymmetryLevel) {
10589 output.WriteRawTag(184, 11);
10590 output.WriteInt32(SymmetryLevel);
10592 if (HasLogPrefix) {
10593 output.WriteRawTag(202, 11);
10594 output.WriteString(LogPrefix);
10596 if (HasLogToStdout) {
10597 output.WriteRawTag(208, 11);
10598 output.WriteBool(LogToStdout);
10600 if (HasLogToResponse) {
10601 output.WriteRawTag(216, 11);
10602 output.WriteBool(LogToResponse);
10604 if (HasOptimizeWithLbTreeSearch) {
10605 output.WriteRawTag(224, 11);
10606 output.WriteBool(OptimizeWithLbTreeSearch);
10608 if (HasLogSubsolverStatistics) {
10609 output.WriteRawTag(232, 11);
10610 output.WriteBool(LogSubsolverStatistics);
10612 if (HasClauseCleanupRatio) {
10613 output.WriteRawTag(241, 11);
10614 output.WriteDouble(ClauseCleanupRatio);
10616 if (HasMaxDomainSizeWhenEncodingEqNeqConstraints) {
10617 output.WriteRawTag(248, 11);
10618 output.WriteInt32(MaxDomainSizeWhenEncodingEqNeqConstraints);
10620 if (HasFixVariablesToTheirHintedValue) {
10621 output.WriteRawTag(128, 12);
10622 output.WriteBool(FixVariablesToTheirHintedValue);
10624 if (HasSolutionPoolSize) {
10625 output.WriteRawTag(136, 12);
10626 output.WriteInt32(SolutionPoolSize);
10628 if (HasFillAdditionalSolutionsInResponse) {
10629 output.WriteRawTag(144, 12);
10630 output.WriteBool(FillAdditionalSolutionsInResponse);
10632 if (HasDebugCrashOnBadHint) {
10633 output.WriteRawTag(152, 12);
10634 output.WriteBool(DebugCrashOnBadHint);
10637 output.WriteRawTag(160, 12);
10638 output.WriteInt32(CutLevel);
10640 if (HasAddObjectiveCut) {
10641 output.WriteRawTag(168, 12);
10642 output.WriteBool(AddObjectiveCut);
10644 if (HasMipComputeTrueObjectiveBound) {
10645 output.WriteRawTag(176, 12);
10646 output.WriteBool(MipComputeTrueObjectiveBound);
10648 if (HasMipMaxValidMagnitude) {
10649 output.WriteRawTag(185, 12);
10650 output.WriteDouble(MipMaxValidMagnitude);
10652 if (HasUseTimetablingInNoOverlap2D) {
10653 output.WriteRawTag(192, 12);
10654 output.WriteBool(UseTimetablingInNoOverlap2D);
10656 if (HasPresolveInclusionWorkLimit) {
10657 output.WriteRawTag(200, 12);
10658 output.WriteInt64(PresolveInclusionWorkLimit);
10660 if (HasIgnoreNames) {
10661 output.WriteRawTag(208, 12);
10662 output.WriteBool(IgnoreNames);
10664 if (HasShareBinaryClauses) {
10665 output.WriteRawTag(216, 12);
10666 output.WriteBool(ShareBinaryClauses);
10668 if (HasUseShavingInProbingSearch) {
10669 output.WriteRawTag(224, 12);
10670 output.WriteBool(UseShavingInProbingSearch);
10672 if (HasShavingSearchDeterministicTime) {
10673 output.WriteRawTag(233, 12);
10674 output.WriteDouble(ShavingSearchDeterministicTime);
10676 if (HasNumWorkers) {
10677 output.WriteRawTag(240, 12);
10678 output.WriteInt32(NumWorkers);
10680 subsolvers_.WriteTo(ref output, _repeated_subsolvers_codec);
10681 ignoreSubsolvers_.WriteTo(ref output, _repeated_ignoreSubsolvers_codec);
10682 subsolverParams_.WriteTo(ref output, _repeated_subsolverParams_codec);
10683 if (HasUseEnergeticReasoningInNoOverlap2D) {
10684 output.WriteRawTag(168, 13);
10685 output.WriteBool(UseEnergeticReasoningInNoOverlap2D);
10687 if (HasUseDualSchedulingHeuristics) {
10688 output.WriteRawTag(176, 13);
10689 output.WriteBool(UseDualSchedulingHeuristics);
10691 if (HasUseHardPrecedencesInCumulative) {
10692 output.WriteRawTag(184, 13);
10693 output.WriteBool(UseHardPrecedencesInCumulative);
10695 if (HasDetectTableWithCost) {
10696 output.WriteRawTag(192, 13);
10697 output.WriteBool(DetectTableWithCost);
10699 if (HasTableCompressionLevel) {
10700 output.WriteRawTag(200, 13);
10701 output.WriteInt32(TableCompressionLevel);
10703 extraSubsolvers_.WriteTo(ref output, _repeated_extraSubsolvers_codec);
10704 if (HasExploitAllPrecedences) {
10705 output.WriteRawTag(224, 13);
10706 output.WriteBool(ExploitAllPrecedences);
10708 if (HasPropagationLoopDetectionFactor) {
10709 output.WriteRawTag(233, 13);
10710 output.WriteDouble(PropagationLoopDetectionFactor);
10712 if (HasOnlySolveIp) {
10713 output.WriteRawTag(240, 13);
10714 output.WriteBool(OnlySolveIp);
10716 if (HasEncodeComplexLinearConstraintWithInteger) {
10717 output.WriteRawTag(248, 13);
10718 output.WriteBool(EncodeComplexLinearConstraintWithInteger);
10720 if (HasNewLinearPropagation) {
10721 output.WriteRawTag(128, 14);
10722 output.WriteBool(NewLinearPropagation);
10724 if (HasMipScaleLargeDomain) {
10725 output.WriteRawTag(136, 14);
10726 output.WriteBool(MipScaleLargeDomain);
10728 if (HasProbingDeterministicTimeLimit) {
10729 output.WriteRawTag(145, 14);
10730 output.WriteDouble(ProbingDeterministicTimeLimit);
10732 if (HasRootLpIterations) {
10733 output.WriteRawTag(152, 14);
10734 output.WriteInt32(RootLpIterations);
10736 if (HasUseObjectiveLbSearch) {
10737 output.WriteRawTag(160, 14);
10738 output.WriteBool(UseObjectiveLbSearch);
10740 if (HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) {
10741 output.WriteRawTag(168, 14);
10742 output.WriteInt32(MaxSizeToCreatePrecedenceLiteralsInDisjunctive);
10744 if (HasUseStrongPropagationInDisjunctive) {
10745 output.WriteRawTag(176, 14);
10746 output.WriteBool(UseStrongPropagationInDisjunctive);
10748 if (HasMipDropTolerance) {
10749 output.WriteRawTag(193, 14);
10750 output.WriteDouble(MipDropTolerance);
10752 if (HasInferAllDiffs) {
10753 output.WriteRawTag(200, 14);
10754 output.WriteBool(InferAllDiffs);
10756 if (HasFindBigLinearOverlap) {
10757 output.WriteRawTag(208, 14);
10758 output.WriteBool(FindBigLinearOverlap);
10760 if (HasSharedTreeNumWorkers) {
10761 output.WriteRawTag(216, 14);
10762 output.WriteInt32(SharedTreeNumWorkers);
10764 if (HasUseSharedTreeSearch) {
10765 output.WriteRawTag(224, 14);
10766 output.WriteBool(UseSharedTreeSearch);
10768 if (HasSharedTreeWorkerObjectiveSplitProbability) {
10769 output.WriteRawTag(233, 14);
10770 output.WriteDouble(SharedTreeWorkerObjectiveSplitProbability);
10772 if (HasSharedTreeMaxNodesPerWorker) {
10773 output.WriteRawTag(240, 14);
10774 output.WriteInt32(SharedTreeMaxNodesPerWorker);
10776 if (HasSharedTreeSplitStrategy) {
10777 output.WriteRawTag(248, 14);
10778 output.WriteEnum((
int) SharedTreeSplitStrategy);
10780 if (HasUseLsOnly) {
10781 output.WriteRawTag(128, 15);
10782 output.WriteBool(UseLsOnly);
10784 if (HasFeasibilityJumpDecay) {
10785 output.WriteRawTag(145, 15);
10786 output.WriteDouble(FeasibilityJumpDecay);
10788 if (HasNumViolationLs) {
10789 output.WriteRawTag(160, 15);
10790 output.WriteInt32(NumViolationLs);
10792 if (HasFeasibilityJumpVarRandomizationProbability) {
10793 output.WriteRawTag(185, 15);
10794 output.WriteDouble(FeasibilityJumpVarRandomizationProbability);
10796 if (HasFeasibilityJumpVarPerburbationRangeRatio) {
10797 output.WriteRawTag(193, 15);
10798 output.WriteDouble(FeasibilityJumpVarPerburbationRangeRatio);
10800 if (HasViolationLsPerturbationPeriod) {
10801 output.WriteRawTag(200, 15);
10802 output.WriteInt32(ViolationLsPerturbationPeriod);
10804 if (HasFeasibilityJumpEnableRestarts) {
10805 output.WriteRawTag(208, 15);
10806 output.WriteBool(FeasibilityJumpEnableRestarts);
10808 if (HasStopAfterRootPropagation) {
10809 output.WriteRawTag(224, 15);
10810 output.WriteBool(StopAfterRootPropagation);
10812 if (HasUseObjectiveShavingSearch) {
10813 output.WriteRawTag(232, 15);
10814 output.WriteBool(UseObjectiveShavingSearch);
10816 if (HasUseLbRelaxLns) {
10817 output.WriteRawTag(248, 15);
10818 output.WriteBool(UseLbRelaxLns);
10820 if (HasLinearSplitSize) {
10821 output.WriteRawTag(128, 16);
10822 output.WriteInt32(LinearSplitSize);
10824 if (HasFeasibilityJumpLinearizationLevel) {
10825 output.WriteRawTag(136, 16);
10826 output.WriteInt32(FeasibilityJumpLinearizationLevel);
10828 if (HasFeasibilityJumpRestartFactor) {
10829 output.WriteRawTag(144, 16);
10830 output.WriteInt32(FeasibilityJumpRestartFactor);
10832 if (HasViolationLsCompoundMoveProbability) {
10833 output.WriteRawTag(153, 16);
10834 output.WriteDouble(ViolationLsCompoundMoveProbability);
10836 if (HasMaxNumIntervalsForTimetableEdgeFinding) {
10837 output.WriteRawTag(160, 16);
10838 output.WriteInt32(MaxNumIntervalsForTimetableEdgeFinding);
10840 if (HasMipPresolveLevel) {
10841 output.WriteRawTag(168, 16);
10842 output.WriteInt32(MipPresolveLevel);
10844 if (HasPushAllTasksTowardStart) {
10845 output.WriteRawTag(176, 16);
10846 output.WriteBool(PushAllTasksTowardStart);
10848 if (HasUseDynamicPrecedenceInDisjunctive) {
10849 output.WriteRawTag(184, 16);
10850 output.WriteBool(UseDynamicPrecedenceInDisjunctive);
10852 if (HasFeasibilityJumpMaxExpandedConstraintSize) {
10853 output.WriteRawTag(192, 16);
10854 output.WriteInt32(FeasibilityJumpMaxExpandedConstraintSize);
10856 if (HasUseFeasibilityJump) {
10857 output.WriteRawTag(200, 16);
10858 output.WriteBool(UseFeasibilityJump);
10860 if (HasLpPrimalTolerance) {
10861 output.WriteRawTag(209, 16);
10862 output.WriteDouble(LpPrimalTolerance);
10864 if (HasLpDualTolerance) {
10865 output.WriteRawTag(217, 16);
10866 output.WriteDouble(LpDualTolerance);
10868 if (HasUseDynamicPrecedenceInCumulative) {
10869 output.WriteRawTag(224, 16);
10870 output.WriteBool(UseDynamicPrecedenceInCumulative);
10872 if (HasUseExtendedProbing) {
10873 output.WriteRawTag(232, 16);
10874 output.WriteBool(UseExtendedProbing);
10876 if (HasAtMostOneMaxExpansionSize) {
10877 output.WriteRawTag(240, 16);
10878 output.WriteInt32(AtMostOneMaxExpansionSize);
10880 if (HasUseAreaEnergeticReasoningInNoOverlap2D) {
10881 output.WriteRawTag(248, 16);
10882 output.WriteBool(UseAreaEnergeticReasoningInNoOverlap2D);
10884 if (HasProbingNumCombinationsLimit) {
10885 output.WriteRawTag(128, 17);
10886 output.WriteInt32(ProbingNumCombinationsLimit);
10888 if (HasInprocessingDtimeRatio) {
10889 output.WriteRawTag(137, 17);
10890 output.WriteDouble(InprocessingDtimeRatio);
10892 if (HasInprocessingProbingDtime) {
10893 output.WriteRawTag(145, 17);
10894 output.WriteDouble(InprocessingProbingDtime);
10896 if (HasInprocessingMinimizationDtime) {
10897 output.WriteRawTag(153, 17);
10898 output.WriteDouble(InprocessingMinimizationDtime);
10900 if (HasMaxPairsPairwiseReasoningInNoOverlap2D) {
10901 output.WriteRawTag(160, 17);
10902 output.WriteInt32(MaxPairsPairwiseReasoningInNoOverlap2D);
10904 if (HasDetectLinearizedProduct) {
10905 output.WriteRawTag(168, 17);
10906 output.WriteBool(DetectLinearizedProduct);
10908 if (HasMipTreatHighMagnitudeBoundsAsInfinity) {
10909 output.WriteRawTag(176, 17);
10910 output.WriteBool(MipTreatHighMagnitudeBoundsAsInfinity);
10912 if (HasAddRltCuts) {
10913 output.WriteRawTag(184, 17);
10914 output.WriteBool(AddRltCuts);
10916 if (HasMaxLinMaxSizeForExpansion) {
10917 output.WriteRawTag(192, 17);
10918 output.WriteInt32(MaxLinMaxSizeForExpansion);
10920 if (HasSharedTreeOpenLeavesPerWorker) {
10921 output.WriteRawTag(201, 17);
10922 output.WriteDouble(SharedTreeOpenLeavesPerWorker);
10924 if (HasSharedTreeWorkerMinRestartsPerSubtree) {
10925 output.WriteRawTag(208, 17);
10926 output.WriteInt32(SharedTreeWorkerMinRestartsPerSubtree);
10929 output.WriteRawTag(216, 17);
10930 output.WriteBool(UseLns);
10932 if (HasSaveLpBasisInLbTreeSearch) {
10933 output.WriteRawTag(224, 17);
10934 output.WriteBool(SaveLpBasisInLbTreeSearch);
10936 if (HasShareGlueClauses) {
10937 output.WriteRawTag(232, 17);
10938 output.WriteBool(ShareGlueClauses);
10940 if (HasUseConservativeScaleOverloadChecker) {
10941 output.WriteRawTag(240, 17);
10942 output.WriteBool(UseConservativeScaleOverloadChecker);
10944 if (HasEncodeCumulativeAsReservoir) {
10945 output.WriteRawTag(248, 17);
10946 output.WriteBool(EncodeCumulativeAsReservoir);
10948 if (HasExpandReservoirUsingCircuit) {
10949 output.WriteRawTag(128, 18);
10950 output.WriteBool(ExpandReservoirUsingCircuit);
10952 if (HasUseVariablesShavingSearch) {
10953 output.WriteRawTag(136, 18);
10954 output.WriteBool(UseVariablesShavingSearch);
10956 if (HasShavingSearchThreshold) {
10957 output.WriteRawTag(144, 18);
10958 output.WriteInt64(ShavingSearchThreshold);
10960 if (HasMaxNumDeterministicBatches) {
10961 output.WriteRawTag(152, 18);
10962 output.WriteInt32(MaxNumDeterministicBatches);
10964 if (HasFeasibilityJumpBatchDtime) {
10965 output.WriteRawTag(161, 18);
10966 output.WriteDouble(FeasibilityJumpBatchDtime);
10968 filterSubsolvers_.WriteTo(ref output, _repeated_filterSubsolvers_codec);
10969 if (HasNumFullSubsolvers) {
10970 output.WriteRawTag(176, 18);
10971 output.WriteInt32(NumFullSubsolvers);
10973 if (HasSharedTreeWorkerEnableTrailSharing) {
10974 output.WriteRawTag(184, 18);
10975 output.WriteBool(SharedTreeWorkerEnableTrailSharing);
10977 if (_unknownFields !=
null) {
10978 _unknownFields.WriteTo(ref output);
10983 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10984 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10985 public int CalculateSize() {
10988 size += 2 + pb::CodedOutputStream.ComputeStringSize(Name);
10990 if (HasPreferredVariableOrder) {
10991 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) PreferredVariableOrder);
10993 if (HasInitialPolarity) {
10994 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) InitialPolarity);
10996 if (HasUsePhaseSaving) {
10999 if (HasPolarityRephaseIncrement) {
11000 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PolarityRephaseIncrement);
11002 if (HasRandomPolarityRatio) {
11005 if (HasRandomBranchesRatio) {
11008 if (HasUseErwaHeuristic) {
11011 if (HasInitialVariablesActivity) {
11014 if (HasAlsoBumpVariablesInConflictReasons) {
11017 if (HasMinimizationAlgorithm) {
11018 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) MinimizationAlgorithm);
11020 if (HasBinaryMinimizationAlgorithm) {
11021 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) BinaryMinimizationAlgorithm);
11023 if (HasSubsumptionDuringConflictAnalysis) {
11026 if (HasClauseCleanupPeriod) {
11027 size += 1 + pb::CodedOutputStream.ComputeInt32Size(ClauseCleanupPeriod);
11029 if (HasClauseCleanupTarget) {
11030 size += 1 + pb::CodedOutputStream.ComputeInt32Size(ClauseCleanupTarget);
11032 if (HasClauseCleanupRatio) {
11035 if (HasClauseCleanupProtection) {
11036 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) ClauseCleanupProtection);
11038 if (HasClauseCleanupLbdBound) {
11039 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ClauseCleanupLbdBound);
11041 if (HasClauseCleanupOrdering) {
11042 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) ClauseCleanupOrdering);
11044 if (HasPbCleanupIncrement) {
11045 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PbCleanupIncrement);
11047 if (HasPbCleanupRatio) {
11050 if (HasVariableActivityDecay) {
11053 if (HasMaxVariableActivityValue) {
11056 if (HasGlucoseMaxDecay) {
11059 if (HasGlucoseDecayIncrement) {
11062 if (HasGlucoseDecayIncrementPeriod) {
11063 size += 2 + pb::CodedOutputStream.ComputeInt32Size(GlucoseDecayIncrementPeriod);
11065 if (HasClauseActivityDecay) {
11068 if (HasMaxClauseActivityValue) {
11071 size += restartAlgorithms_.CalculateSize(_repeated_restartAlgorithms_codec);
11072 if (HasDefaultRestartAlgorithms) {
11073 size += 2 + pb::CodedOutputStream.ComputeStringSize(DefaultRestartAlgorithms);
11075 if (HasRestartPeriod) {
11076 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RestartPeriod);
11078 if (HasRestartRunningWindowSize) {
11079 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RestartRunningWindowSize);
11081 if (HasRestartDlAverageRatio) {
11084 if (HasRestartLbdAverageRatio) {
11087 if (HasUseBlockingRestart) {
11090 if (HasBlockingRestartWindowSize) {
11091 size += 2 + pb::CodedOutputStream.ComputeInt32Size(BlockingRestartWindowSize);
11093 if (HasBlockingRestartMultiplier) {
11096 if (HasNumConflictsBeforeStrategyChanges) {
11097 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumConflictsBeforeStrategyChanges);
11099 if (HasStrategyChangeIncreaseRatio) {
11102 if (HasMaxTimeInSeconds) {
11105 if (HasMaxDeterministicTime) {
11108 if (HasMaxNumDeterministicBatches) {
11109 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxNumDeterministicBatches);
11111 if (HasMaxNumberOfConflicts) {
11112 size += 2 + pb::CodedOutputStream.ComputeInt64Size(MaxNumberOfConflicts);
11114 if (HasMaxMemoryInMb) {
11115 size += 2 + pb::CodedOutputStream.ComputeInt64Size(MaxMemoryInMb);
11117 if (HasAbsoluteGapLimit) {
11120 if (HasRelativeGapLimit) {
11123 if (HasRandomSeed) {
11124 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RandomSeed);
11126 if (HasPermuteVariableRandomly) {
11129 if (HasPermutePresolveConstraintOrder) {
11132 if (HasUseAbslRandom) {
11135 if (HasLogSearchProgress) {
11138 if (HasLogSubsolverStatistics) {
11141 if (HasLogPrefix) {
11142 size += 2 + pb::CodedOutputStream.ComputeStringSize(LogPrefix);
11144 if (HasLogToStdout) {
11147 if (HasLogToResponse) {
11150 if (HasUsePbResolution) {
11153 if (HasMinimizeReductionDuringPbResolution) {
11156 if (HasCountAssumptionLevelsInLbd) {
11159 if (HasPresolveBveThreshold) {
11160 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PresolveBveThreshold);
11162 if (HasPresolveBveClauseWeight) {
11163 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PresolveBveClauseWeight);
11165 if (HasProbingDeterministicTimeLimit) {
11168 if (HasPresolveProbingDeterministicTimeLimit) {
11171 if (HasPresolveBlockedClause) {
11174 if (HasPresolveUseBva) {
11177 if (HasPresolveBvaThreshold) {
11178 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PresolveBvaThreshold);
11180 if (HasMaxPresolveIterations) {
11181 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxPresolveIterations);
11183 if (HasCpModelPresolve) {
11186 if (HasCpModelProbingLevel) {
11187 size += 2 + pb::CodedOutputStream.ComputeInt32Size(CpModelProbingLevel);
11189 if (HasCpModelUseSatPresolve) {
11192 if (HasDetectTableWithCost) {
11195 if (HasTableCompressionLevel) {
11196 size += 2 + pb::CodedOutputStream.ComputeInt32Size(TableCompressionLevel);
11198 if (HasExpandAlldiffConstraints) {
11201 if (HasExpandReservoirConstraints) {
11204 if (HasExpandReservoirUsingCircuit) {
11207 if (HasEncodeCumulativeAsReservoir) {
11210 if (HasMaxLinMaxSizeForExpansion) {
11211 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxLinMaxSizeForExpansion);
11213 if (HasDisableConstraintExpansion) {
11216 if (HasEncodeComplexLinearConstraintWithInteger) {
11219 if (HasMergeNoOverlapWorkLimit) {
11222 if (HasMergeAtMostOneWorkLimit) {
11225 if (HasPresolveSubstitutionLevel) {
11226 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PresolveSubstitutionLevel);
11228 if (HasPresolveExtractIntegerEnforcement) {
11231 if (HasPresolveInclusionWorkLimit) {
11232 size += 2 + pb::CodedOutputStream.ComputeInt64Size(PresolveInclusionWorkLimit);
11234 if (HasIgnoreNames) {
11237 if (HasInferAllDiffs) {
11240 if (HasFindBigLinearOverlap) {
11243 if (HasUseSatInprocessing) {
11246 if (HasInprocessingDtimeRatio) {
11249 if (HasInprocessingProbingDtime) {
11252 if (HasInprocessingMinimizationDtime) {
11255 if (HasNumWorkers) {
11256 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumWorkers);
11258 if (HasNumSearchWorkers) {
11259 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumSearchWorkers);
11261 if (HasNumFullSubsolvers) {
11262 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumFullSubsolvers);
11264 size += subsolvers_.CalculateSize(_repeated_subsolvers_codec);
11265 size += extraSubsolvers_.CalculateSize(_repeated_extraSubsolvers_codec);
11266 size += ignoreSubsolvers_.CalculateSize(_repeated_ignoreSubsolvers_codec);
11267 size += filterSubsolvers_.CalculateSize(_repeated_filterSubsolvers_codec);
11268 size += subsolverParams_.CalculateSize(_repeated_subsolverParams_codec);
11269 if (HasInterleaveSearch) {
11272 if (HasInterleaveBatchSize) {
11273 size += 2 + pb::CodedOutputStream.ComputeInt32Size(InterleaveBatchSize);
11275 if (HasShareObjectiveBounds) {
11278 if (HasShareLevelZeroBounds) {
11281 if (HasShareBinaryClauses) {
11284 if (HasShareGlueClauses) {
11287 if (HasDebugPostsolveWithFullSolver) {
11290 if (HasDebugMaxNumPresolveOperations) {
11291 size += 2 + pb::CodedOutputStream.ComputeInt32Size(DebugMaxNumPresolveOperations);
11293 if (HasDebugCrashOnBadHint) {
11296 if (HasUseOptimizationHints) {
11299 if (HasCoreMinimizationLevel) {
11300 size += 2 + pb::CodedOutputStream.ComputeInt32Size(CoreMinimizationLevel);
11302 if (HasFindMultipleCores) {
11305 if (HasCoverOptimization) {
11308 if (HasMaxSatAssumptionOrder) {
11309 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) MaxSatAssumptionOrder);
11311 if (HasMaxSatReverseAssumptionOrder) {
11314 if (HasMaxSatStratification) {
11315 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) MaxSatStratification);
11317 if (HasPropagationLoopDetectionFactor) {
11320 if (HasUsePrecedencesInDisjunctiveConstraint) {
11323 if (HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) {
11324 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxSizeToCreatePrecedenceLiteralsInDisjunctive);
11326 if (HasUseStrongPropagationInDisjunctive) {
11329 if (HasUseDynamicPrecedenceInDisjunctive) {
11332 if (HasUseDynamicPrecedenceInCumulative) {
11335 if (HasUseOverloadCheckerInCumulative) {
11338 if (HasUseConservativeScaleOverloadChecker) {
11341 if (HasUseTimetableEdgeFindingInCumulative) {
11344 if (HasMaxNumIntervalsForTimetableEdgeFinding) {
11345 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxNumIntervalsForTimetableEdgeFinding);
11347 if (HasUseHardPrecedencesInCumulative) {
11350 if (HasExploitAllPrecedences) {
11353 if (HasUseDisjunctiveConstraintInCumulative) {
11356 if (HasUseTimetablingInNoOverlap2D) {
11359 if (HasUseEnergeticReasoningInNoOverlap2D) {
11362 if (HasUseAreaEnergeticReasoningInNoOverlap2D) {
11365 if (HasMaxPairsPairwiseReasoningInNoOverlap2D) {
11366 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxPairsPairwiseReasoningInNoOverlap2D);
11368 if (HasUseDualSchedulingHeuristics) {
11371 if (HasSearchBranching) {
11372 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) SearchBranching);
11374 if (HasHintConflictLimit) {
11375 size += 2 + pb::CodedOutputStream.ComputeInt32Size(HintConflictLimit);
11377 if (HasRepairHint) {
11380 if (HasFixVariablesToTheirHintedValue) {
11383 if (HasUseProbingSearch) {
11386 if (HasUseExtendedProbing) {
11389 if (HasProbingNumCombinationsLimit) {
11390 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ProbingNumCombinationsLimit);
11392 if (HasUseShavingInProbingSearch) {
11395 if (HasShavingSearchDeterministicTime) {
11398 if (HasShavingSearchThreshold) {
11399 size += 2 + pb::CodedOutputStream.ComputeInt64Size(ShavingSearchThreshold);
11401 if (HasUseObjectiveLbSearch) {
11404 if (HasUseObjectiveShavingSearch) {
11407 if (HasUseVariablesShavingSearch) {
11410 if (HasPseudoCostReliabilityThreshold) {
11411 size += 2 + pb::CodedOutputStream.ComputeInt64Size(PseudoCostReliabilityThreshold);
11413 if (HasOptimizeWithCore) {
11416 if (HasOptimizeWithLbTreeSearch) {
11419 if (HasSaveLpBasisInLbTreeSearch) {
11422 if (HasBinarySearchNumConflicts) {
11423 size += 2 + pb::CodedOutputStream.ComputeInt32Size(BinarySearchNumConflicts);
11425 if (HasOptimizeWithMaxHs) {
11428 if (HasUseFeasibilityJump) {
11431 if (HasUseLsOnly) {
11434 if (HasFeasibilityJumpDecay) {
11437 if (HasFeasibilityJumpLinearizationLevel) {
11438 size += 2 + pb::CodedOutputStream.ComputeInt32Size(FeasibilityJumpLinearizationLevel);
11440 if (HasFeasibilityJumpRestartFactor) {
11441 size += 2 + pb::CodedOutputStream.ComputeInt32Size(FeasibilityJumpRestartFactor);
11443 if (HasFeasibilityJumpBatchDtime) {
11446 if (HasFeasibilityJumpVarRandomizationProbability) {
11449 if (HasFeasibilityJumpVarPerburbationRangeRatio) {
11452 if (HasFeasibilityJumpEnableRestarts) {
11455 if (HasFeasibilityJumpMaxExpandedConstraintSize) {
11456 size += 2 + pb::CodedOutputStream.ComputeInt32Size(FeasibilityJumpMaxExpandedConstraintSize);
11458 if (HasNumViolationLs) {
11459 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumViolationLs);
11461 if (HasViolationLsPerturbationPeriod) {
11462 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ViolationLsPerturbationPeriod);
11464 if (HasViolationLsCompoundMoveProbability) {
11467 if (HasSharedTreeNumWorkers) {
11468 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SharedTreeNumWorkers);
11470 if (HasUseSharedTreeSearch) {
11473 if (HasSharedTreeWorkerObjectiveSplitProbability) {
11476 if (HasSharedTreeWorkerMinRestartsPerSubtree) {
11477 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SharedTreeWorkerMinRestartsPerSubtree);
11479 if (HasSharedTreeWorkerEnableTrailSharing) {
11482 if (HasSharedTreeOpenLeavesPerWorker) {
11485 if (HasSharedTreeMaxNodesPerWorker) {
11486 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SharedTreeMaxNodesPerWorker);
11488 if (HasSharedTreeSplitStrategy) {
11489 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) SharedTreeSplitStrategy);
11491 if (HasEnumerateAllSolutions) {
11494 if (HasKeepAllFeasibleSolutionsInPresolve) {
11497 if (HasFillTightenedDomainsInResponse) {
11500 if (HasFillAdditionalSolutionsInResponse) {
11503 if (HasInstantiateAllVariables) {
11506 if (HasAutoDetectGreaterThanAtLeastOneOf) {
11509 if (HasStopAfterFirstSolution) {
11512 if (HasStopAfterPresolve) {
11515 if (HasStopAfterRootPropagation) {
11521 if (HasUseLnsOnly) {
11524 if (HasSolutionPoolSize) {
11525 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SolutionPoolSize);
11527 if (HasUseRinsLns) {
11530 if (HasUseFeasibilityPump) {
11533 if (HasUseLbRelaxLns) {
11536 if (HasFpRounding) {
11537 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) FpRounding);
11539 if (HasDiversifyLnsParams) {
11542 if (HasRandomizeSearch) {
11545 if (HasSearchRandomVariablePoolSize) {
11546 size += 2 + pb::CodedOutputStream.ComputeInt64Size(SearchRandomVariablePoolSize);
11548 if (HasPushAllTasksTowardStart) {
11551 if (HasUseOptionalVariables) {
11554 if (HasUseExactLpReason) {
11557 if (HasUseCombinedNoOverlap) {
11560 if (HasAtMostOneMaxExpansionSize) {
11561 size += 2 + pb::CodedOutputStream.ComputeInt32Size(AtMostOneMaxExpansionSize);
11563 if (HasCatchSigintSignal) {
11566 if (HasUseImpliedBounds) {
11569 if (HasPolishLpSolution) {
11572 if (HasLpPrimalTolerance) {
11575 if (HasLpDualTolerance) {
11578 if (HasConvertIntervals) {
11581 if (HasSymmetryLevel) {
11582 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SymmetryLevel);
11584 if (HasNewLinearPropagation) {
11587 if (HasLinearSplitSize) {
11588 size += 2 + pb::CodedOutputStream.ComputeInt32Size(LinearSplitSize);
11590 if (HasLinearizationLevel) {
11591 size += 2 + pb::CodedOutputStream.ComputeInt32Size(LinearizationLevel);
11593 if (HasBooleanEncodingLevel) {
11594 size += 2 + pb::CodedOutputStream.ComputeInt32Size(BooleanEncodingLevel);
11596 if (HasMaxDomainSizeWhenEncodingEqNeqConstraints) {
11597 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxDomainSizeWhenEncodingEqNeqConstraints);
11599 if (HasMaxNumCuts) {
11600 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxNumCuts);
11603 size += 2 + pb::CodedOutputStream.ComputeInt32Size(CutLevel);
11605 if (HasOnlyAddCutsAtLevelZero) {
11608 if (HasAddObjectiveCut) {
11611 if (HasAddCgCuts) {
11614 if (HasAddMirCuts) {
11617 if (HasAddZeroHalfCuts) {
11620 if (HasAddCliqueCuts) {
11623 if (HasAddRltCuts) {
11626 if (HasMaxAllDiffCutSize) {
11627 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxAllDiffCutSize);
11629 if (HasAddLinMaxCuts) {
11632 if (HasMaxIntegerRoundingScaling) {
11633 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxIntegerRoundingScaling);
11635 if (HasAddLpConstraintsLazily) {
11638 if (HasRootLpIterations) {
11639 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RootLpIterations);
11641 if (HasMinOrthogonalityForLpConstraints) {
11644 if (HasMaxCutRoundsAtLevelZero) {
11645 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxCutRoundsAtLevelZero);
11647 if (HasMaxConsecutiveInactiveCount) {
11648 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxConsecutiveInactiveCount);
11650 if (HasCutMaxActiveCountValue) {
11653 if (HasCutActiveCountDecay) {
11656 if (HasCutCleanupTarget) {
11657 size += 2 + pb::CodedOutputStream.ComputeInt32Size(CutCleanupTarget);
11659 if (HasNewConstraintsBatchSize) {
11660 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NewConstraintsBatchSize);
11662 if (HasExploitIntegerLpSolution) {
11665 if (HasExploitAllLpSolution) {
11668 if (HasExploitBestSolution) {
11671 if (HasExploitRelaxationSolution) {
11674 if (HasExploitObjective) {
11677 if (HasDetectLinearizedProduct) {
11680 if (HasMipMaxBound) {
11683 if (HasMipVarScaling) {
11686 if (HasMipScaleLargeDomain) {
11689 if (HasMipAutomaticallyScaleVariables) {
11692 if (HasOnlySolveIp) {
11695 if (HasMipWantedPrecision) {
11698 if (HasMipMaxActivityExponent) {
11699 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MipMaxActivityExponent);
11701 if (HasMipCheckPrecision) {
11704 if (HasMipComputeTrueObjectiveBound) {
11707 if (HasMipMaxValidMagnitude) {
11710 if (HasMipTreatHighMagnitudeBoundsAsInfinity) {
11713 if (HasMipDropTolerance) {
11716 if (HasMipPresolveLevel) {
11717 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MipPresolveLevel);
11719 if (_unknownFields !=
null) {
11720 size += _unknownFields.CalculateSize();
11725 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
11726 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
11727 public void MergeFrom(SatParameters other) {
11728 if (other ==
null) {
11731 if (other.HasName) {
11734 if (other.HasPreferredVariableOrder) {
11735 PreferredVariableOrder = other.PreferredVariableOrder;
11737 if (other.HasInitialPolarity) {
11738 InitialPolarity = other.InitialPolarity;
11740 if (other.HasUsePhaseSaving) {
11741 UsePhaseSaving = other.UsePhaseSaving;
11743 if (other.HasPolarityRephaseIncrement) {
11744 PolarityRephaseIncrement = other.PolarityRephaseIncrement;
11746 if (other.HasRandomPolarityRatio) {
11747 RandomPolarityRatio = other.RandomPolarityRatio;
11749 if (other.HasRandomBranchesRatio) {
11750 RandomBranchesRatio = other.RandomBranchesRatio;
11752 if (other.HasUseErwaHeuristic) {
11753 UseErwaHeuristic = other.UseErwaHeuristic;
11755 if (other.HasInitialVariablesActivity) {
11756 InitialVariablesActivity = other.InitialVariablesActivity;
11758 if (other.HasAlsoBumpVariablesInConflictReasons) {
11759 AlsoBumpVariablesInConflictReasons = other.AlsoBumpVariablesInConflictReasons;
11761 if (other.HasMinimizationAlgorithm) {
11762 MinimizationAlgorithm = other.MinimizationAlgorithm;
11764 if (other.HasBinaryMinimizationAlgorithm) {
11765 BinaryMinimizationAlgorithm = other.BinaryMinimizationAlgorithm;
11767 if (other.HasSubsumptionDuringConflictAnalysis) {
11768 SubsumptionDuringConflictAnalysis = other.SubsumptionDuringConflictAnalysis;
11770 if (other.HasClauseCleanupPeriod) {
11771 ClauseCleanupPeriod = other.ClauseCleanupPeriod;
11773 if (other.HasClauseCleanupTarget) {
11774 ClauseCleanupTarget = other.ClauseCleanupTarget;
11776 if (other.HasClauseCleanupRatio) {
11777 ClauseCleanupRatio = other.ClauseCleanupRatio;
11779 if (other.HasClauseCleanupProtection) {
11780 ClauseCleanupProtection = other.ClauseCleanupProtection;
11782 if (other.HasClauseCleanupLbdBound) {
11783 ClauseCleanupLbdBound = other.ClauseCleanupLbdBound;
11785 if (other.HasClauseCleanupOrdering) {
11786 ClauseCleanupOrdering = other.ClauseCleanupOrdering;
11788 if (other.HasPbCleanupIncrement) {
11789 PbCleanupIncrement = other.PbCleanupIncrement;
11791 if (other.HasPbCleanupRatio) {
11792 PbCleanupRatio = other.PbCleanupRatio;
11794 if (other.HasVariableActivityDecay) {
11795 VariableActivityDecay = other.VariableActivityDecay;
11797 if (other.HasMaxVariableActivityValue) {
11798 MaxVariableActivityValue = other.MaxVariableActivityValue;
11800 if (other.HasGlucoseMaxDecay) {
11801 GlucoseMaxDecay = other.GlucoseMaxDecay;
11803 if (other.HasGlucoseDecayIncrement) {
11804 GlucoseDecayIncrement = other.GlucoseDecayIncrement;
11806 if (other.HasGlucoseDecayIncrementPeriod) {
11807 GlucoseDecayIncrementPeriod = other.GlucoseDecayIncrementPeriod;
11809 if (other.HasClauseActivityDecay) {
11810 ClauseActivityDecay = other.ClauseActivityDecay;
11812 if (other.HasMaxClauseActivityValue) {
11813 MaxClauseActivityValue = other.MaxClauseActivityValue;
11815 restartAlgorithms_.Add(other.restartAlgorithms_);
11816 if (other.HasDefaultRestartAlgorithms) {
11817 DefaultRestartAlgorithms = other.DefaultRestartAlgorithms;
11819 if (other.HasRestartPeriod) {
11820 RestartPeriod = other.RestartPeriod;
11822 if (other.HasRestartRunningWindowSize) {
11823 RestartRunningWindowSize = other.RestartRunningWindowSize;
11825 if (other.HasRestartDlAverageRatio) {
11826 RestartDlAverageRatio = other.RestartDlAverageRatio;
11828 if (other.HasRestartLbdAverageRatio) {
11829 RestartLbdAverageRatio = other.RestartLbdAverageRatio;
11831 if (other.HasUseBlockingRestart) {
11832 UseBlockingRestart = other.UseBlockingRestart;
11834 if (other.HasBlockingRestartWindowSize) {
11835 BlockingRestartWindowSize = other.BlockingRestartWindowSize;
11837 if (other.HasBlockingRestartMultiplier) {
11838 BlockingRestartMultiplier = other.BlockingRestartMultiplier;
11840 if (other.HasNumConflictsBeforeStrategyChanges) {
11841 NumConflictsBeforeStrategyChanges = other.NumConflictsBeforeStrategyChanges;
11843 if (other.HasStrategyChangeIncreaseRatio) {
11844 StrategyChangeIncreaseRatio = other.StrategyChangeIncreaseRatio;
11846 if (other.HasMaxTimeInSeconds) {
11847 MaxTimeInSeconds = other.MaxTimeInSeconds;
11849 if (other.HasMaxDeterministicTime) {
11850 MaxDeterministicTime = other.MaxDeterministicTime;
11852 if (other.HasMaxNumDeterministicBatches) {
11853 MaxNumDeterministicBatches = other.MaxNumDeterministicBatches;
11855 if (other.HasMaxNumberOfConflicts) {
11856 MaxNumberOfConflicts = other.MaxNumberOfConflicts;
11858 if (other.HasMaxMemoryInMb) {
11859 MaxMemoryInMb = other.MaxMemoryInMb;
11861 if (other.HasAbsoluteGapLimit) {
11862 AbsoluteGapLimit = other.AbsoluteGapLimit;
11864 if (other.HasRelativeGapLimit) {
11865 RelativeGapLimit = other.RelativeGapLimit;
11867 if (other.HasRandomSeed) {
11868 RandomSeed = other.RandomSeed;
11870 if (other.HasPermuteVariableRandomly) {
11871 PermuteVariableRandomly = other.PermuteVariableRandomly;
11873 if (other.HasPermutePresolveConstraintOrder) {
11874 PermutePresolveConstraintOrder = other.PermutePresolveConstraintOrder;
11876 if (other.HasUseAbslRandom) {
11877 UseAbslRandom = other.UseAbslRandom;
11879 if (other.HasLogSearchProgress) {
11880 LogSearchProgress = other.LogSearchProgress;
11882 if (other.HasLogSubsolverStatistics) {
11883 LogSubsolverStatistics = other.LogSubsolverStatistics;
11885 if (other.HasLogPrefix) {
11886 LogPrefix = other.LogPrefix;
11888 if (other.HasLogToStdout) {
11889 LogToStdout = other.LogToStdout;
11891 if (other.HasLogToResponse) {
11892 LogToResponse = other.LogToResponse;
11894 if (other.HasUsePbResolution) {
11895 UsePbResolution = other.UsePbResolution;
11897 if (other.HasMinimizeReductionDuringPbResolution) {
11898 MinimizeReductionDuringPbResolution = other.MinimizeReductionDuringPbResolution;
11900 if (other.HasCountAssumptionLevelsInLbd) {
11901 CountAssumptionLevelsInLbd = other.CountAssumptionLevelsInLbd;
11903 if (other.HasPresolveBveThreshold) {
11904 PresolveBveThreshold = other.PresolveBveThreshold;
11906 if (other.HasPresolveBveClauseWeight) {
11907 PresolveBveClauseWeight = other.PresolveBveClauseWeight;
11909 if (other.HasProbingDeterministicTimeLimit) {
11910 ProbingDeterministicTimeLimit = other.ProbingDeterministicTimeLimit;
11912 if (other.HasPresolveProbingDeterministicTimeLimit) {
11913 PresolveProbingDeterministicTimeLimit = other.PresolveProbingDeterministicTimeLimit;
11915 if (other.HasPresolveBlockedClause) {
11916 PresolveBlockedClause = other.PresolveBlockedClause;
11918 if (other.HasPresolveUseBva) {
11919 PresolveUseBva = other.PresolveUseBva;
11921 if (other.HasPresolveBvaThreshold) {
11922 PresolveBvaThreshold = other.PresolveBvaThreshold;
11924 if (other.HasMaxPresolveIterations) {
11925 MaxPresolveIterations = other.MaxPresolveIterations;
11927 if (other.HasCpModelPresolve) {
11928 CpModelPresolve = other.CpModelPresolve;
11930 if (other.HasCpModelProbingLevel) {
11931 CpModelProbingLevel = other.CpModelProbingLevel;
11933 if (other.HasCpModelUseSatPresolve) {
11934 CpModelUseSatPresolve = other.CpModelUseSatPresolve;
11936 if (other.HasDetectTableWithCost) {
11937 DetectTableWithCost = other.DetectTableWithCost;
11939 if (other.HasTableCompressionLevel) {
11940 TableCompressionLevel = other.TableCompressionLevel;
11942 if (other.HasExpandAlldiffConstraints) {
11943 ExpandAlldiffConstraints = other.ExpandAlldiffConstraints;
11945 if (other.HasExpandReservoirConstraints) {
11946 ExpandReservoirConstraints = other.ExpandReservoirConstraints;
11948 if (other.HasExpandReservoirUsingCircuit) {
11949 ExpandReservoirUsingCircuit = other.ExpandReservoirUsingCircuit;
11951 if (other.HasEncodeCumulativeAsReservoir) {
11952 EncodeCumulativeAsReservoir = other.EncodeCumulativeAsReservoir;
11954 if (other.HasMaxLinMaxSizeForExpansion) {
11955 MaxLinMaxSizeForExpansion = other.MaxLinMaxSizeForExpansion;
11957 if (other.HasDisableConstraintExpansion) {
11958 DisableConstraintExpansion = other.DisableConstraintExpansion;
11960 if (other.HasEncodeComplexLinearConstraintWithInteger) {
11961 EncodeComplexLinearConstraintWithInteger = other.EncodeComplexLinearConstraintWithInteger;
11963 if (other.HasMergeNoOverlapWorkLimit) {
11964 MergeNoOverlapWorkLimit = other.MergeNoOverlapWorkLimit;
11966 if (other.HasMergeAtMostOneWorkLimit) {
11967 MergeAtMostOneWorkLimit = other.MergeAtMostOneWorkLimit;
11969 if (other.HasPresolveSubstitutionLevel) {
11970 PresolveSubstitutionLevel = other.PresolveSubstitutionLevel;
11972 if (other.HasPresolveExtractIntegerEnforcement) {
11973 PresolveExtractIntegerEnforcement = other.PresolveExtractIntegerEnforcement;
11975 if (other.HasPresolveInclusionWorkLimit) {
11976 PresolveInclusionWorkLimit = other.PresolveInclusionWorkLimit;
11978 if (other.HasIgnoreNames) {
11979 IgnoreNames = other.IgnoreNames;
11981 if (other.HasInferAllDiffs) {
11982 InferAllDiffs = other.InferAllDiffs;
11984 if (other.HasFindBigLinearOverlap) {
11985 FindBigLinearOverlap = other.FindBigLinearOverlap;
11987 if (other.HasUseSatInprocessing) {
11988 UseSatInprocessing = other.UseSatInprocessing;
11990 if (other.HasInprocessingDtimeRatio) {
11991 InprocessingDtimeRatio = other.InprocessingDtimeRatio;
11993 if (other.HasInprocessingProbingDtime) {
11994 InprocessingProbingDtime = other.InprocessingProbingDtime;
11996 if (other.HasInprocessingMinimizationDtime) {
11997 InprocessingMinimizationDtime = other.InprocessingMinimizationDtime;
11999 if (other.HasNumWorkers) {
12000 NumWorkers = other.NumWorkers;
12002 if (other.HasNumSearchWorkers) {
12003 NumSearchWorkers = other.NumSearchWorkers;
12005 if (other.HasNumFullSubsolvers) {
12006 NumFullSubsolvers = other.NumFullSubsolvers;
12008 subsolvers_.Add(other.subsolvers_);
12009 extraSubsolvers_.Add(other.extraSubsolvers_);
12010 ignoreSubsolvers_.Add(other.ignoreSubsolvers_);
12011 filterSubsolvers_.Add(other.filterSubsolvers_);
12012 subsolverParams_.Add(other.subsolverParams_);
12013 if (other.HasInterleaveSearch) {
12014 InterleaveSearch = other.InterleaveSearch;
12016 if (other.HasInterleaveBatchSize) {
12017 InterleaveBatchSize = other.InterleaveBatchSize;
12019 if (other.HasShareObjectiveBounds) {
12020 ShareObjectiveBounds = other.ShareObjectiveBounds;
12022 if (other.HasShareLevelZeroBounds) {
12023 ShareLevelZeroBounds = other.ShareLevelZeroBounds;
12025 if (other.HasShareBinaryClauses) {
12026 ShareBinaryClauses = other.ShareBinaryClauses;
12028 if (other.HasShareGlueClauses) {
12029 ShareGlueClauses = other.ShareGlueClauses;
12031 if (other.HasDebugPostsolveWithFullSolver) {
12032 DebugPostsolveWithFullSolver = other.DebugPostsolveWithFullSolver;
12034 if (other.HasDebugMaxNumPresolveOperations) {
12035 DebugMaxNumPresolveOperations = other.DebugMaxNumPresolveOperations;
12037 if (other.HasDebugCrashOnBadHint) {
12038 DebugCrashOnBadHint = other.DebugCrashOnBadHint;
12040 if (other.HasUseOptimizationHints) {
12041 UseOptimizationHints = other.UseOptimizationHints;
12043 if (other.HasCoreMinimizationLevel) {
12044 CoreMinimizationLevel = other.CoreMinimizationLevel;
12046 if (other.HasFindMultipleCores) {
12047 FindMultipleCores = other.FindMultipleCores;
12049 if (other.HasCoverOptimization) {
12050 CoverOptimization = other.CoverOptimization;
12052 if (other.HasMaxSatAssumptionOrder) {
12053 MaxSatAssumptionOrder = other.MaxSatAssumptionOrder;
12055 if (other.HasMaxSatReverseAssumptionOrder) {
12056 MaxSatReverseAssumptionOrder = other.MaxSatReverseAssumptionOrder;
12058 if (other.HasMaxSatStratification) {
12059 MaxSatStratification = other.MaxSatStratification;
12061 if (other.HasPropagationLoopDetectionFactor) {
12062 PropagationLoopDetectionFactor = other.PropagationLoopDetectionFactor;
12064 if (other.HasUsePrecedencesInDisjunctiveConstraint) {
12065 UsePrecedencesInDisjunctiveConstraint = other.UsePrecedencesInDisjunctiveConstraint;
12067 if (other.HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) {
12068 MaxSizeToCreatePrecedenceLiteralsInDisjunctive = other.MaxSizeToCreatePrecedenceLiteralsInDisjunctive;
12070 if (other.HasUseStrongPropagationInDisjunctive) {
12071 UseStrongPropagationInDisjunctive = other.UseStrongPropagationInDisjunctive;
12073 if (other.HasUseDynamicPrecedenceInDisjunctive) {
12074 UseDynamicPrecedenceInDisjunctive = other.UseDynamicPrecedenceInDisjunctive;
12076 if (other.HasUseDynamicPrecedenceInCumulative) {
12077 UseDynamicPrecedenceInCumulative = other.UseDynamicPrecedenceInCumulative;
12079 if (other.HasUseOverloadCheckerInCumulative) {
12080 UseOverloadCheckerInCumulative = other.UseOverloadCheckerInCumulative;
12082 if (other.HasUseConservativeScaleOverloadChecker) {
12083 UseConservativeScaleOverloadChecker = other.UseConservativeScaleOverloadChecker;
12085 if (other.HasUseTimetableEdgeFindingInCumulative) {
12086 UseTimetableEdgeFindingInCumulative = other.UseTimetableEdgeFindingInCumulative;
12088 if (other.HasMaxNumIntervalsForTimetableEdgeFinding) {
12089 MaxNumIntervalsForTimetableEdgeFinding = other.MaxNumIntervalsForTimetableEdgeFinding;
12091 if (other.HasUseHardPrecedencesInCumulative) {
12092 UseHardPrecedencesInCumulative = other.UseHardPrecedencesInCumulative;
12094 if (other.HasExploitAllPrecedences) {
12095 ExploitAllPrecedences = other.ExploitAllPrecedences;
12097 if (other.HasUseDisjunctiveConstraintInCumulative) {
12098 UseDisjunctiveConstraintInCumulative = other.UseDisjunctiveConstraintInCumulative;
12100 if (other.HasUseTimetablingInNoOverlap2D) {
12101 UseTimetablingInNoOverlap2D = other.UseTimetablingInNoOverlap2D;
12103 if (other.HasUseEnergeticReasoningInNoOverlap2D) {
12104 UseEnergeticReasoningInNoOverlap2D = other.UseEnergeticReasoningInNoOverlap2D;
12106 if (other.HasUseAreaEnergeticReasoningInNoOverlap2D) {
12107 UseAreaEnergeticReasoningInNoOverlap2D = other.UseAreaEnergeticReasoningInNoOverlap2D;
12109 if (other.HasMaxPairsPairwiseReasoningInNoOverlap2D) {
12110 MaxPairsPairwiseReasoningInNoOverlap2D = other.MaxPairsPairwiseReasoningInNoOverlap2D;
12112 if (other.HasUseDualSchedulingHeuristics) {
12113 UseDualSchedulingHeuristics = other.UseDualSchedulingHeuristics;
12115 if (other.HasSearchBranching) {
12116 SearchBranching = other.SearchBranching;
12118 if (other.HasHintConflictLimit) {
12119 HintConflictLimit = other.HintConflictLimit;
12121 if (other.HasRepairHint) {
12122 RepairHint = other.RepairHint;
12124 if (other.HasFixVariablesToTheirHintedValue) {
12125 FixVariablesToTheirHintedValue = other.FixVariablesToTheirHintedValue;
12127 if (other.HasUseProbingSearch) {
12128 UseProbingSearch = other.UseProbingSearch;
12130 if (other.HasUseExtendedProbing) {
12131 UseExtendedProbing = other.UseExtendedProbing;
12133 if (other.HasProbingNumCombinationsLimit) {
12134 ProbingNumCombinationsLimit = other.ProbingNumCombinationsLimit;
12136 if (other.HasUseShavingInProbingSearch) {
12137 UseShavingInProbingSearch = other.UseShavingInProbingSearch;
12139 if (other.HasShavingSearchDeterministicTime) {
12140 ShavingSearchDeterministicTime = other.ShavingSearchDeterministicTime;
12142 if (other.HasShavingSearchThreshold) {
12143 ShavingSearchThreshold = other.ShavingSearchThreshold;
12145 if (other.HasUseObjectiveLbSearch) {
12146 UseObjectiveLbSearch = other.UseObjectiveLbSearch;
12148 if (other.HasUseObjectiveShavingSearch) {
12149 UseObjectiveShavingSearch = other.UseObjectiveShavingSearch;
12151 if (other.HasUseVariablesShavingSearch) {
12152 UseVariablesShavingSearch = other.UseVariablesShavingSearch;
12154 if (other.HasPseudoCostReliabilityThreshold) {
12155 PseudoCostReliabilityThreshold = other.PseudoCostReliabilityThreshold;
12157 if (other.HasOptimizeWithCore) {
12158 OptimizeWithCore = other.OptimizeWithCore;
12160 if (other.HasOptimizeWithLbTreeSearch) {
12161 OptimizeWithLbTreeSearch = other.OptimizeWithLbTreeSearch;
12163 if (other.HasSaveLpBasisInLbTreeSearch) {
12164 SaveLpBasisInLbTreeSearch = other.SaveLpBasisInLbTreeSearch;
12166 if (other.HasBinarySearchNumConflicts) {
12167 BinarySearchNumConflicts = other.BinarySearchNumConflicts;
12169 if (other.HasOptimizeWithMaxHs) {
12170 OptimizeWithMaxHs = other.OptimizeWithMaxHs;
12172 if (other.HasUseFeasibilityJump) {
12173 UseFeasibilityJump = other.UseFeasibilityJump;
12175 if (other.HasUseLsOnly) {
12176 UseLsOnly = other.UseLsOnly;
12178 if (other.HasFeasibilityJumpDecay) {
12179 FeasibilityJumpDecay = other.FeasibilityJumpDecay;
12181 if (other.HasFeasibilityJumpLinearizationLevel) {
12182 FeasibilityJumpLinearizationLevel = other.FeasibilityJumpLinearizationLevel;
12184 if (other.HasFeasibilityJumpRestartFactor) {
12185 FeasibilityJumpRestartFactor = other.FeasibilityJumpRestartFactor;
12187 if (other.HasFeasibilityJumpBatchDtime) {
12188 FeasibilityJumpBatchDtime = other.FeasibilityJumpBatchDtime;
12190 if (other.HasFeasibilityJumpVarRandomizationProbability) {
12191 FeasibilityJumpVarRandomizationProbability = other.FeasibilityJumpVarRandomizationProbability;
12193 if (other.HasFeasibilityJumpVarPerburbationRangeRatio) {
12194 FeasibilityJumpVarPerburbationRangeRatio = other.FeasibilityJumpVarPerburbationRangeRatio;
12196 if (other.HasFeasibilityJumpEnableRestarts) {
12197 FeasibilityJumpEnableRestarts = other.FeasibilityJumpEnableRestarts;
12199 if (other.HasFeasibilityJumpMaxExpandedConstraintSize) {
12200 FeasibilityJumpMaxExpandedConstraintSize = other.FeasibilityJumpMaxExpandedConstraintSize;
12202 if (other.HasNumViolationLs) {
12203 NumViolationLs = other.NumViolationLs;
12205 if (other.HasViolationLsPerturbationPeriod) {
12206 ViolationLsPerturbationPeriod = other.ViolationLsPerturbationPeriod;
12208 if (other.HasViolationLsCompoundMoveProbability) {
12209 ViolationLsCompoundMoveProbability = other.ViolationLsCompoundMoveProbability;
12211 if (other.HasSharedTreeNumWorkers) {
12212 SharedTreeNumWorkers = other.SharedTreeNumWorkers;
12214 if (other.HasUseSharedTreeSearch) {
12215 UseSharedTreeSearch = other.UseSharedTreeSearch;
12217 if (other.HasSharedTreeWorkerObjectiveSplitProbability) {
12218 SharedTreeWorkerObjectiveSplitProbability = other.SharedTreeWorkerObjectiveSplitProbability;
12220 if (other.HasSharedTreeWorkerMinRestartsPerSubtree) {
12221 SharedTreeWorkerMinRestartsPerSubtree = other.SharedTreeWorkerMinRestartsPerSubtree;
12223 if (other.HasSharedTreeWorkerEnableTrailSharing) {
12224 SharedTreeWorkerEnableTrailSharing = other.SharedTreeWorkerEnableTrailSharing;
12226 if (other.HasSharedTreeOpenLeavesPerWorker) {
12227 SharedTreeOpenLeavesPerWorker = other.SharedTreeOpenLeavesPerWorker;
12229 if (other.HasSharedTreeMaxNodesPerWorker) {
12230 SharedTreeMaxNodesPerWorker = other.SharedTreeMaxNodesPerWorker;
12232 if (other.HasSharedTreeSplitStrategy) {
12233 SharedTreeSplitStrategy = other.SharedTreeSplitStrategy;
12235 if (other.HasEnumerateAllSolutions) {
12236 EnumerateAllSolutions = other.EnumerateAllSolutions;
12238 if (other.HasKeepAllFeasibleSolutionsInPresolve) {
12239 KeepAllFeasibleSolutionsInPresolve = other.KeepAllFeasibleSolutionsInPresolve;
12241 if (other.HasFillTightenedDomainsInResponse) {
12242 FillTightenedDomainsInResponse = other.FillTightenedDomainsInResponse;
12244 if (other.HasFillAdditionalSolutionsInResponse) {
12245 FillAdditionalSolutionsInResponse = other.FillAdditionalSolutionsInResponse;
12247 if (other.HasInstantiateAllVariables) {
12248 InstantiateAllVariables = other.InstantiateAllVariables;
12250 if (other.HasAutoDetectGreaterThanAtLeastOneOf) {
12251 AutoDetectGreaterThanAtLeastOneOf = other.AutoDetectGreaterThanAtLeastOneOf;
12253 if (other.HasStopAfterFirstSolution) {
12254 StopAfterFirstSolution = other.StopAfterFirstSolution;
12256 if (other.HasStopAfterPresolve) {
12257 StopAfterPresolve = other.StopAfterPresolve;
12259 if (other.HasStopAfterRootPropagation) {
12260 StopAfterRootPropagation = other.StopAfterRootPropagation;
12262 if (other.HasUseLns) {
12263 UseLns = other.UseLns;
12265 if (other.HasUseLnsOnly) {
12266 UseLnsOnly = other.UseLnsOnly;
12268 if (other.HasSolutionPoolSize) {
12269 SolutionPoolSize = other.SolutionPoolSize;
12271 if (other.HasUseRinsLns) {
12272 UseRinsLns = other.UseRinsLns;
12274 if (other.HasUseFeasibilityPump) {
12275 UseFeasibilityPump = other.UseFeasibilityPump;
12277 if (other.HasUseLbRelaxLns) {
12278 UseLbRelaxLns = other.UseLbRelaxLns;
12280 if (other.HasFpRounding) {
12281 FpRounding = other.FpRounding;
12283 if (other.HasDiversifyLnsParams) {
12284 DiversifyLnsParams = other.DiversifyLnsParams;
12286 if (other.HasRandomizeSearch) {
12287 RandomizeSearch = other.RandomizeSearch;
12289 if (other.HasSearchRandomVariablePoolSize) {
12290 SearchRandomVariablePoolSize = other.SearchRandomVariablePoolSize;
12292 if (other.HasPushAllTasksTowardStart) {
12293 PushAllTasksTowardStart = other.PushAllTasksTowardStart;
12295 if (other.HasUseOptionalVariables) {
12296 UseOptionalVariables = other.UseOptionalVariables;
12298 if (other.HasUseExactLpReason) {
12299 UseExactLpReason = other.UseExactLpReason;
12301 if (other.HasUseCombinedNoOverlap) {
12302 UseCombinedNoOverlap = other.UseCombinedNoOverlap;
12304 if (other.HasAtMostOneMaxExpansionSize) {
12305 AtMostOneMaxExpansionSize = other.AtMostOneMaxExpansionSize;
12307 if (other.HasCatchSigintSignal) {
12308 CatchSigintSignal = other.CatchSigintSignal;
12310 if (other.HasUseImpliedBounds) {
12311 UseImpliedBounds = other.UseImpliedBounds;
12313 if (other.HasPolishLpSolution) {
12314 PolishLpSolution = other.PolishLpSolution;
12316 if (other.HasLpPrimalTolerance) {
12317 LpPrimalTolerance = other.LpPrimalTolerance;
12319 if (other.HasLpDualTolerance) {
12320 LpDualTolerance = other.LpDualTolerance;
12322 if (other.HasConvertIntervals) {
12323 ConvertIntervals = other.ConvertIntervals;
12325 if (other.HasSymmetryLevel) {
12326 SymmetryLevel = other.SymmetryLevel;
12328 if (other.HasNewLinearPropagation) {
12329 NewLinearPropagation = other.NewLinearPropagation;
12331 if (other.HasLinearSplitSize) {
12332 LinearSplitSize = other.LinearSplitSize;
12334 if (other.HasLinearizationLevel) {
12335 LinearizationLevel = other.LinearizationLevel;
12337 if (other.HasBooleanEncodingLevel) {
12338 BooleanEncodingLevel = other.BooleanEncodingLevel;
12340 if (other.HasMaxDomainSizeWhenEncodingEqNeqConstraints) {
12341 MaxDomainSizeWhenEncodingEqNeqConstraints = other.MaxDomainSizeWhenEncodingEqNeqConstraints;
12343 if (other.HasMaxNumCuts) {
12344 MaxNumCuts = other.MaxNumCuts;
12346 if (other.HasCutLevel) {
12347 CutLevel = other.CutLevel;
12349 if (other.HasOnlyAddCutsAtLevelZero) {
12350 OnlyAddCutsAtLevelZero = other.OnlyAddCutsAtLevelZero;
12352 if (other.HasAddObjectiveCut) {
12353 AddObjectiveCut = other.AddObjectiveCut;
12355 if (other.HasAddCgCuts) {
12356 AddCgCuts = other.AddCgCuts;
12358 if (other.HasAddMirCuts) {
12359 AddMirCuts = other.AddMirCuts;
12361 if (other.HasAddZeroHalfCuts) {
12362 AddZeroHalfCuts = other.AddZeroHalfCuts;
12364 if (other.HasAddCliqueCuts) {
12365 AddCliqueCuts = other.AddCliqueCuts;
12367 if (other.HasAddRltCuts) {
12368 AddRltCuts = other.AddRltCuts;
12370 if (other.HasMaxAllDiffCutSize) {
12371 MaxAllDiffCutSize = other.MaxAllDiffCutSize;
12373 if (other.HasAddLinMaxCuts) {
12374 AddLinMaxCuts = other.AddLinMaxCuts;
12376 if (other.HasMaxIntegerRoundingScaling) {
12377 MaxIntegerRoundingScaling = other.MaxIntegerRoundingScaling;
12379 if (other.HasAddLpConstraintsLazily) {
12380 AddLpConstraintsLazily = other.AddLpConstraintsLazily;
12382 if (other.HasRootLpIterations) {
12383 RootLpIterations = other.RootLpIterations;
12385 if (other.HasMinOrthogonalityForLpConstraints) {
12386 MinOrthogonalityForLpConstraints = other.MinOrthogonalityForLpConstraints;
12388 if (other.HasMaxCutRoundsAtLevelZero) {
12389 MaxCutRoundsAtLevelZero = other.MaxCutRoundsAtLevelZero;
12391 if (other.HasMaxConsecutiveInactiveCount) {
12392 MaxConsecutiveInactiveCount = other.MaxConsecutiveInactiveCount;
12394 if (other.HasCutMaxActiveCountValue) {
12395 CutMaxActiveCountValue = other.CutMaxActiveCountValue;
12397 if (other.HasCutActiveCountDecay) {
12398 CutActiveCountDecay = other.CutActiveCountDecay;
12400 if (other.HasCutCleanupTarget) {
12401 CutCleanupTarget = other.CutCleanupTarget;
12403 if (other.HasNewConstraintsBatchSize) {
12404 NewConstraintsBatchSize = other.NewConstraintsBatchSize;
12406 if (other.HasExploitIntegerLpSolution) {
12407 ExploitIntegerLpSolution = other.ExploitIntegerLpSolution;
12409 if (other.HasExploitAllLpSolution) {
12410 ExploitAllLpSolution = other.ExploitAllLpSolution;
12412 if (other.HasExploitBestSolution) {
12413 ExploitBestSolution = other.ExploitBestSolution;
12415 if (other.HasExploitRelaxationSolution) {
12416 ExploitRelaxationSolution = other.ExploitRelaxationSolution;
12418 if (other.HasExploitObjective) {
12419 ExploitObjective = other.ExploitObjective;
12421 if (other.HasDetectLinearizedProduct) {
12422 DetectLinearizedProduct = other.DetectLinearizedProduct;
12424 if (other.HasMipMaxBound) {
12425 MipMaxBound = other.MipMaxBound;
12427 if (other.HasMipVarScaling) {
12428 MipVarScaling = other.MipVarScaling;
12430 if (other.HasMipScaleLargeDomain) {
12431 MipScaleLargeDomain = other.MipScaleLargeDomain;
12433 if (other.HasMipAutomaticallyScaleVariables) {
12434 MipAutomaticallyScaleVariables = other.MipAutomaticallyScaleVariables;
12436 if (other.HasOnlySolveIp) {
12437 OnlySolveIp = other.OnlySolveIp;
12439 if (other.HasMipWantedPrecision) {
12440 MipWantedPrecision = other.MipWantedPrecision;
12442 if (other.HasMipMaxActivityExponent) {
12443 MipMaxActivityExponent = other.MipMaxActivityExponent;
12445 if (other.HasMipCheckPrecision) {
12446 MipCheckPrecision = other.MipCheckPrecision;
12448 if (other.HasMipComputeTrueObjectiveBound) {
12449 MipComputeTrueObjectiveBound = other.MipComputeTrueObjectiveBound;
12451 if (other.HasMipMaxValidMagnitude) {
12452 MipMaxValidMagnitude = other.MipMaxValidMagnitude;
12454 if (other.HasMipTreatHighMagnitudeBoundsAsInfinity) {
12455 MipTreatHighMagnitudeBoundsAsInfinity = other.MipTreatHighMagnitudeBoundsAsInfinity;
12457 if (other.HasMipDropTolerance) {
12458 MipDropTolerance = other.MipDropTolerance;
12460 if (other.HasMipPresolveLevel) {
12461 MipPresolveLevel = other.MipPresolveLevel;
12463 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
12466 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
12467 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
12468 public void MergeFrom(pb::CodedInputStream input) {
12469 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
12470 input.ReadRawMessage(
this);
12473 while ((tag = input.ReadTag()) != 0) {
12476 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
12479 PreferredVariableOrder = (global::Google.OrTools.Sat.SatParameters.Types.VariableOrder) input.ReadEnum();
12483 InitialPolarity = (global::Google.OrTools.Sat.SatParameters.Types.Polarity) input.ReadEnum();
12487 MinimizationAlgorithm = (global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm) input.ReadEnum();
12491 ClauseCleanupPeriod = input.ReadInt32();
12495 ClauseCleanupTarget = input.ReadInt32();
12499 VariableActivityDecay = input.ReadDouble();
12503 MaxVariableActivityValue = input.ReadDouble();
12507 ClauseActivityDecay = input.ReadDouble();
12511 MaxClauseActivityValue = input.ReadDouble();
12515 GlucoseMaxDecay = input.ReadDouble();
12519 GlucoseDecayIncrement = input.ReadDouble();
12523 GlucoseDecayIncrementPeriod = input.ReadInt32();
12527 RestartPeriod = input.ReadInt32();
12531 RandomSeed = input.ReadInt32();
12535 RandomBranchesRatio = input.ReadDouble();
12539 BinaryMinimizationAlgorithm = (global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm) input.ReadEnum();
12543 UseOptimizationHints = input.ReadBool();
12547 MaxTimeInSeconds = input.ReadDouble();
12551 MaxNumberOfConflicts = input.ReadInt64();
12555 MaxMemoryInMb = input.ReadInt64();
12559 LogSearchProgress = input.ReadBool();
12563 UsePbResolution = input.ReadBool();
12567 UsePhaseSaving = input.ReadBool();
12571 RandomPolarityRatio = input.ReadDouble();
12575 PbCleanupIncrement = input.ReadInt32();
12579 PbCleanupRatio = input.ReadDouble();
12583 MinimizeReductionDuringPbResolution = input.ReadBool();
12587 CountAssumptionLevelsInLbd = input.ReadBool();
12591 CoreMinimizationLevel = input.ReadInt32();
12595 MaxSatAssumptionOrder = (global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder) input.ReadEnum();
12599 MaxSatReverseAssumptionOrder = input.ReadBool();
12603 MaxSatStratification = (global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm) input.ReadEnum();
12607 PresolveBveThreshold = input.ReadInt32();
12611 PresolveBveClauseWeight = input.ReadInt32();
12615 SubsumptionDuringConflictAnalysis = input.ReadBool();
12619 PresolveProbingDeterministicTimeLimit = input.ReadDouble();
12623 ClauseCleanupProtection = (global::Google.OrTools.Sat.SatParameters.Types.ClauseProtection) input.ReadEnum();
12627 ClauseCleanupLbdBound = input.ReadInt32();
12631 ClauseCleanupOrdering = (global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering) input.ReadEnum();
12636 restartAlgorithms_.AddEntriesFrom(input, _repeated_restartAlgorithms_codec);
12640 RestartRunningWindowSize = input.ReadInt32();
12644 RestartDlAverageRatio = input.ReadDouble();
12648 UseBlockingRestart = input.ReadBool();
12652 BlockingRestartWindowSize = input.ReadInt32();
12656 BlockingRestartMultiplier = input.ReadDouble();
12660 MaxDeterministicTime = input.ReadDouble();
12664 NumConflictsBeforeStrategyChanges = input.ReadInt32();
12668 StrategyChangeIncreaseRatio = input.ReadDouble();
12672 DefaultRestartAlgorithms = input.ReadString();
12676 RestartLbdAverageRatio = input.ReadDouble();
12680 PresolveUseBva = input.ReadBool();
12684 PresolveBvaThreshold = input.ReadInt32();
12688 UsePrecedencesInDisjunctiveConstraint = input.ReadBool();
12692 UseErwaHeuristic = input.ReadBool();
12696 InitialVariablesActivity = input.ReadDouble();
12700 AlsoBumpVariablesInConflictReasons = input.ReadBool();
12704 UseOverloadCheckerInCumulative = input.ReadBool();
12708 UseTimetableEdgeFindingInCumulative = input.ReadBool();
12712 UseDisjunctiveConstraintInCumulative = input.ReadBool();
12716 SearchBranching = (global::Google.OrTools.Sat.SatParameters.Types.SearchBranching) input.ReadEnum();
12720 OptimizeWithCore = input.ReadBool();
12724 FindMultipleCores = input.ReadBool();
12728 OptimizeWithMaxHs = input.ReadBool();
12732 CpModelPresolve = input.ReadBool();
12736 EnumerateAllSolutions = input.ReadBool();
12740 PresolveBlockedClause = input.ReadBool();
12744 CoverOptimization = input.ReadBool();
12748 LinearizationLevel = input.ReadInt32();
12752 MaxNumCuts = input.ReadInt32();
12756 OnlyAddCutsAtLevelZero = input.ReadBool();
12760 CpModelUseSatPresolve = input.ReadBool();
12764 ExploitIntegerLpSolution = input.ReadBool();
12768 AutoDetectGreaterThanAtLeastOneOf = input.ReadBool();
12772 StopAfterFirstSolution = input.ReadBool();
12776 BinarySearchNumConflicts = input.ReadInt32();
12780 NumSearchWorkers = input.ReadInt32();
12784 UseLnsOnly = input.ReadBool();
12788 RandomizeSearch = input.ReadBool();
12792 SearchRandomVariablePoolSize = input.ReadInt64();
12796 InstantiateAllVariables = input.ReadBool();
12800 BooleanEncodingLevel = input.ReadInt32();
12804 UseOptionalVariables = input.ReadBool();
12808 UseExactLpReason = input.ReadBool();
12812 CpModelProbingLevel = input.ReadInt32();
12816 AddLpConstraintsLazily = input.ReadBool();
12820 ShareObjectiveBounds = input.ReadBool();
12824 ShareLevelZeroBounds = input.ReadBool();
12828 MinOrthogonalityForLpConstraints = input.ReadDouble();
12832 ExploitAllLpSolution = input.ReadBool();
12836 AddCgCuts = input.ReadBool();
12840 MaxIntegerRoundingScaling = input.ReadInt32();
12844 AddMirCuts = input.ReadBool();
12848 MaxConsecutiveInactiveCount = input.ReadInt32();
12852 NewConstraintsBatchSize = input.ReadInt32();
12856 PseudoCostReliabilityThreshold = input.ReadInt64();
12860 MipMaxBound = input.ReadDouble();
12864 MipVarScaling = input.ReadDouble();
12868 MipWantedPrecision = input.ReadDouble();
12872 MipMaxActivityExponent = input.ReadInt32();
12876 MipCheckPrecision = input.ReadDouble();
12880 UseRinsLns = input.ReadBool();
12884 ExploitBestSolution = input.ReadBool();
12888 ExploitObjective = input.ReadBool();
12892 FillTightenedDomainsInResponse = input.ReadBool();
12896 UseCombinedNoOverlap = input.ReadBool();
12900 InterleaveBatchSize = input.ReadInt32();
12904 CatchSigintSignal = input.ReadBool();
12908 InterleaveSearch = input.ReadBool();
12912 DiversifyLnsParams = input.ReadBool();
12916 MaxPresolveIterations = input.ReadInt32();
12920 UseImpliedBounds = input.ReadBool();
12924 MergeNoOverlapWorkLimit = input.ReadDouble();
12928 MergeAtMostOneWorkLimit = input.ReadDouble();
12932 PresolveSubstitutionLevel = input.ReadInt32();
12936 MaxAllDiffCutSize = input.ReadInt32();
12940 StopAfterPresolve = input.ReadBool();
12944 DebugMaxNumPresolveOperations = input.ReadInt32();
12948 AddLinMaxCuts = input.ReadBool();
12952 HintConflictLimit = input.ReadInt32();
12956 MaxCutRoundsAtLevelZero = input.ReadInt32();
12960 CutMaxActiveCountValue = input.ReadDouble();
12964 CutActiveCountDecay = input.ReadDouble();
12968 CutCleanupTarget = input.ReadInt32();
12972 AbsoluteGapLimit = input.ReadDouble();
12976 RelativeGapLimit = input.ReadDouble();
12980 ExploitRelaxationSolution = input.ReadBool();
12984 DebugPostsolveWithFullSolver = input.ReadBool();
12988 UseSatInprocessing = input.ReadBool();
12992 UseFeasibilityPump = input.ReadBool();
12996 FpRounding = (global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod) input.ReadEnum();
13000 MipAutomaticallyScaleVariables = input.ReadBool();
13004 RepairHint = input.ReadBool();
13008 PolarityRephaseIncrement = input.ReadInt32();
13012 AddZeroHalfCuts = input.ReadBool();
13016 ExpandAlldiffConstraints = input.ReadBool();
13020 Name = input.ReadString();
13024 AddCliqueCuts = input.ReadBool();
13028 KeepAllFeasibleSolutionsInPresolve = input.ReadBool();
13032 PresolveExtractIntegerEnforcement = input.ReadBool();
13036 PolishLpSolution = input.ReadBool();
13040 UseProbingSearch = input.ReadBool();
13044 ConvertIntervals = input.ReadBool();
13048 PermuteVariableRandomly = input.ReadBool();
13052 PermutePresolveConstraintOrder = input.ReadBool();
13056 UseAbslRandom = input.ReadBool();
13060 DisableConstraintExpansion = input.ReadBool();
13064 ExpandReservoirConstraints = input.ReadBool();
13068 SymmetryLevel = input.ReadInt32();
13072 LogPrefix = input.ReadString();
13076 LogToStdout = input.ReadBool();
13080 LogToResponse = input.ReadBool();
13084 OptimizeWithLbTreeSearch = input.ReadBool();
13088 LogSubsolverStatistics = input.ReadBool();
13092 ClauseCleanupRatio = input.ReadDouble();
13096 MaxDomainSizeWhenEncodingEqNeqConstraints = input.ReadInt32();
13100 FixVariablesToTheirHintedValue = input.ReadBool();
13104 SolutionPoolSize = input.ReadInt32();
13108 FillAdditionalSolutionsInResponse = input.ReadBool();
13112 DebugCrashOnBadHint = input.ReadBool();
13116 CutLevel = input.ReadInt32();
13120 AddObjectiveCut = input.ReadBool();
13124 MipComputeTrueObjectiveBound = input.ReadBool();
13128 MipMaxValidMagnitude = input.ReadDouble();
13132 UseTimetablingInNoOverlap2D = input.ReadBool();
13136 PresolveInclusionWorkLimit = input.ReadInt64();
13140 IgnoreNames = input.ReadBool();
13144 ShareBinaryClauses = input.ReadBool();
13148 UseShavingInProbingSearch = input.ReadBool();
13152 ShavingSearchDeterministicTime = input.ReadDouble();
13156 NumWorkers = input.ReadInt32();
13160 subsolvers_.AddEntriesFrom(input, _repeated_subsolvers_codec);
13164 ignoreSubsolvers_.AddEntriesFrom(input, _repeated_ignoreSubsolvers_codec);
13168 subsolverParams_.AddEntriesFrom(input, _repeated_subsolverParams_codec);
13172 UseEnergeticReasoningInNoOverlap2D = input.ReadBool();
13176 UseDualSchedulingHeuristics = input.ReadBool();
13180 UseHardPrecedencesInCumulative = input.ReadBool();
13184 DetectTableWithCost = input.ReadBool();
13188 TableCompressionLevel = input.ReadInt32();
13192 extraSubsolvers_.AddEntriesFrom(input, _repeated_extraSubsolvers_codec);
13196 ExploitAllPrecedences = input.ReadBool();
13200 PropagationLoopDetectionFactor = input.ReadDouble();
13204 OnlySolveIp = input.ReadBool();
13208 EncodeComplexLinearConstraintWithInteger = input.ReadBool();
13212 NewLinearPropagation = input.ReadBool();
13216 MipScaleLargeDomain = input.ReadBool();
13220 ProbingDeterministicTimeLimit = input.ReadDouble();
13224 RootLpIterations = input.ReadInt32();
13228 UseObjectiveLbSearch = input.ReadBool();
13232 MaxSizeToCreatePrecedenceLiteralsInDisjunctive = input.ReadInt32();
13236 UseStrongPropagationInDisjunctive = input.ReadBool();
13240 MipDropTolerance = input.ReadDouble();
13244 InferAllDiffs = input.ReadBool();
13248 FindBigLinearOverlap = input.ReadBool();
13252 SharedTreeNumWorkers = input.ReadInt32();
13256 UseSharedTreeSearch = input.ReadBool();
13260 SharedTreeWorkerObjectiveSplitProbability = input.ReadDouble();
13264 SharedTreeMaxNodesPerWorker = input.ReadInt32();
13268 SharedTreeSplitStrategy = (global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy) input.ReadEnum();
13272 UseLsOnly = input.ReadBool();
13276 FeasibilityJumpDecay = input.ReadDouble();
13280 NumViolationLs = input.ReadInt32();
13284 FeasibilityJumpVarRandomizationProbability = input.ReadDouble();
13288 FeasibilityJumpVarPerburbationRangeRatio = input.ReadDouble();
13292 ViolationLsPerturbationPeriod = input.ReadInt32();
13296 FeasibilityJumpEnableRestarts = input.ReadBool();
13300 StopAfterRootPropagation = input.ReadBool();
13304 UseObjectiveShavingSearch = input.ReadBool();
13308 UseLbRelaxLns = input.ReadBool();
13312 LinearSplitSize = input.ReadInt32();
13316 FeasibilityJumpLinearizationLevel = input.ReadInt32();
13320 FeasibilityJumpRestartFactor = input.ReadInt32();
13324 ViolationLsCompoundMoveProbability = input.ReadDouble();
13328 MaxNumIntervalsForTimetableEdgeFinding = input.ReadInt32();
13332 MipPresolveLevel = input.ReadInt32();
13336 PushAllTasksTowardStart = input.ReadBool();
13340 UseDynamicPrecedenceInDisjunctive = input.ReadBool();
13344 FeasibilityJumpMaxExpandedConstraintSize = input.ReadInt32();
13348 UseFeasibilityJump = input.ReadBool();
13352 LpPrimalTolerance = input.ReadDouble();
13356 LpDualTolerance = input.ReadDouble();
13360 UseDynamicPrecedenceInCumulative = input.ReadBool();
13364 UseExtendedProbing = input.ReadBool();
13368 AtMostOneMaxExpansionSize = input.ReadInt32();
13372 UseAreaEnergeticReasoningInNoOverlap2D = input.ReadBool();
13376 ProbingNumCombinationsLimit = input.ReadInt32();
13380 InprocessingDtimeRatio = input.ReadDouble();
13384 InprocessingProbingDtime = input.ReadDouble();
13388 InprocessingMinimizationDtime = input.ReadDouble();
13392 MaxPairsPairwiseReasoningInNoOverlap2D = input.ReadInt32();
13396 DetectLinearizedProduct = input.ReadBool();
13400 MipTreatHighMagnitudeBoundsAsInfinity = input.ReadBool();
13404 AddRltCuts = input.ReadBool();
13408 MaxLinMaxSizeForExpansion = input.ReadInt32();
13412 SharedTreeOpenLeavesPerWorker = input.ReadDouble();
13416 SharedTreeWorkerMinRestartsPerSubtree = input.ReadInt32();
13420 UseLns = input.ReadBool();
13424 SaveLpBasisInLbTreeSearch = input.ReadBool();
13428 ShareGlueClauses = input.ReadBool();
13432 UseConservativeScaleOverloadChecker = input.ReadBool();
13436 EncodeCumulativeAsReservoir = input.ReadBool();
13440 ExpandReservoirUsingCircuit = input.ReadBool();
13444 UseVariablesShavingSearch = input.ReadBool();
13448 ShavingSearchThreshold = input.ReadInt64();
13452 MaxNumDeterministicBatches = input.ReadInt32();
13456 FeasibilityJumpBatchDtime = input.ReadDouble();
13460 filterSubsolvers_.AddEntriesFrom(input, _repeated_filterSubsolvers_codec);
13464 NumFullSubsolvers = input.ReadInt32();
13468 SharedTreeWorkerEnableTrailSharing = input.ReadBool();
13476 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
13477 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
13478 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
13479 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
13481 while ((tag = input.ReadTag()) != 0) {
13484 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
13487 PreferredVariableOrder = (global::Google.OrTools.Sat.SatParameters.Types.VariableOrder) input.ReadEnum();
13491 InitialPolarity = (global::Google.OrTools.Sat.SatParameters.Types.Polarity) input.ReadEnum();
13495 MinimizationAlgorithm = (global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm) input.ReadEnum();
13499 ClauseCleanupPeriod = input.ReadInt32();
13503 ClauseCleanupTarget = input.ReadInt32();
13507 VariableActivityDecay = input.ReadDouble();
13511 MaxVariableActivityValue = input.ReadDouble();
13515 ClauseActivityDecay = input.ReadDouble();
13519 MaxClauseActivityValue = input.ReadDouble();
13523 GlucoseMaxDecay = input.ReadDouble();
13527 GlucoseDecayIncrement = input.ReadDouble();
13531 GlucoseDecayIncrementPeriod = input.ReadInt32();
13535 RestartPeriod = input.ReadInt32();
13539 RandomSeed = input.ReadInt32();
13543 RandomBranchesRatio = input.ReadDouble();
13547 BinaryMinimizationAlgorithm = (global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm) input.ReadEnum();
13551 UseOptimizationHints = input.ReadBool();
13555 MaxTimeInSeconds = input.ReadDouble();
13559 MaxNumberOfConflicts = input.ReadInt64();
13563 MaxMemoryInMb = input.ReadInt64();
13567 LogSearchProgress = input.ReadBool();
13571 UsePbResolution = input.ReadBool();
13575 UsePhaseSaving = input.ReadBool();
13579 RandomPolarityRatio = input.ReadDouble();
13583 PbCleanupIncrement = input.ReadInt32();
13587 PbCleanupRatio = input.ReadDouble();
13591 MinimizeReductionDuringPbResolution = input.ReadBool();
13595 CountAssumptionLevelsInLbd = input.ReadBool();
13599 CoreMinimizationLevel = input.ReadInt32();
13603 MaxSatAssumptionOrder = (global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder) input.ReadEnum();
13607 MaxSatReverseAssumptionOrder = input.ReadBool();
13611 MaxSatStratification = (global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm) input.ReadEnum();
13615 PresolveBveThreshold = input.ReadInt32();
13619 PresolveBveClauseWeight = input.ReadInt32();
13623 SubsumptionDuringConflictAnalysis = input.ReadBool();
13627 PresolveProbingDeterministicTimeLimit = input.ReadDouble();
13631 ClauseCleanupProtection = (global::Google.OrTools.Sat.SatParameters.Types.ClauseProtection) input.ReadEnum();
13635 ClauseCleanupLbdBound = input.ReadInt32();
13639 ClauseCleanupOrdering = (global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering) input.ReadEnum();
13644 restartAlgorithms_.AddEntriesFrom(ref input, _repeated_restartAlgorithms_codec);
13648 RestartRunningWindowSize = input.ReadInt32();
13652 RestartDlAverageRatio = input.ReadDouble();
13656 UseBlockingRestart = input.ReadBool();
13660 BlockingRestartWindowSize = input.ReadInt32();
13664 BlockingRestartMultiplier = input.ReadDouble();
13668 MaxDeterministicTime = input.ReadDouble();
13672 NumConflictsBeforeStrategyChanges = input.ReadInt32();
13676 StrategyChangeIncreaseRatio = input.ReadDouble();
13680 DefaultRestartAlgorithms = input.ReadString();
13684 RestartLbdAverageRatio = input.ReadDouble();
13688 PresolveUseBva = input.ReadBool();
13692 PresolveBvaThreshold = input.ReadInt32();
13696 UsePrecedencesInDisjunctiveConstraint = input.ReadBool();
13700 UseErwaHeuristic = input.ReadBool();
13704 InitialVariablesActivity = input.ReadDouble();
13708 AlsoBumpVariablesInConflictReasons = input.ReadBool();
13712 UseOverloadCheckerInCumulative = input.ReadBool();
13716 UseTimetableEdgeFindingInCumulative = input.ReadBool();
13720 UseDisjunctiveConstraintInCumulative = input.ReadBool();
13724 SearchBranching = (global::Google.OrTools.Sat.SatParameters.Types.SearchBranching) input.ReadEnum();
13728 OptimizeWithCore = input.ReadBool();
13732 FindMultipleCores = input.ReadBool();
13736 OptimizeWithMaxHs = input.ReadBool();
13740 CpModelPresolve = input.ReadBool();
13744 EnumerateAllSolutions = input.ReadBool();
13748 PresolveBlockedClause = input.ReadBool();
13752 CoverOptimization = input.ReadBool();
13756 LinearizationLevel = input.ReadInt32();
13760 MaxNumCuts = input.ReadInt32();
13764 OnlyAddCutsAtLevelZero = input.ReadBool();
13768 CpModelUseSatPresolve = input.ReadBool();
13772 ExploitIntegerLpSolution = input.ReadBool();
13776 AutoDetectGreaterThanAtLeastOneOf = input.ReadBool();
13780 StopAfterFirstSolution = input.ReadBool();
13784 BinarySearchNumConflicts = input.ReadInt32();
13788 NumSearchWorkers = input.ReadInt32();
13792 UseLnsOnly = input.ReadBool();
13796 RandomizeSearch = input.ReadBool();
13800 SearchRandomVariablePoolSize = input.ReadInt64();
13804 InstantiateAllVariables = input.ReadBool();
13808 BooleanEncodingLevel = input.ReadInt32();
13812 UseOptionalVariables = input.ReadBool();
13816 UseExactLpReason = input.ReadBool();
13820 CpModelProbingLevel = input.ReadInt32();
13824 AddLpConstraintsLazily = input.ReadBool();
13828 ShareObjectiveBounds = input.ReadBool();
13832 ShareLevelZeroBounds = input.ReadBool();
13836 MinOrthogonalityForLpConstraints = input.ReadDouble();
13840 ExploitAllLpSolution = input.ReadBool();
13844 AddCgCuts = input.ReadBool();
13848 MaxIntegerRoundingScaling = input.ReadInt32();
13852 AddMirCuts = input.ReadBool();
13856 MaxConsecutiveInactiveCount = input.ReadInt32();
13860 NewConstraintsBatchSize = input.ReadInt32();
13864 PseudoCostReliabilityThreshold = input.ReadInt64();
13868 MipMaxBound = input.ReadDouble();
13872 MipVarScaling = input.ReadDouble();
13876 MipWantedPrecision = input.ReadDouble();
13880 MipMaxActivityExponent = input.ReadInt32();
13884 MipCheckPrecision = input.ReadDouble();
13888 UseRinsLns = input.ReadBool();
13892 ExploitBestSolution = input.ReadBool();
13896 ExploitObjective = input.ReadBool();
13900 FillTightenedDomainsInResponse = input.ReadBool();
13904 UseCombinedNoOverlap = input.ReadBool();
13908 InterleaveBatchSize = input.ReadInt32();
13912 CatchSigintSignal = input.ReadBool();
13916 InterleaveSearch = input.ReadBool();
13920 DiversifyLnsParams = input.ReadBool();
13924 MaxPresolveIterations = input.ReadInt32();
13928 UseImpliedBounds = input.ReadBool();
13932 MergeNoOverlapWorkLimit = input.ReadDouble();
13936 MergeAtMostOneWorkLimit = input.ReadDouble();
13940 PresolveSubstitutionLevel = input.ReadInt32();
13944 MaxAllDiffCutSize = input.ReadInt32();
13948 StopAfterPresolve = input.ReadBool();
13952 DebugMaxNumPresolveOperations = input.ReadInt32();
13956 AddLinMaxCuts = input.ReadBool();
13960 HintConflictLimit = input.ReadInt32();
13964 MaxCutRoundsAtLevelZero = input.ReadInt32();
13968 CutMaxActiveCountValue = input.ReadDouble();
13972 CutActiveCountDecay = input.ReadDouble();
13976 CutCleanupTarget = input.ReadInt32();
13980 AbsoluteGapLimit = input.ReadDouble();
13984 RelativeGapLimit = input.ReadDouble();
13988 ExploitRelaxationSolution = input.ReadBool();
13992 DebugPostsolveWithFullSolver = input.ReadBool();
13996 UseSatInprocessing = input.ReadBool();
14000 UseFeasibilityPump = input.ReadBool();
14004 FpRounding = (global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod) input.ReadEnum();
14008 MipAutomaticallyScaleVariables = input.ReadBool();
14012 RepairHint = input.ReadBool();
14016 PolarityRephaseIncrement = input.ReadInt32();
14020 AddZeroHalfCuts = input.ReadBool();
14024 ExpandAlldiffConstraints = input.ReadBool();
14028 Name = input.ReadString();
14032 AddCliqueCuts = input.ReadBool();
14036 KeepAllFeasibleSolutionsInPresolve = input.ReadBool();
14040 PresolveExtractIntegerEnforcement = input.ReadBool();
14044 PolishLpSolution = input.ReadBool();
14048 UseProbingSearch = input.ReadBool();
14052 ConvertIntervals = input.ReadBool();
14056 PermuteVariableRandomly = input.ReadBool();
14060 PermutePresolveConstraintOrder = input.ReadBool();
14064 UseAbslRandom = input.ReadBool();
14068 DisableConstraintExpansion = input.ReadBool();
14072 ExpandReservoirConstraints = input.ReadBool();
14076 SymmetryLevel = input.ReadInt32();
14080 LogPrefix = input.ReadString();
14084 LogToStdout = input.ReadBool();
14088 LogToResponse = input.ReadBool();
14092 OptimizeWithLbTreeSearch = input.ReadBool();
14096 LogSubsolverStatistics = input.ReadBool();
14100 ClauseCleanupRatio = input.ReadDouble();
14104 MaxDomainSizeWhenEncodingEqNeqConstraints = input.ReadInt32();
14108 FixVariablesToTheirHintedValue = input.ReadBool();
14112 SolutionPoolSize = input.ReadInt32();
14116 FillAdditionalSolutionsInResponse = input.ReadBool();
14120 DebugCrashOnBadHint = input.ReadBool();
14124 CutLevel = input.ReadInt32();
14128 AddObjectiveCut = input.ReadBool();
14132 MipComputeTrueObjectiveBound = input.ReadBool();
14136 MipMaxValidMagnitude = input.ReadDouble();
14140 UseTimetablingInNoOverlap2D = input.ReadBool();
14144 PresolveInclusionWorkLimit = input.ReadInt64();
14148 IgnoreNames = input.ReadBool();
14152 ShareBinaryClauses = input.ReadBool();
14156 UseShavingInProbingSearch = input.ReadBool();
14160 ShavingSearchDeterministicTime = input.ReadDouble();
14164 NumWorkers = input.ReadInt32();
14168 subsolvers_.AddEntriesFrom(ref input, _repeated_subsolvers_codec);
14172 ignoreSubsolvers_.AddEntriesFrom(ref input, _repeated_ignoreSubsolvers_codec);
14176 subsolverParams_.AddEntriesFrom(ref input, _repeated_subsolverParams_codec);
14180 UseEnergeticReasoningInNoOverlap2D = input.ReadBool();
14184 UseDualSchedulingHeuristics = input.ReadBool();
14188 UseHardPrecedencesInCumulative = input.ReadBool();
14192 DetectTableWithCost = input.ReadBool();
14196 TableCompressionLevel = input.ReadInt32();
14200 extraSubsolvers_.AddEntriesFrom(ref input, _repeated_extraSubsolvers_codec);
14204 ExploitAllPrecedences = input.ReadBool();
14208 PropagationLoopDetectionFactor = input.ReadDouble();
14212 OnlySolveIp = input.ReadBool();
14216 EncodeComplexLinearConstraintWithInteger = input.ReadBool();
14220 NewLinearPropagation = input.ReadBool();
14224 MipScaleLargeDomain = input.ReadBool();
14228 ProbingDeterministicTimeLimit = input.ReadDouble();
14232 RootLpIterations = input.ReadInt32();
14236 UseObjectiveLbSearch = input.ReadBool();
14240 MaxSizeToCreatePrecedenceLiteralsInDisjunctive = input.ReadInt32();
14244 UseStrongPropagationInDisjunctive = input.ReadBool();
14248 MipDropTolerance = input.ReadDouble();
14252 InferAllDiffs = input.ReadBool();
14256 FindBigLinearOverlap = input.ReadBool();
14260 SharedTreeNumWorkers = input.ReadInt32();
14264 UseSharedTreeSearch = input.ReadBool();
14268 SharedTreeWorkerObjectiveSplitProbability = input.ReadDouble();
14272 SharedTreeMaxNodesPerWorker = input.ReadInt32();
14276 SharedTreeSplitStrategy = (global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy) input.ReadEnum();
14280 UseLsOnly = input.ReadBool();
14284 FeasibilityJumpDecay = input.ReadDouble();
14288 NumViolationLs = input.ReadInt32();
14292 FeasibilityJumpVarRandomizationProbability = input.ReadDouble();
14296 FeasibilityJumpVarPerburbationRangeRatio = input.ReadDouble();
14300 ViolationLsPerturbationPeriod = input.ReadInt32();
14304 FeasibilityJumpEnableRestarts = input.ReadBool();
14308 StopAfterRootPropagation = input.ReadBool();
14312 UseObjectiveShavingSearch = input.ReadBool();
14316 UseLbRelaxLns = input.ReadBool();
14320 LinearSplitSize = input.ReadInt32();
14324 FeasibilityJumpLinearizationLevel = input.ReadInt32();
14328 FeasibilityJumpRestartFactor = input.ReadInt32();
14332 ViolationLsCompoundMoveProbability = input.ReadDouble();
14336 MaxNumIntervalsForTimetableEdgeFinding = input.ReadInt32();
14340 MipPresolveLevel = input.ReadInt32();
14344 PushAllTasksTowardStart = input.ReadBool();
14348 UseDynamicPrecedenceInDisjunctive = input.ReadBool();
14352 FeasibilityJumpMaxExpandedConstraintSize = input.ReadInt32();
14356 UseFeasibilityJump = input.ReadBool();
14360 LpPrimalTolerance = input.ReadDouble();
14364 LpDualTolerance = input.ReadDouble();
14368 UseDynamicPrecedenceInCumulative = input.ReadBool();
14372 UseExtendedProbing = input.ReadBool();
14376 AtMostOneMaxExpansionSize = input.ReadInt32();
14380 UseAreaEnergeticReasoningInNoOverlap2D = input.ReadBool();
14384 ProbingNumCombinationsLimit = input.ReadInt32();
14388 InprocessingDtimeRatio = input.ReadDouble();
14392 InprocessingProbingDtime = input.ReadDouble();
14396 InprocessingMinimizationDtime = input.ReadDouble();
14400 MaxPairsPairwiseReasoningInNoOverlap2D = input.ReadInt32();
14404 DetectLinearizedProduct = input.ReadBool();
14408 MipTreatHighMagnitudeBoundsAsInfinity = input.ReadBool();
14412 AddRltCuts = input.ReadBool();
14416 MaxLinMaxSizeForExpansion = input.ReadInt32();
14420 SharedTreeOpenLeavesPerWorker = input.ReadDouble();
14424 SharedTreeWorkerMinRestartsPerSubtree = input.ReadInt32();
14428 UseLns = input.ReadBool();
14432 SaveLpBasisInLbTreeSearch = input.ReadBool();
14436 ShareGlueClauses = input.ReadBool();
14440 UseConservativeScaleOverloadChecker = input.ReadBool();
14444 EncodeCumulativeAsReservoir = input.ReadBool();
14448 ExpandReservoirUsingCircuit = input.ReadBool();
14452 UseVariablesShavingSearch = input.ReadBool();
14456 ShavingSearchThreshold = input.ReadInt64();
14460 MaxNumDeterministicBatches = input.ReadInt32();
14464 FeasibilityJumpBatchDtime = input.ReadDouble();
14468 filterSubsolvers_.AddEntriesFrom(ref input, _repeated_filterSubsolvers_codec);
14472 NumFullSubsolvers = input.ReadInt32();
14476 SharedTreeWorkerEnableTrailSharing = input.ReadBool();
14484 #region Nested types
14486 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
14487 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
14488 public static partial class Types {
14493 public enum VariableOrder {
14497 [pbr::OriginalName(
"IN_ORDER")] InOrder = 0,
14498 [pbr::OriginalName(
"IN_REVERSE_ORDER")] InReverseOrder = 1,
14499 [pbr::OriginalName(
"IN_RANDOM_ORDER")] InRandomOrder = 2,
14510 public enum Polarity {
14511 [pbr::OriginalName(
"POLARITY_TRUE")] True = 0,
14512 [pbr::OriginalName(
"POLARITY_FALSE")] False = 1,
14513 [pbr::OriginalName(
"POLARITY_RANDOM")] Random = 2,
14519 public enum ConflictMinimizationAlgorithm {
14520 [pbr::OriginalName(
"NONE")]
None = 0,
14521 [pbr::OriginalName(
"SIMPLE")] Simple = 1,
14522 [pbr::OriginalName(
"RECURSIVE")] Recursive = 2,
14523 [pbr::OriginalName(
"EXPERIMENTAL")] Experimental = 3,
14529 public enum BinaryMinizationAlgorithm {
14530 [pbr::OriginalName(
"NO_BINARY_MINIMIZATION")] NoBinaryMinimization = 0,
14531 [pbr::OriginalName(
"BINARY_MINIMIZATION_FIRST")] BinaryMinimizationFirst = 1,
14532 [pbr::OriginalName(
"BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION")] BinaryMinimizationFirstWithTransitiveReduction = 4,
14533 [pbr::OriginalName(
"BINARY_MINIMIZATION_WITH_REACHABILITY")] BinaryMinimizationWithReachability = 2,
14534 [pbr::OriginalName(
"EXPERIMENTAL_BINARY_MINIMIZATION")] ExperimentalBinaryMinimization = 3,
14546 [pbr::OriginalName(
"PROTECTION_NONE")] ProtectionNone = 0,
14550 [pbr::OriginalName(
"PROTECTION_ALWAYS")] ProtectionAlways = 1,
14554 [pbr::OriginalName(
"PROTECTION_LBD")] ProtectionLbd = 2,
14561 public enum ClauseOrdering {
14565 [pbr::OriginalName(
"CLAUSE_ACTIVITY")] ClauseActivity = 0,
14569 [pbr::OriginalName(
"CLAUSE_LBD")] ClauseLbd = 1,
14580 public enum RestartAlgorithm {
14581 [pbr::OriginalName(
"NO_RESTART")] NoRestart = 0,
14585 [pbr::OriginalName(
"LUBY_RESTART")] LubyRestart = 1,
14589 [pbr::OriginalName(
"DL_MOVING_AVERAGE_RESTART")] DlMovingAverageRestart = 2,
14593 [pbr::OriginalName(
"LBD_MOVING_AVERAGE_RESTART")] LbdMovingAverageRestart = 3,
14597 [pbr::OriginalName(
"FIXED_RESTART")] FixedRestart = 4,
14603 public enum MaxSatAssumptionOrder {
14604 [pbr::OriginalName(
"DEFAULT_ASSUMPTION_ORDER")] DefaultAssumptionOrder = 0,
14605 [pbr::OriginalName(
"ORDER_ASSUMPTION_BY_DEPTH")] OrderAssumptionByDepth = 1,
14606 [pbr::OriginalName(
"ORDER_ASSUMPTION_BY_WEIGHT")] OrderAssumptionByWeight = 2,
14612 public enum MaxSatStratificationAlgorithm {
14616 [pbr::OriginalName(
"STRATIFICATION_NONE")] StratificationNone = 0,
14621 [pbr::OriginalName(
"STRATIFICATION_DESCENT")] StratificationDescent = 1,
14628 [pbr::OriginalName(
"STRATIFICATION_ASCENT")] StratificationAscent = 2,
14634 public enum SearchBranching {
14641 [pbr::OriginalName(
"AUTOMATIC_SEARCH")] AutomaticSearch = 0,
14647 [pbr::OriginalName(
"FIXED_SEARCH")] FixedSearch = 1,
14651 [pbr::OriginalName(
"PORTFOLIO_SEARCH")] PortfolioSearch = 2,
14656 [pbr::OriginalName(
"LP_SEARCH")] LpSearch = 3,
14662 [pbr::OriginalName(
"PSEUDO_COST_SEARCH")] PseudoCostSearch = 4,
14668 [pbr::OriginalName(
"PORTFOLIO_WITH_QUICK_RESTART_SEARCH")] PortfolioWithQuickRestartSearch = 5,
14674 [pbr::OriginalName(
"HINT_SEARCH")] HintSearch = 6,
14681 [pbr::OriginalName(
"PARTIAL_FIXED_SEARCH")] PartialFixedSearch = 7,
14685 [pbr::OriginalName(
"RANDOMIZED_SEARCH")] RandomizedSearch = 8,
14688 public enum SharedTreeSplitStrategy {
14693 [pbr::OriginalName(
"SPLIT_STRATEGY_AUTO")] SplitStrategyAuto = 0,
14702 [pbr::OriginalName(
"SPLIT_STRATEGY_DISCREPANCY")] SplitStrategyDiscrepancy = 1,
14707 [pbr::OriginalName(
"SPLIT_STRATEGY_OBJECTIVE_LB")] SplitStrategyObjectiveLb = 2,
14711 [pbr::OriginalName(
"SPLIT_STRATEGY_BALANCED_TREE")] SplitStrategyBalancedTree = 3,
14715 [pbr::OriginalName(
"SPLIT_STRATEGY_FIRST_PROPOSAL")] SplitStrategyFirstProposal = 4,
14721 public enum FPRoundingMethod {
14725 [pbr::OriginalName(
"NEAREST_INTEGER")] NearestInteger = 0,
14731 [pbr::OriginalName(
"LOCK_BASED")] LockBased = 1,
14736 [pbr::OriginalName(
"ACTIVE_LOCK_BASED")] ActiveLockBased = 3,
14745 [pbr::OriginalName(
"PROPAGATION_ASSISTED")] PropagationAssisted = 2,
14757#endregion Designer generated code
1.12.0