pb

package
v0.0.0-...-9b02bcc Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 13, 2022 License: Apache-2.0 Imports: 5 Imported by: 0

README

The .proto files here are sourced from github.com/or-tools/ortools/sat.

Documentation

Index

Constants

View Source 
const (
	Default_SatParameters_Name                                           = string("")
	Default_SatParameters_PreferredVariableOrder                         = SatParameters_IN_ORDER
	Default_SatParameters_InitialPolarity                                = SatParameters_POLARITY_FALSE
	Default_SatParameters_UsePhaseSaving                                 = bool(true)
	Default_SatParameters_PolarityRephaseIncrement                       = int32(1000)
	Default_SatParameters_RandomPolarityRatio                            = float64(0)
	Default_SatParameters_RandomBranchesRatio                            = float64(0)
	Default_SatParameters_UseErwaHeuristic                               = bool(false)
	Default_SatParameters_InitialVariablesActivity                       = float64(0)
	Default_SatParameters_AlsoBumpVariablesInConflictReasons             = bool(false)
	Default_SatParameters_MinimizationAlgorithm                          = SatParameters_RECURSIVE
	Default_SatParameters_BinaryMinimizationAlgorithm                    = SatParameters_BINARY_MINIMIZATION_FIRST
	Default_SatParameters_SubsumptionDuringConflictAnalysis              = bool(true)
	Default_SatParameters_ClauseCleanupPeriod                            = int32(10000)
	Default_SatParameters_ClauseCleanupTarget                            = int32(10000)
	Default_SatParameters_ClauseCleanupProtection                        = SatParameters_PROTECTION_NONE
	Default_SatParameters_ClauseCleanupLbdBound                          = int32(5)
	Default_SatParameters_ClauseCleanupOrdering                          = SatParameters_CLAUSE_ACTIVITY
	Default_SatParameters_PbCleanupIncrement                             = int32(200)
	Default_SatParameters_PbCleanupRatio                                 = float64(0.5)
	Default_SatParameters_MinimizeWithPropagationRestartPeriod           = int32(10)
	Default_SatParameters_MinimizeWithPropagationNumDecisions            = int32(1000)
	Default_SatParameters_VariableActivityDecay                          = float64(0.8)
	Default_SatParameters_MaxVariableActivityValue                       = float64(1e+100)
	Default_SatParameters_GlucoseMaxDecay                                = float64(0.95)
	Default_SatParameters_GlucoseDecayIncrement                          = float64(0.01)
	Default_SatParameters_GlucoseDecayIncrementPeriod                    = int32(5000)
	Default_SatParameters_ClauseActivityDecay                            = float64(0.999)
	Default_SatParameters_MaxClauseActivityValue                         = float64(1e+20)
	Default_SatParameters_DefaultRestartAlgorithms                       = string("LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART")
	Default_SatParameters_RestartPeriod                                  = int32(50)
	Default_SatParameters_RestartRunningWindowSize                       = int32(50)
	Default_SatParameters_RestartDlAverageRatio                          = float64(1)
	Default_SatParameters_RestartLbdAverageRatio                         = float64(1)
	Default_SatParameters_UseBlockingRestart                             = bool(false)
	Default_SatParameters_BlockingRestartWindowSize                      = int32(5000)
	Default_SatParameters_BlockingRestartMultiplier                      = float64(1.4)
	Default_SatParameters_NumConflictsBeforeStrategyChanges              = int32(0)
	Default_SatParameters_StrategyChangeIncreaseRatio                    = float64(0)
	Default_SatParameters_MaxNumberOfConflicts                           = int64(9223372036854775807)
	Default_SatParameters_MaxMemoryInMb                                  = int64(10000)
	Default_SatParameters_AbsoluteGapLimit                               = float64(0)
	Default_SatParameters_RelativeGapLimit                               = float64(0)
	Default_SatParameters_TreatBinaryClausesSeparately                   = bool(true)
	Default_SatParameters_RandomSeed                                     = int32(1)
	Default_SatParameters_PermuteVariableRandomly                        = bool(false)
	Default_SatParameters_PermutePresolveConstraintOrder                 = bool(false)
	Default_SatParameters_UseAbslRandom                                  = bool(false)
	Default_SatParameters_LogSearchProgress                              = bool(false)
	Default_SatParameters_LogPrefix                                      = string("")
	Default_SatParameters_LogToStdout                                    = bool(true)
	Default_SatParameters_LogToResponse                                  = bool(false)
	Default_SatParameters_UsePbResolution                                = bool(false)
	Default_SatParameters_MinimizeReductionDuringPbResolution            = bool(false)
	Default_SatParameters_CountAssumptionLevelsInLbd                     = bool(true)
	Default_SatParameters_PresolveBveThreshold                           = int32(500)
	Default_SatParameters_PresolveBveClauseWeight                        = int32(3)
	Default_SatParameters_PresolveProbingDeterministicTimeLimit          = float64(30)
	Default_SatParameters_PresolveBlockedClause                          = bool(true)
	Default_SatParameters_PresolveUseBva                                 = bool(true)
	Default_SatParameters_PresolveBvaThreshold                           = int32(1)
	Default_SatParameters_MaxPresolveIterations                          = int32(3)
	Default_SatParameters_CpModelPresolve                                = bool(true)
	Default_SatParameters_CpModelPostsolveWithFullSolver                 = bool(false)
	Default_SatParameters_CpModelMaxNumPresolveOperations                = int32(0)
	Default_SatParameters_CpModelProbingLevel                            = int32(2)
	Default_SatParameters_CpModelUseSatPresolve                          = bool(true)
	Default_SatParameters_UseSatInprocessing                             = bool(false)
	Default_SatParameters_ExpandElementConstraints                       = bool(true)
	Default_SatParameters_ExpandAutomatonConstraints                     = bool(true)
	Default_SatParameters_ExpandTableConstraints                         = bool(true)
	Default_SatParameters_ExpandAlldiffConstraints                       = bool(false)
	Default_SatParameters_ExpandReservoirConstraints                     = bool(true)
	Default_SatParameters_DisableConstraintExpansion                     = bool(false)
	Default_SatParameters_MergeNoOverlapWorkLimit                        = float64(1e+12)
	Default_SatParameters_MergeAtMostOneWorkLimit                        = float64(1e+08)
	Default_SatParameters_PresolveSubstitutionLevel                      = int32(1)
	Default_SatParameters_PresolveExtractIntegerEnforcement              = bool(false)
	Default_SatParameters_UseOptimizationHints                           = bool(true)
	Default_SatParameters_MinimizeCore                                   = bool(true)
	Default_SatParameters_FindMultipleCores                              = bool(true)
	Default_SatParameters_CoverOptimization                              = bool(true)
	Default_SatParameters_MaxSatAssumptionOrder                          = SatParameters_DEFAULT_ASSUMPTION_ORDER
	Default_SatParameters_MaxSatReverseAssumptionOrder                   = bool(false)
	Default_SatParameters_MaxSatStratification                           = SatParameters_STRATIFICATION_DESCENT
	Default_SatParameters_UsePrecedencesInDisjunctiveConstraint          = bool(true)
	Default_SatParameters_UseOverloadCheckerInCumulativeConstraint       = bool(false)
	Default_SatParameters_UseTimetableEdgeFindingInCumulativeConstraint  = bool(false)
	Default_SatParameters_UseDisjunctiveConstraintInCumulativeConstraint = bool(true)
	Default_SatParameters_LinearizationLevel                             = int32(1)
	Default_SatParameters_BooleanEncodingLevel                           = int32(1)
	Default_SatParameters_MaxNumCuts                                     = int32(10000)
	Default_SatParameters_OnlyAddCutsAtLevelZero                         = bool(false)
	Default_SatParameters_AddKnapsackCuts                                = bool(false)
	Default_SatParameters_AddCgCuts                                      = bool(true)
	Default_SatParameters_AddMirCuts                                     = bool(true)
	Default_SatParameters_AddZeroHalfCuts                                = bool(true)
	Default_SatParameters_AddCliqueCuts                                  = bool(true)
	Default_SatParameters_MaxAllDiffCutSize                              = int32(7)
	Default_SatParameters_AddLinMaxCuts                                  = bool(true)
	Default_SatParameters_MaxIntegerRoundingScaling                      = int32(600)
	Default_SatParameters_AddLpConstraintsLazily                         = bool(true)
	Default_SatParameters_MinOrthogonalityForLpConstraints               = float64(0.05)
	Default_SatParameters_MaxCutRoundsAtLevelZero                        = int32(1)
	Default_SatParameters_MaxConsecutiveInactiveCount                    = int32(100)
	Default_SatParameters_CutMaxActiveCountValue                         = float64(1e+10)
	Default_SatParameters_CutActiveCountDecay                            = float64(0.8)
	Default_SatParameters_CutCleanupTarget                               = int32(1000)
	Default_SatParameters_NewConstraintsBatchSize                        = int32(50)
	Default_SatParameters_SearchBranching                                = SatParameters_AUTOMATIC_SEARCH
	Default_SatParameters_HintConflictLimit                              = int32(10)
	Default_SatParameters_RepairHint                                     = bool(false)
	Default_SatParameters_ExploitIntegerLpSolution                       = bool(true)
	Default_SatParameters_ExploitAllLpSolution                           = bool(true)
	Default_SatParameters_ExploitBestSolution                            = bool(false)
	Default_SatParameters_ExploitRelaxationSolution                      = bool(false)
	Default_SatParameters_ExploitObjective                               = bool(true)
	Default_SatParameters_ProbingPeriodAtRoot                            = int64(0)
	Default_SatParameters_UseProbingSearch                               = bool(false)
	Default_SatParameters_PseudoCostReliabilityThreshold                 = int64(100)
	Default_SatParameters_OptimizeWithCore                               = bool(false)
	Default_SatParameters_BinarySearchNumConflicts                       = int32(-1)
	Default_SatParameters_OptimizeWithMaxHs                              = bool(false)
	Default_SatParameters_EnumerateAllSolutions                          = bool(false)
	Default_SatParameters_KeepAllFeasibleSolutionsInPresolve             = bool(false)
	Default_SatParameters_FillTightenedDomainsInResponse                 = bool(false)
	Default_SatParameters_InstantiateAllVariables                        = bool(true)
	Default_SatParameters_AutoDetectGreaterThanAtLeastOneOf              = bool(true)
	Default_SatParameters_StopAfterFirstSolution                         = bool(false)
	Default_SatParameters_StopAfterPresolve                              = bool(false)
	Default_SatParameters_NumSearchWorkers                               = int32(1)
	Default_SatParameters_InterleaveSearch                               = bool(false)
	Default_SatParameters_InterleaveBatchSize                            = int32(1)
	Default_SatParameters_ReduceMemoryUsageInInterleaveMode              = bool(false)
	Default_SatParameters_ShareObjectiveBounds                           = bool(true)
	Default_SatParameters_ShareLevelZeroBounds                           = bool(true)
	Default_SatParameters_UseLnsOnly                                     = bool(false)
	Default_SatParameters_LnsFocusOnDecisionVariables                    = bool(false)
	Default_SatParameters_LnsExpandIntervalsInConstraintGraph            = bool(true)
	Default_SatParameters_UseRinsLns                                     = bool(true)
	Default_SatParameters_UseFeasibilityPump                             = bool(true)
	Default_SatParameters_FpRounding                                     = SatParameters_PROPAGATION_ASSISTED
	Default_SatParameters_UseRelaxationLns                               = bool(false)
	Default_SatParameters_DiversifyLnsParams                             = bool(false)
	Default_SatParameters_RandomizeSearch                                = bool(false)
	Default_SatParameters_SearchRandomizationTolerance                   = int64(0)
	Default_SatParameters_UseOptionalVariables                           = bool(true)
	Default_SatParameters_UseExactLpReason                               = bool(true)
	Default_SatParameters_UseBranchingInLp                               = bool(false)
	Default_SatParameters_UseCombinedNoOverlap                           = bool(false)
	Default_SatParameters_CatchSigintSignal                              = bool(true)
	Default_SatParameters_UseImpliedBounds                               = bool(true)
	Default_SatParameters_PolishLpSolution                               = bool(false)
	Default_SatParameters_ConvertIntervals                               = bool(false)
	Default_SatParameters_SymmetryLevel                                  = int32(2)
	Default_SatParameters_MipMaxBound                                    = float64(1e+07)
	Default_SatParameters_MipVarScaling                                  = float64(1)
	Default_SatParameters_MipAutomaticallyScaleVariables                 = bool(true)
	Default_SatParameters_MipWantedPrecision                             = float64(1e-06)
	Default_SatParameters_MipMaxActivityExponent                         = int32(53)
	Default_SatParameters_MipCheckPrecision                              = float64(0.0001)
)

Default values for SatParameters fields.

Variables

View Source 
var (
	CpSolverStatus_name = map[int32]string{
		0: "UNKNOWN",
		1: "MODEL_INVALID",
		2: "FEASIBLE",
		3: "INFEASIBLE",
		4: "OPTIMAL",
	}
	CpSolverStatus_value = map[string]int32{
		"UNKNOWN":       0,
		"MODEL_INVALID": 1,
		"FEASIBLE":      2,
		"INFEASIBLE":    3,
		"OPTIMAL":       4,
	}
)

Enum value maps for CpSolverStatus.

View Source 
var (
	DecisionStrategyProto_VariableSelectionStrategy_name = map[int32]string{
		0: "CHOOSE_FIRST",
		1: "CHOOSE_LOWEST_MIN",
		2: "CHOOSE_HIGHEST_MAX",
		3: "CHOOSE_MIN_DOMAIN_SIZE",
		4: "CHOOSE_MAX_DOMAIN_SIZE",
	}
	DecisionStrategyProto_VariableSelectionStrategy_value = map[string]int32{
		"CHOOSE_FIRST":           0,
		"CHOOSE_LOWEST_MIN":      1,
		"CHOOSE_HIGHEST_MAX":     2,
		"CHOOSE_MIN_DOMAIN_SIZE": 3,
		"CHOOSE_MAX_DOMAIN_SIZE": 4,
	}
)

Enum value maps for DecisionStrategyProto_VariableSelectionStrategy.

View Source 
var (
	DecisionStrategyProto_DomainReductionStrategy_name = map[int32]string{
		0: "SELECT_MIN_VALUE",
		1: "SELECT_MAX_VALUE",
		2: "SELECT_LOWER_HALF",
		3: "SELECT_UPPER_HALF",
		4: "SELECT_MEDIAN_VALUE",
	}
	DecisionStrategyProto_DomainReductionStrategy_value = map[string]int32{
		"SELECT_MIN_VALUE":    0,
		"SELECT_MAX_VALUE":    1,
		"SELECT_LOWER_HALF":   2,
		"SELECT_UPPER_HALF":   3,
		"SELECT_MEDIAN_VALUE": 4,
	}
)

Enum value maps for DecisionStrategyProto_DomainReductionStrategy.

View Source 
var (
	SatParameters_VariableOrder_name = map[int32]string{
		0: "IN_ORDER",
		1: "IN_REVERSE_ORDER",
		2: "IN_RANDOM_ORDER",
	}
	SatParameters_VariableOrder_value = map[string]int32{
		"IN_ORDER":         0,
		"IN_REVERSE_ORDER": 1,
		"IN_RANDOM_ORDER":  2,
	}
)

Enum value maps for SatParameters_VariableOrder.

View Source 
var (
	SatParameters_Polarity_name = map[int32]string{
		0: "POLARITY_TRUE",
		1: "POLARITY_FALSE",
		2: "POLARITY_RANDOM",
		3: "POLARITY_WEIGHTED_SIGN",
		4: "POLARITY_REVERSE_WEIGHTED_SIGN",
	}
	SatParameters_Polarity_value = map[string]int32{
		"POLARITY_TRUE":                  0,
		"POLARITY_FALSE":                 1,
		"POLARITY_RANDOM":                2,
		"POLARITY_WEIGHTED_SIGN":         3,
		"POLARITY_REVERSE_WEIGHTED_SIGN": 4,
	}
)

Enum value maps for SatParameters_Polarity.

View Source 
var (
	SatParameters_ConflictMinimizationAlgorithm_name = map[int32]string{
		0: "NONE",
		1: "SIMPLE",
		2: "RECURSIVE",
		3: "EXPERIMENTAL",
	}
	SatParameters_ConflictMinimizationAlgorithm_value = map[string]int32{
		"NONE":         0,
		"SIMPLE":       1,
		"RECURSIVE":    2,
		"EXPERIMENTAL": 3,
	}
)

Enum value maps for SatParameters_ConflictMinimizationAlgorithm.

View Source 
var (
	SatParameters_BinaryMinizationAlgorithm_name = map[int32]string{
		0: "NO_BINARY_MINIMIZATION",
		1: "BINARY_MINIMIZATION_FIRST",
		4: "BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION",
		2: "BINARY_MINIMIZATION_WITH_REACHABILITY",
		3: "EXPERIMENTAL_BINARY_MINIMIZATION",
	}
	SatParameters_BinaryMinizationAlgorithm_value = map[string]int32{
		"NO_BINARY_MINIMIZATION":                              0,
		"BINARY_MINIMIZATION_FIRST":                           1,
		"BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION": 4,
		"BINARY_MINIMIZATION_WITH_REACHABILITY":               2,
		"EXPERIMENTAL_BINARY_MINIMIZATION":                    3,
	}
)

Enum value maps for SatParameters_BinaryMinizationAlgorithm.

View Source 
var (
	SatParameters_ClauseProtection_name = map[int32]string{
		0: "PROTECTION_NONE",
		1: "PROTECTION_ALWAYS",
		2: "PROTECTION_LBD",
	}
	SatParameters_ClauseProtection_value = map[string]int32{
		"PROTECTION_NONE":   0,
		"PROTECTION_ALWAYS": 1,
		"PROTECTION_LBD":    2,
	}
)

Enum value maps for SatParameters_ClauseProtection.

View Source 
var (
	SatParameters_ClauseOrdering_name = map[int32]string{
		0: "CLAUSE_ACTIVITY",
		1: "CLAUSE_LBD",
	}
	SatParameters_ClauseOrdering_value = map[string]int32{
		"CLAUSE_ACTIVITY": 0,
		"CLAUSE_LBD":      1,
	}
)

Enum value maps for SatParameters_ClauseOrdering.

View Source 
var (
	SatParameters_RestartAlgorithm_name = map[int32]string{
		0: "NO_RESTART",
		1: "LUBY_RESTART",
		2: "DL_MOVING_AVERAGE_RESTART",
		3: "LBD_MOVING_AVERAGE_RESTART",
		4: "FIXED_RESTART",
	}
	SatParameters_RestartAlgorithm_value = map[string]int32{
		"NO_RESTART":                 0,
		"LUBY_RESTART":               1,
		"DL_MOVING_AVERAGE_RESTART":  2,
		"LBD_MOVING_AVERAGE_RESTART": 3,
		"FIXED_RESTART":              4,
	}
)

Enum value maps for SatParameters_RestartAlgorithm.

View Source 
var (
	SatParameters_MaxSatAssumptionOrder_name = map[int32]string{
		0: "DEFAULT_ASSUMPTION_ORDER",
		1: "ORDER_ASSUMPTION_BY_DEPTH",
		2: "ORDER_ASSUMPTION_BY_WEIGHT",
	}
	SatParameters_MaxSatAssumptionOrder_value = map[string]int32{
		"DEFAULT_ASSUMPTION_ORDER":   0,
		"ORDER_ASSUMPTION_BY_DEPTH":  1,
		"ORDER_ASSUMPTION_BY_WEIGHT": 2,
	}
)

Enum value maps for SatParameters_MaxSatAssumptionOrder.

View Source 
var (
	SatParameters_MaxSatStratificationAlgorithm_name = map[int32]string{
		0: "STRATIFICATION_NONE",
		1: "STRATIFICATION_DESCENT",
		2: "STRATIFICATION_ASCENT",
	}
	SatParameters_MaxSatStratificationAlgorithm_value = map[string]int32{
		"STRATIFICATION_NONE":    0,
		"STRATIFICATION_DESCENT": 1,
		"STRATIFICATION_ASCENT":  2,
	}
)

Enum value maps for SatParameters_MaxSatStratificationAlgorithm.

View Source 
var (
	SatParameters_SearchBranching_name = map[int32]string{
		0: "AUTOMATIC_SEARCH",
		1: "FIXED_SEARCH",
		2: "PORTFOLIO_SEARCH",
		3: "LP_SEARCH",
		4: "PSEUDO_COST_SEARCH",
		5: "PORTFOLIO_WITH_QUICK_RESTART_SEARCH",
		6: "HINT_SEARCH",
	}
	SatParameters_SearchBranching_value = map[string]int32{
		"AUTOMATIC_SEARCH":                    0,
		"FIXED_SEARCH":                        1,
		"PORTFOLIO_SEARCH":                    2,
		"LP_SEARCH":                           3,
		"PSEUDO_COST_SEARCH":                  4,
		"PORTFOLIO_WITH_QUICK_RESTART_SEARCH": 5,
		"HINT_SEARCH":                         6,
	}
)

Enum value maps for SatParameters_SearchBranching.

View Source 
var (
	SatParameters_FPRoundingMethod_name = map[int32]string{
		0: "NEAREST_INTEGER",
		1: "LOCK_BASED",
		3: "ACTIVE_LOCK_BASED",
		2: "PROPAGATION_ASSISTED",
	}
	SatParameters_FPRoundingMethod_value = map[string]int32{
		"NEAREST_INTEGER":      0,
		"LOCK_BASED":           1,
		"ACTIVE_LOCK_BASED":    3,
		"PROPAGATION_ASSISTED": 2,
	}
)

Enum value maps for SatParameters_FPRoundingMethod.

View Source 
var (
	Default_SatParameters_MaxTimeInSeconds     = float64(math.Inf(+1))
	Default_SatParameters_MaxDeterministicTime = float64(math.Inf(+1))
)

Default values for SatParameters fields.

View Source 
var File_cp_model_proto protoreflect.FileDescriptor
View Source 
var File_sat_parameters_proto protoreflect.FileDescriptor

Functions

This section is empty.

Types

type AllDifferentConstraintProto 

type AllDifferentConstraintProto struct {
	Vars []int32 `protobuf:"varint,1,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	// contains filtered or unexported fields
}

All variables must take different values.

func (*AllDifferentConstraintProto) Descriptor deprecated 

func (*AllDifferentConstraintProto) Descriptor() ([]byte, []int)

Deprecated: Use AllDifferentConstraintProto.ProtoReflect.Descriptor instead.

func (*AllDifferentConstraintProto) GetVars 

func (x *AllDifferentConstraintProto) GetVars() []int32

func (*AllDifferentConstraintProto) ProtoMessage 

func (*AllDifferentConstraintProto) ProtoMessage()

func (*AllDifferentConstraintProto) ProtoReflect 

func (x *AllDifferentConstraintProto) ProtoReflect() protoreflect.Message

func (*AllDifferentConstraintProto) Reset 

func (x *AllDifferentConstraintProto) Reset()

func (*AllDifferentConstraintProto) String 

func (x *AllDifferentConstraintProto) String() string

type AutomatonConstraintProto 

type AutomatonConstraintProto struct {

	// A state is identified by a non-negative number. It is preferable to keep
	// all the states dense in says [0, num_states). The automaton starts at
	// starting_state and must finish in any of the final states.
	StartingState int64   `protobuf:"varint,2,opt,name=starting_state,json=startingState,proto3" json:"starting_state,omitempty"`
	FinalStates   []int64 `protobuf:"varint,3,rep,packed,name=final_states,json=finalStates,proto3" json:"final_states,omitempty"`
	// List of transitions (all 3 vectors have the same size). Both tail and head
	// are states, label is any variable value. No two outgoing transitions from
	// the same state can have the same label.
	TransitionTail  []int64 `protobuf:"varint,4,rep,packed,name=transition_tail,json=transitionTail,proto3" json:"transition_tail,omitempty"`
	TransitionHead  []int64 `protobuf:"varint,5,rep,packed,name=transition_head,json=transitionHead,proto3" json:"transition_head,omitempty"`
	TransitionLabel []int64 `protobuf:"varint,6,rep,packed,name=transition_label,json=transitionLabel,proto3" json:"transition_label,omitempty"`
	// The sequence of variables. The automaton is ran for vars_size() "steps" and
	// the value of vars[i] corresponds to the transition label at step i.
	Vars []int32 `protobuf:"varint,7,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	// contains filtered or unexported fields
}

This constraint forces a sequence of variables to be accepted by an automaton.

func (*AutomatonConstraintProto) Descriptor deprecated 

func (*AutomatonConstraintProto) Descriptor() ([]byte, []int)

Deprecated: Use AutomatonConstraintProto.ProtoReflect.Descriptor instead.

func (*AutomatonConstraintProto) GetFinalStates 

func (x *AutomatonConstraintProto) GetFinalStates() []int64

func (*AutomatonConstraintProto) GetStartingState 

func (x *AutomatonConstraintProto) GetStartingState() int64

func (*AutomatonConstraintProto) GetTransitionHead 

func (x *AutomatonConstraintProto) GetTransitionHead() []int64

func (*AutomatonConstraintProto) GetTransitionLabel 

func (x *AutomatonConstraintProto) GetTransitionLabel() []int64

func (*AutomatonConstraintProto) GetTransitionTail 

func (x *AutomatonConstraintProto) GetTransitionTail() []int64

func (*AutomatonConstraintProto) GetVars 

func (x *AutomatonConstraintProto) GetVars() []int32

func (*AutomatonConstraintProto) ProtoMessage 

func (*AutomatonConstraintProto) ProtoMessage()

func (*AutomatonConstraintProto) ProtoReflect 

func (x *AutomatonConstraintProto) ProtoReflect() protoreflect.Message

func (*AutomatonConstraintProto) Reset 

func (x *AutomatonConstraintProto) Reset()

func (*AutomatonConstraintProto) String 

func (x *AutomatonConstraintProto) String() string

type BoolArgumentProto 

type BoolArgumentProto struct {
	Literals []int32 `protobuf:"varint,1,rep,packed,name=literals,proto3" json:"literals,omitempty"`
	// contains filtered or unexported fields
}

Argument of the constraints of the form OP(literals).

func (*BoolArgumentProto) Descriptor deprecated 

func (*BoolArgumentProto) Descriptor() ([]byte, []int)

Deprecated: Use BoolArgumentProto.ProtoReflect.Descriptor instead.

func (*BoolArgumentProto) GetLiterals 

func (x *BoolArgumentProto) GetLiterals() []int32

func (*BoolArgumentProto) ProtoMessage 

func (*BoolArgumentProto) ProtoMessage()

func (*BoolArgumentProto) ProtoReflect 

func (x *BoolArgumentProto) ProtoReflect() protoreflect.Message

func (*BoolArgumentProto) Reset 

func (x *BoolArgumentProto) Reset()

func (*BoolArgumentProto) String 

func (x *BoolArgumentProto) String() string

type CircuitConstraintProto 

type CircuitConstraintProto struct {
	Tails    []int32 `protobuf:"varint,3,rep,packed,name=tails,proto3" json:"tails,omitempty"`
	Heads    []int32 `protobuf:"varint,4,rep,packed,name=heads,proto3" json:"heads,omitempty"`
	Literals []int32 `protobuf:"varint,5,rep,packed,name=literals,proto3" json:"literals,omitempty"`
	// contains filtered or unexported fields
}

The circuit constraint is defined on a graph where the arc presence are controlled by literals. Each arc is given by an index in the tails/heads/literals lists that must have the same size.

For now, we ignore node indices with no incident arc. All the other nodes must have exactly one incoming and one outgoing selected arc (i.e. literal at true). All the selected arcs that are not self-loops must form a single circuit. Note that multi-arcs are allowed, but only one of them will be true at the same time. Multi-self loop are disallowed though.

func (*CircuitConstraintProto) Descriptor deprecated 

func (*CircuitConstraintProto) Descriptor() ([]byte, []int)

Deprecated: Use CircuitConstraintProto.ProtoReflect.Descriptor instead.

func (*CircuitConstraintProto) GetHeads 

func (x *CircuitConstraintProto) GetHeads() []int32

func (*CircuitConstraintProto) GetLiterals 

func (x *CircuitConstraintProto) GetLiterals() []int32

func (*CircuitConstraintProto) GetTails 

func (x *CircuitConstraintProto) GetTails() []int32

func (*CircuitConstraintProto) ProtoMessage 

func (*CircuitConstraintProto) ProtoMessage()

func (*CircuitConstraintProto) ProtoReflect 

func (x *CircuitConstraintProto) ProtoReflect() protoreflect.Message

func (*CircuitConstraintProto) Reset 

func (x *CircuitConstraintProto) Reset()

func (*CircuitConstraintProto) String 

func (x *CircuitConstraintProto) String() string

type ConstraintProto 

type ConstraintProto struct {

	// For debug/logging only. Can be empty.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The constraint will be enforced iff all literals listed here are true. If
	// this is empty, then the constraint will always be enforced. An enforced
	// constraint must be satisfied, and an un-enforced one will simply be
	// ignored.
	//
	// This is also called half-reification. To have an equivalence between a
	// literal and a constraint (full reification), one must add both a constraint
	// (controlled by a literal l) and its negation (controlled by the negation of
	// l).
	//
	// Important: as of September 2018, only a few constraint support enforcement:
	// - bool_or, bool_and, linear: fully supported.
	// - interval: only support a single enforcement literal.
	// - other: no support (but can be added on a per-demand basis).
	EnforcementLiteral []int32 `protobuf:"varint,2,rep,packed,name=enforcement_literal,json=enforcementLiteral,proto3" json:"enforcement_literal,omitempty"`
	// The actual constraint with its arguments.
	//
	// Types that are assignable to Constraint:
	//	*ConstraintProto_BoolOr
	//	*ConstraintProto_BoolAnd
	//	*ConstraintProto_AtMostOne
	//	*ConstraintProto_ExactlyOne
	//	*ConstraintProto_BoolXor
	//	*ConstraintProto_IntDiv
	//	*ConstraintProto_IntMod
	//	*ConstraintProto_IntMax
	//	*ConstraintProto_LinMax
	//	*ConstraintProto_IntMin
	//	*ConstraintProto_LinMin
	//	*ConstraintProto_IntProd
	//	*ConstraintProto_Linear
	//	*ConstraintProto_AllDiff
	//	*ConstraintProto_Element
	//	*ConstraintProto_Circuit
	//	*ConstraintProto_Routes
	//	*ConstraintProto_Table
	//	*ConstraintProto_Automaton
	//	*ConstraintProto_Inverse
	//	*ConstraintProto_Reservoir
	//	*ConstraintProto_Interval
	//	*ConstraintProto_NoOverlap
	//	*ConstraintProto_NoOverlap_2D
	//	*ConstraintProto_Cumulative
	Constraint isConstraintProto_Constraint `protobuf_oneof:"constraint"`
	// contains filtered or unexported fields
}

Next id: 30

func (*ConstraintProto) Descriptor deprecated 

func (*ConstraintProto) Descriptor() ([]byte, []int)

Deprecated: Use ConstraintProto.ProtoReflect.Descriptor instead.

func (*ConstraintProto) GetAllDiff 

func (x *ConstraintProto) GetAllDiff() *AllDifferentConstraintProto

func (*ConstraintProto) GetAtMostOne 

func (x *ConstraintProto) GetAtMostOne() *BoolArgumentProto

func (*ConstraintProto) GetAutomaton 

func (x *ConstraintProto) GetAutomaton() *AutomatonConstraintProto

func (*ConstraintProto) GetBoolAnd 

func (x *ConstraintProto) GetBoolAnd() *BoolArgumentProto

func (*ConstraintProto) GetBoolOr 

func (x *ConstraintProto) GetBoolOr() *BoolArgumentProto

func (*ConstraintProto) GetBoolXor 

func (x *ConstraintProto) GetBoolXor() *BoolArgumentProto

func (*ConstraintProto) GetCircuit 

func (x *ConstraintProto) GetCircuit() *CircuitConstraintProto

func (*ConstraintProto) GetConstraint 

func (m *ConstraintProto) GetConstraint() isConstraintProto_Constraint

func (*ConstraintProto) GetCumulative 

func (x *ConstraintProto) GetCumulative() *CumulativeConstraintProto

func (*ConstraintProto) GetElement 

func (x *ConstraintProto) GetElement() *ElementConstraintProto

func (*ConstraintProto) GetEnforcementLiteral 

func (x *ConstraintProto) GetEnforcementLiteral() []int32

func (*ConstraintProto) GetExactlyOne 

func (x *ConstraintProto) GetExactlyOne() *BoolArgumentProto

func (*ConstraintProto) GetIntDiv 

func (x *ConstraintProto) GetIntDiv() *IntegerArgumentProto

func (*ConstraintProto) GetIntMax 

func (x *ConstraintProto) GetIntMax() *IntegerArgumentProto

func (*ConstraintProto) GetIntMin 

func (x *ConstraintProto) GetIntMin() *IntegerArgumentProto

func (*ConstraintProto) GetIntMod 

func (x *ConstraintProto) GetIntMod() *IntegerArgumentProto

func (*ConstraintProto) GetIntProd 

func (x *ConstraintProto) GetIntProd() *IntegerArgumentProto

func (*ConstraintProto) GetInterval 

func (x *ConstraintProto) GetInterval() *IntervalConstraintProto

func (*ConstraintProto) GetInverse 

func (x *ConstraintProto) GetInverse() *InverseConstraintProto

func (*ConstraintProto) GetLinMax 

func (x *ConstraintProto) GetLinMax() *LinearArgumentProto

func (*ConstraintProto) GetLinMin 

func (x *ConstraintProto) GetLinMin() *LinearArgumentProto

func (*ConstraintProto) GetLinear 

func (x *ConstraintProto) GetLinear() *LinearConstraintProto

func (*ConstraintProto) GetName 

func (x *ConstraintProto) GetName() string

func (*ConstraintProto) GetNoOverlap 

func (x *ConstraintProto) GetNoOverlap() *NoOverlapConstraintProto

func (*ConstraintProto) GetNoOverlap_2D 

func (x *ConstraintProto) GetNoOverlap_2D() *NoOverlap2DConstraintProto

func (*ConstraintProto) GetReservoir 

func (x *ConstraintProto) GetReservoir() *ReservoirConstraintProto

func (*ConstraintProto) GetRoutes 

func (x *ConstraintProto) GetRoutes() *RoutesConstraintProto

func (*ConstraintProto) GetTable 

func (x *ConstraintProto) GetTable() *TableConstraintProto

func (*ConstraintProto) ProtoMessage 

func (*ConstraintProto) ProtoMessage()

func (*ConstraintProto) ProtoReflect 

func (x *ConstraintProto) ProtoReflect() protoreflect.Message

func (*ConstraintProto) Reset 

func (x *ConstraintProto) Reset()

func (*ConstraintProto) String 

func (x *ConstraintProto) String() string

type ConstraintProto_AllDiff 

type ConstraintProto_AllDiff struct {
	// The all_diff constraint forces all variables to take different values.
	AllDiff *AllDifferentConstraintProto `protobuf:"bytes,13,opt,name=all_diff,json=allDiff,proto3,oneof"`
}

type ConstraintProto_AtMostOne 

type ConstraintProto_AtMostOne struct {
	// The at_most_one constraint enforces that no more than one literal is
	// true at the same time.
	//
	// Note that an at most one constraint of length n could be encoded with n
	// bool_and constraint with n-1 term on the right hand side. So in a sense,
	// this constraint contribute directly to the "implication-graph" or the
	// 2-SAT part of the model.
	//
	// This constraint does not support enforcement_literal. Just use a linear
	// constraint if you need to enforce it. You also do not need to use it
	// directly, we will extract it from the model in most situations.
	AtMostOne *BoolArgumentProto `protobuf:"bytes,26,opt,name=at_most_one,json=atMostOne,proto3,oneof"`
}

type ConstraintProto_Automaton 

type ConstraintProto_Automaton struct {
	// The automaton constraint forces a sequence of variables to be accepted
	// by an automaton.
	Automaton *AutomatonConstraintProto `protobuf:"bytes,17,opt,name=automaton,proto3,oneof"`
}

type ConstraintProto_BoolAnd 

type ConstraintProto_BoolAnd struct {
	// The bool_and constraint forces all of the literals to be true.
	//
	// This is a "redundant" constraint in the sense that this can easily be
	// encoded with many bool_or or at_most_one. It is just more space efficient
	// and handled slightly differently internally.
	BoolAnd *BoolArgumentProto `protobuf:"bytes,4,opt,name=bool_and,json=boolAnd,proto3,oneof"`
}

type ConstraintProto_BoolOr 

type ConstraintProto_BoolOr struct {
	// The bool_or constraint forces at least one literal to be true.
	BoolOr *BoolArgumentProto `protobuf:"bytes,3,opt,name=bool_or,json=boolOr,proto3,oneof"`
}

type ConstraintProto_BoolXor 

type ConstraintProto_BoolXor struct {
	// The bool_xor constraint forces an odd number of the literals to be true.
	BoolXor *BoolArgumentProto `protobuf:"bytes,5,opt,name=bool_xor,json=boolXor,proto3,oneof"`
}

type ConstraintProto_Circuit 

type ConstraintProto_Circuit struct {
	// The circuit constraint takes a graph and forces the arcs present
	// (with arc presence indicated by a literal) to form a unique cycle.
	Circuit *CircuitConstraintProto `protobuf:"bytes,15,opt,name=circuit,proto3,oneof"`
}

type ConstraintProto_Cumulative 

type ConstraintProto_Cumulative struct {
	// The cumulative constraint ensures that for any integer point, the sum
	// of the demands of the intervals containing that point does not exceed
	// the capacity.
	Cumulative *CumulativeConstraintProto `protobuf:"bytes,22,opt,name=cumulative,proto3,oneof"`
}

type ConstraintProto_Element 

type ConstraintProto_Element struct {
	// The element constraint forces the variable with the given index
	// to be equal to the target.
	Element *ElementConstraintProto `protobuf:"bytes,14,opt,name=element,proto3,oneof"`
}

type ConstraintProto_ExactlyOne 

type ConstraintProto_ExactlyOne struct {
	// The exactly_one constraint force exactly one literal to true and no more.
	//
	// Anytime a bool_or (it could have been called at_least_one) is included
	// into an at_most_one, then the bool_or is actually an exactly one
	// constraint, and the extra literal in the at_most_one can be set to false.
	// So in this sense, this constraint is not really needed. it is just here
	// for a better description of the problem structure and to facilitate some
	// algorithm.
	//
	// This constraint does not support enforcement_literal. Just use a linear
	// constraint if you need to enforce it. You also do not need to use it
	// directly, we will extract it from the model in most situations.
	ExactlyOne *BoolArgumentProto `protobuf:"bytes,29,opt,name=exactly_one,json=exactlyOne,proto3,oneof"`
}

type ConstraintProto_IntDiv 

type ConstraintProto_IntDiv struct {
	// The int_div constraint forces the target to equal vars[0] / vars[1].
	// In particular, vars[1] can never take the value 0.
	IntDiv *IntegerArgumentProto `protobuf:"bytes,7,opt,name=int_div,json=intDiv,proto3,oneof"`
}

type ConstraintProto_IntMax 

type ConstraintProto_IntMax struct {
	// The int_max constraint forces the target to equal the maximum of all
	// variables.
	//
	// The lin_max constraint forces the target to equal the maximum of all
	// linear expressions.
	//
	// TODO(user): Remove int_max in favor of lin_max.
	IntMax *IntegerArgumentProto `protobuf:"bytes,9,opt,name=int_max,json=intMax,proto3,oneof"`
}

type ConstraintProto_IntMin 

type ConstraintProto_IntMin struct {
	// The int_min constraint forces the target to equal the minimum of all
	// variables.
	//
	// The lin_min constraint forces the target to equal the minimum of all
	// linear expressions.
	//
	// TODO(user): Remove int_min in favor of lin_min.
	IntMin *IntegerArgumentProto `protobuf:"bytes,10,opt,name=int_min,json=intMin,proto3,oneof"`
}

type ConstraintProto_IntMod 

type ConstraintProto_IntMod struct {
	// The int_mod constraint forces the target to equal vars[0] % vars[1].
	// The domain of vars[1] must be strictly positive.
	IntMod *IntegerArgumentProto `protobuf:"bytes,8,opt,name=int_mod,json=intMod,proto3,oneof"`
}

type ConstraintProto_IntProd 

type ConstraintProto_IntProd struct {
	// The int_prod constraint forces the target to equal the product of all
	// variables. By convention, because we can just remove term equal to one,
	// the empty product forces the target to be one.
	//
	// TODO(user): Support more than two terms in the product.
	IntProd *IntegerArgumentProto `protobuf:"bytes,11,opt,name=int_prod,json=intProd,proto3,oneof"`
}

type ConstraintProto_Interval 

type ConstraintProto_Interval struct {
	// The interval constraint takes a start, end, and size, and forces
	// start + size == end.
	Interval *IntervalConstraintProto `protobuf:"bytes,19,opt,name=interval,proto3,oneof"`
}

type ConstraintProto_Inverse 

type ConstraintProto_Inverse struct {
	// The inverse constraint forces two arrays to be inverses of each other:
	// the values of one are the indices of the other, and vice versa.
	Inverse *InverseConstraintProto `protobuf:"bytes,18,opt,name=inverse,proto3,oneof"`
}

type ConstraintProto_LinMax 

type ConstraintProto_LinMax struct {
	LinMax *LinearArgumentProto `protobuf:"bytes,27,opt,name=lin_max,json=linMax,proto3,oneof"`
}

type ConstraintProto_LinMin 

type ConstraintProto_LinMin struct {
	LinMin *LinearArgumentProto `protobuf:"bytes,28,opt,name=lin_min,json=linMin,proto3,oneof"`
}

type ConstraintProto_Linear 

type ConstraintProto_Linear struct {
	// The linear constraint enforces a linear inequality among the variables,
	// such as 0 <= x + 2y <= 10.
	Linear *LinearConstraintProto `protobuf:"bytes,12,opt,name=linear,proto3,oneof"`
}

type ConstraintProto_NoOverlap 

type ConstraintProto_NoOverlap struct {
	// The no_overlap constraint prevents a set of intervals from
	// overlapping; in scheduling, this is called a disjunctive
	// constraint.
	NoOverlap *NoOverlapConstraintProto `protobuf:"bytes,20,opt,name=no_overlap,json=noOverlap,proto3,oneof"`
}

type ConstraintProto_NoOverlap_2D 

type ConstraintProto_NoOverlap_2D struct {
	// The no_overlap_2d constraint prevents a set of boxes from overlapping.
	NoOverlap_2D *NoOverlap2DConstraintProto `protobuf:"bytes,21,opt,name=no_overlap_2d,json=noOverlap2d,proto3,oneof"`
}

type ConstraintProto_Reservoir 

type ConstraintProto_Reservoir struct {
	// The reservoir constraint forces the sum of a set of active demands
	// to always be between a specified minimum and maximum value during
	// specific times.
	Reservoir *ReservoirConstraintProto `protobuf:"bytes,24,opt,name=reservoir,proto3,oneof"`
}

type ConstraintProto_Routes 

type ConstraintProto_Routes struct {
	// The routes constraint implements the vehicle routing problem.
	Routes *RoutesConstraintProto `protobuf:"bytes,23,opt,name=routes,proto3,oneof"`
}

type ConstraintProto_Table 

type ConstraintProto_Table struct {
	// The table constraint enforces what values a tuple of variables may
	// take.
	Table *TableConstraintProto `protobuf:"bytes,16,opt,name=table,proto3,oneof"`
}

type CpModelProto 

type CpModelProto struct {

	// For debug/logging only. Can be empty.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The associated Protos should be referred by their index in these fields.
	Variables   []*IntegerVariableProto `protobuf:"bytes,2,rep,name=variables,proto3" json:"variables,omitempty"`
	Constraints []*ConstraintProto      `protobuf:"bytes,3,rep,name=constraints,proto3" json:"constraints,omitempty"`
	// The objective to minimize. Can be empty for pure decision problems.
	Objective *CpObjectiveProto `protobuf:"bytes,4,opt,name=objective,proto3" json:"objective,omitempty"`
	// Defines the strategy that the solver should follow when the
	// search_branching parameter is set to FIXED_SEARCH. Note that this strategy
	// is also used as a heuristic when we are not in fixed search.
	//
	// Advanced Usage: if not all variables appears and the parameter
	// "instantiate_all_variables" is set to false, then the solver will not try
	// to instantiate the variables that do not appear. Thus, at the end of the
	// search, not all variables may be fixed and this is why we have the
	// solution_lower_bounds and solution_upper_bounds fields in the
	// CpSolverResponse.
	SearchStrategy []*DecisionStrategyProto `protobuf:"bytes,5,rep,name=search_strategy,json=searchStrategy,proto3" json:"search_strategy,omitempty"`
	// Solution hint.
	//
	// If a feasible or almost-feasible solution to the problem is already known,
	// it may be helpful to pass it to the solver so that it can be used. The
	// solver will try to use this information to create its initial feasible
	// solution.
	//
	// Note that it may not always be faster to give a hint like this to the
	// solver. There is also no guarantee that the solver will use this hint or
	// try to return a solution "close" to this assignment in case of multiple
	// optimal solutions.
	SolutionHint *PartialVariableAssignment `protobuf:"bytes,6,opt,name=solution_hint,json=solutionHint,proto3" json:"solution_hint,omitempty"`
	// A list of literals. The model will be solved assuming all these literals
	// are true. Compared to just fixing the domain of these literals, using this
	// mechanism is slower but allows in case the model is INFEASIBLE to get a
	// potentially small subset of them that can be used to explain the
	// infeasibility.
	//
	// Think (IIS), except when you are only concerned by the provided
	// assumptions. This is powerful as it allows to group a set of logicially
	// related constraint under only one enforcement literal which can potentially
	// give you a good and interpretable explanation for infeasiblity.
	//
	// Such infeasibility explanation will be available in the
	// sufficient_assumptions_for_infeasibility response field.
	Assumptions []int32 `protobuf:"varint,7,rep,packed,name=assumptions,proto3" json:"assumptions,omitempty"`
	// For now, this is not meant to be filled by a client writing a model, but
	// by our preprocessing step.
	//
	// Information about the symmetries of the feasible solution space.
	// These usually leaves the objective invariant.
	Symmetry *SymmetryProto `protobuf:"bytes,8,opt,name=symmetry,proto3" json:"symmetry,omitempty"`
	// contains filtered or unexported fields
}

A constraint programming problem.

func (*CpModelProto) Descriptor deprecated 

func (*CpModelProto) Descriptor() ([]byte, []int)

Deprecated: Use CpModelProto.ProtoReflect.Descriptor instead.

func (*CpModelProto) GetAssumptions 

func (x *CpModelProto) GetAssumptions() []int32

func (*CpModelProto) GetConstraints 

func (x *CpModelProto) GetConstraints() []*ConstraintProto

func (*CpModelProto) GetName 

func (x *CpModelProto) GetName() string

func (*CpModelProto) GetObjective 

func (x *CpModelProto) GetObjective() *CpObjectiveProto

func (*CpModelProto) GetSearchStrategy 

func (x *CpModelProto) GetSearchStrategy() []*DecisionStrategyProto

func (*CpModelProto) GetSolutionHint 

func (x *CpModelProto) GetSolutionHint() *PartialVariableAssignment

func (*CpModelProto) GetSymmetry 

func (x *CpModelProto) GetSymmetry() *SymmetryProto

func (*CpModelProto) GetVariables 

func (x *CpModelProto) GetVariables() []*IntegerVariableProto

func (*CpModelProto) ProtoMessage 

func (*CpModelProto) ProtoMessage()

func (*CpModelProto) ProtoReflect 

func (x *CpModelProto) ProtoReflect() protoreflect.Message

func (*CpModelProto) Reset 

func (x *CpModelProto) Reset()

func (*CpModelProto) String 

func (x *CpModelProto) String() string

type CpObjectiveProto 

type CpObjectiveProto struct {

	// The linear terms of the objective to minimize.
	// For a maximization problem, one can negate all coefficients in the
	// objective and set a scaling_factor to -1.
	Vars   []int32 `protobuf:"varint,1,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	Coeffs []int64 `protobuf:"varint,4,rep,packed,name=coeffs,proto3" json:"coeffs,omitempty"`
	// The displayed objective is always:
	//   scaling_factor * (sum(coefficients[i] * objective_vars[i]) + offset).
	// This is needed to have a consistent objective after presolve or when
	// scaling a double problem to express it with integers.
	//
	// Note that if scaling_factor is zero, then it is assumed to be 1, so that by
	// default these fields have no effect.
	Offset        float64 `protobuf:"fixed64,2,opt,name=offset,proto3" json:"offset,omitempty"`
	ScalingFactor float64 `protobuf:"fixed64,3,opt,name=scaling_factor,json=scalingFactor,proto3" json:"scaling_factor,omitempty"`
	// If non-empty, only look for an objective value in the given domain.
	// Note that this does not depend on the offset or scaling factor, it is a
	// domain on the sum of the objective terms only.
	Domain []int64 `protobuf:"varint,5,rep,packed,name=domain,proto3" json:"domain,omitempty"`
	// contains filtered or unexported fields
}

Optimization objective.

This is in a message because decision problems don't have any objective.

func (*CpObjectiveProto) Descriptor deprecated 

func (*CpObjectiveProto) Descriptor() ([]byte, []int)

Deprecated: Use CpObjectiveProto.ProtoReflect.Descriptor instead.

func (*CpObjectiveProto) GetCoeffs 

func (x *CpObjectiveProto) GetCoeffs() []int64

func (*CpObjectiveProto) GetDomain 

func (x *CpObjectiveProto) GetDomain() []int64

func (*CpObjectiveProto) GetOffset 

func (x *CpObjectiveProto) GetOffset() float64

func (*CpObjectiveProto) GetScalingFactor 

func (x *CpObjectiveProto) GetScalingFactor() float64

func (*CpObjectiveProto) GetVars 

func (x *CpObjectiveProto) GetVars() []int32

func (*CpObjectiveProto) ProtoMessage 

func (*CpObjectiveProto) ProtoMessage()

func (*CpObjectiveProto) ProtoReflect 

func (x *CpObjectiveProto) ProtoReflect() protoreflect.Message

func (*CpObjectiveProto) Reset 

func (x *CpObjectiveProto) Reset()

func (*CpObjectiveProto) String 

func (x *CpObjectiveProto) String() string

type CpSolverResponse 

type CpSolverResponse struct {

	// The status of the solve.
	Status CpSolverStatus `protobuf:"varint,1,opt,name=status,proto3,enum=operations_research.sat.CpSolverStatus" json:"status,omitempty"`
	// A feasible solution to the given problem. Depending on the returned status
	// it may be optimal or just feasible. This is in one-to-one correspondence
	// with a CpModelProto::variables repeated field and list the values of all
	// the variables.
	Solution []int64 `protobuf:"varint,2,rep,packed,name=solution,proto3" json:"solution,omitempty"`
	// Only make sense for an optimization problem. The objective value of the
	// returned solution if it is non-empty. If there is no solution, then for a
	// minimization problem, this will be an upper-bound of the objective of any
	// feasible solution, and a lower-bound for a maximization problem.
	ObjectiveValue float64 `protobuf:"fixed64,3,opt,name=objective_value,json=objectiveValue,proto3" json:"objective_value,omitempty"`
	// Only make sense for an optimization problem. A proven lower-bound on the
	// objective for a minimization problem, or a proven upper-bound for a
	// maximization problem.
	BestObjectiveBound float64 `protobuf:"fixed64,4,opt,name=best_objective_bound,json=bestObjectiveBound,proto3" json:"best_objective_bound,omitempty"`
	// Advanced usage.
	//
	// If the problem has some variables that are not fixed at the end of the
	// search (because of a particular search strategy in the CpModelProto) then
	// this will be used instead of filling the solution above. The two fields
	// will then contains the lower and upper bounds of each variable as they were
	// when the best "solution" was found.
	SolutionLowerBounds []int64 `` /* 129-byte string literal not displayed */
	SolutionUpperBounds []int64 `` /* 129-byte string literal not displayed */
	// Advanced usage.
	//
	// If the option fill_tightened_domains_in_response is set, then this field
	// will be a copy of the CpModelProto.variables where each domain has been
	// reduced using the information the solver was able to derive. Note that this
	// is only filled with the info derived during a normal search and we do not
	// have any dedicated algorithm to improve it.
	//
	// If the problem is a feasibility problem, then these bounds will be valid
	// for any feasible solution. If the problem is an optimization problem, then
	// these bounds will only be valid for any OPTIMAL solutions, it can exclude
	// sub-optimal feasible ones.
	TightenedVariables []*IntegerVariableProto `protobuf:"bytes,21,rep,name=tightened_variables,json=tightenedVariables,proto3" json:"tightened_variables,omitempty"`
	// A subset of the model "assumptions" field. This will only be filled if the
	// status is INFEASIBLE. This subset of assumption will be enough to still get
	// an infeasible problem.
	//
	// This is related to what is called the irreducible inconsistent subsystem or
	// IIS. Except one is only concerned by the provided assumptions. There is
	// also no guarantee that we return an irreducible (aka minimal subset).
	// However, this is based on SAT explanation and there is a good chance it is
	// not too large.
	//
	// If you really want a minimal subset, a possible way to get one is by
	// changing your model to minimize the number of assumptions at false, but
	// this is likely an harder problem to solve.
	//
	// TODO(user): Allows for returning multiple core at once.
	SufficientAssumptionsForInfeasibility []int32 `` /* 185-byte string literal not displayed */
	// This will be true iff the solver was asked to find all solutions to a
	// satisfiability problem (or all optimal solutions to an optimization
	// problem), and it was successful in doing so.
	//
	// TODO(user): Remove as we also use the OPTIMAL vs FEASIBLE status for that.
	AllSolutionsWereFound bool `` /* 129-byte string literal not displayed */
	// Some statistics about the solve.
	NumBooleans            int64   `protobuf:"varint,10,opt,name=num_booleans,json=numBooleans,proto3" json:"num_booleans,omitempty"`
	NumConflicts           int64   `protobuf:"varint,11,opt,name=num_conflicts,json=numConflicts,proto3" json:"num_conflicts,omitempty"`
	NumBranches            int64   `protobuf:"varint,12,opt,name=num_branches,json=numBranches,proto3" json:"num_branches,omitempty"`
	NumBinaryPropagations  int64   `` /* 128-byte string literal not displayed */
	NumIntegerPropagations int64   `` /* 131-byte string literal not displayed */
	NumRestarts            int64   `protobuf:"varint,24,opt,name=num_restarts,json=numRestarts,proto3" json:"num_restarts,omitempty"`
	NumLpIterations        int64   `protobuf:"varint,25,opt,name=num_lp_iterations,json=numLpIterations,proto3" json:"num_lp_iterations,omitempty"`
	WallTime               float64 `protobuf:"fixed64,15,opt,name=wall_time,json=wallTime,proto3" json:"wall_time,omitempty"`
	UserTime               float64 `protobuf:"fixed64,16,opt,name=user_time,json=userTime,proto3" json:"user_time,omitempty"`
	DeterministicTime      float64 `protobuf:"fixed64,17,opt,name=deterministic_time,json=deterministicTime,proto3" json:"deterministic_time,omitempty"`
	PrimalIntegral         float64 `protobuf:"fixed64,22,opt,name=primal_integral,json=primalIntegral,proto3" json:"primal_integral,omitempty"`
	// Additional information about how the solution was found.
	SolutionInfo string `protobuf:"bytes,20,opt,name=solution_info,json=solutionInfo,proto3" json:"solution_info,omitempty"`
	// The solve log will be filled if the parameter log_to_response is set to
	// true.
	SolveLog string `protobuf:"bytes,26,opt,name=solve_log,json=solveLog,proto3" json:"solve_log,omitempty"`
	// contains filtered or unexported fields
}

The response returned by a solver trying to solve a CpModelProto.

TODO(user): support returning multiple solutions. Look at the Stubby streaming API as we probably wants to get them as they are found. Next id: 27

func (*CpSolverResponse) Descriptor deprecated 

func (*CpSolverResponse) Descriptor() ([]byte, []int)

Deprecated: Use CpSolverResponse.ProtoReflect.Descriptor instead.

func (*CpSolverResponse) GetAllSolutionsWereFound 

func (x *CpSolverResponse) GetAllSolutionsWereFound() bool

func (*CpSolverResponse) GetBestObjectiveBound 

func (x *CpSolverResponse) GetBestObjectiveBound() float64

func (*CpSolverResponse) GetDeterministicTime 

func (x *CpSolverResponse) GetDeterministicTime() float64

func (*CpSolverResponse) GetNumBinaryPropagations 

func (x *CpSolverResponse) GetNumBinaryPropagations() int64

func (*CpSolverResponse) GetNumBooleans 

func (x *CpSolverResponse) GetNumBooleans() int64

func (*CpSolverResponse) GetNumBranches 

func (x *CpSolverResponse) GetNumBranches() int64

func (*CpSolverResponse) GetNumConflicts 

func (x *CpSolverResponse) GetNumConflicts() int64

func (*CpSolverResponse) GetNumIntegerPropagations 

func (x *CpSolverResponse) GetNumIntegerPropagations() int64

func (*CpSolverResponse) GetNumLpIterations 

func (x *CpSolverResponse) GetNumLpIterations() int64

func (*CpSolverResponse) GetNumRestarts 

func (x *CpSolverResponse) GetNumRestarts() int64

func (*CpSolverResponse) GetObjectiveValue 

func (x *CpSolverResponse) GetObjectiveValue() float64

func (*CpSolverResponse) GetPrimalIntegral 

func (x *CpSolverResponse) GetPrimalIntegral() float64

func (*CpSolverResponse) GetSolution 

func (x *CpSolverResponse) GetSolution() []int64

func (*CpSolverResponse) GetSolutionInfo 

func (x *CpSolverResponse) GetSolutionInfo() string

func (*CpSolverResponse) GetSolutionLowerBounds 

func (x *CpSolverResponse) GetSolutionLowerBounds() []int64

func (*CpSolverResponse) GetSolutionUpperBounds 

func (x *CpSolverResponse) GetSolutionUpperBounds() []int64

func (*CpSolverResponse) GetSolveLog 

func (x *CpSolverResponse) GetSolveLog() string

func (*CpSolverResponse) GetStatus 

func (x *CpSolverResponse) GetStatus() CpSolverStatus

func (*CpSolverResponse) GetSufficientAssumptionsForInfeasibility 

func (x *CpSolverResponse) GetSufficientAssumptionsForInfeasibility() []int32

func (*CpSolverResponse) GetTightenedVariables 

func (x *CpSolverResponse) GetTightenedVariables() []*IntegerVariableProto

func (*CpSolverResponse) GetUserTime 

func (x *CpSolverResponse) GetUserTime() float64

func (*CpSolverResponse) GetWallTime 

func (x *CpSolverResponse) GetWallTime() float64

func (*CpSolverResponse) ProtoMessage 

func (*CpSolverResponse) ProtoMessage()

func (*CpSolverResponse) ProtoReflect 

func (x *CpSolverResponse) ProtoReflect() protoreflect.Message

func (*CpSolverResponse) Reset 

func (x *CpSolverResponse) Reset()

func (*CpSolverResponse) String 

func (x *CpSolverResponse) String() string

type CpSolverStatus 

type CpSolverStatus int32

The status returned by a solver trying to solve a CpModelProto. 

const (
	// The status of the model is still unknown. A search limit has been reached
	// before any of the statuses below could be determined.
	CpSolverStatus_UNKNOWN CpSolverStatus = 0
	// The given CpModelProto didn't pass the validation step. You can get a
	// detailed error by calling ValidateCpModel(model_proto).
	CpSolverStatus_MODEL_INVALID CpSolverStatus = 1
	// A feasible solution has been found. But the search was stopped before we
	// could prove optimality or before we enumerated all solutions of a
	// feasibility problem (if asked).
	CpSolverStatus_FEASIBLE CpSolverStatus = 2
	// The problem has been proven infeasible.
	CpSolverStatus_INFEASIBLE CpSolverStatus = 3
	// An optimal feasible solution has been found.
	//
	// More generally, this status represent a success. So we also return OPTIMAL
	// if we find a solution for a pure feasiblity problem or if a gap limit has
	// been specified and we return a solution within this limit. In the case
	// where we need to return all the feasible solution, this status will only be
	// returned if we enumerated all of them; If we stopped before, we will return
	// FEASIBLE.
	CpSolverStatus_OPTIMAL CpSolverStatus = 4
)

func (CpSolverStatus) Descriptor 

func (CpSolverStatus) Descriptor() protoreflect.EnumDescriptor

func (CpSolverStatus) Enum 

func (x CpSolverStatus) Enum() *CpSolverStatus

func (CpSolverStatus) EnumDescriptor deprecated 

func (CpSolverStatus) EnumDescriptor() ([]byte, []int)

Deprecated: Use CpSolverStatus.Descriptor instead.

func (CpSolverStatus) Number 

func (x CpSolverStatus) Number() protoreflect.EnumNumber

func (CpSolverStatus) String 

func (x CpSolverStatus) String() string

func (CpSolverStatus) Type 

func (CpSolverStatus) Type() protoreflect.EnumType

type CumulativeConstraintProto 

type CumulativeConstraintProto struct {
	Capacity  int32   `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"`
	Intervals []int32 `protobuf:"varint,2,rep,packed,name=intervals,proto3" json:"intervals,omitempty"`
	Demands   []int32 `protobuf:"varint,3,rep,packed,name=demands,proto3" json:"demands,omitempty"` // Same size as intervals.
	// contains filtered or unexported fields
}

The sum of the demands of the intervals at each interval point cannot exceed a capacity. Note that intervals are interpreted as [start, end) and as such intervals like [2,3) and [3,4) do not overlap for the point of view of this constraint. Moreover, intervals of size zero are ignored.

func (*CumulativeConstraintProto) Descriptor deprecated 

func (*CumulativeConstraintProto) Descriptor() ([]byte, []int)

Deprecated: Use CumulativeConstraintProto.ProtoReflect.Descriptor instead.

func (*CumulativeConstraintProto) GetCapacity 

func (x *CumulativeConstraintProto) GetCapacity() int32

func (*CumulativeConstraintProto) GetDemands 

func (x *CumulativeConstraintProto) GetDemands() []int32

func (*CumulativeConstraintProto) GetIntervals 

func (x *CumulativeConstraintProto) GetIntervals() []int32

func (*CumulativeConstraintProto) ProtoMessage 

func (*CumulativeConstraintProto) ProtoMessage()

func (*CumulativeConstraintProto) ProtoReflect 

func (x *CumulativeConstraintProto) ProtoReflect() protoreflect.Message

func (*CumulativeConstraintProto) Reset 

func (x *CumulativeConstraintProto) Reset()

func (*CumulativeConstraintProto) String 

func (x *CumulativeConstraintProto) String() string

type DecisionStrategyProto 

type DecisionStrategyProto struct {

	// The variables to be considered for the next decision. The order matter and
	// is always used as a tie-breaker after the variable selection strategy
	// criteria defined below.
	Variables                 []int32                                         `protobuf:"varint,1,rep,packed,name=variables,proto3" json:"variables,omitempty"`
	VariableSelectionStrategy DecisionStrategyProto_VariableSelectionStrategy `` /* 216-byte string literal not displayed */
	DomainReductionStrategy   DecisionStrategyProto_DomainReductionStrategy   `` /* 208-byte string literal not displayed */
	Transformations           []*DecisionStrategyProto_AffineTransformation   `protobuf:"bytes,4,rep,name=transformations,proto3" json:"transformations,omitempty"`
	// contains filtered or unexported fields
}

Define the strategy to follow when the solver needs to take a new decision. Note that this strategy is only defined on a subset of variables.

func (*DecisionStrategyProto) Descriptor deprecated 

func (*DecisionStrategyProto) Descriptor() ([]byte, []int)

Deprecated: Use DecisionStrategyProto.ProtoReflect.Descriptor instead.

func (*DecisionStrategyProto) GetDomainReductionStrategy 

func (x *DecisionStrategyProto) GetDomainReductionStrategy() DecisionStrategyProto_DomainReductionStrategy

func (*DecisionStrategyProto) GetTransformations 

func (x *DecisionStrategyProto) GetTransformations() []*DecisionStrategyProto_AffineTransformation

func (*DecisionStrategyProto) GetVariableSelectionStrategy 

func (x *DecisionStrategyProto) GetVariableSelectionStrategy() DecisionStrategyProto_VariableSelectionStrategy

func (*DecisionStrategyProto) GetVariables 

func (x *DecisionStrategyProto) GetVariables() []int32

func (*DecisionStrategyProto) ProtoMessage 

func (*DecisionStrategyProto) ProtoMessage()

func (*DecisionStrategyProto) ProtoReflect 

func (x *DecisionStrategyProto) ProtoReflect() protoreflect.Message

func (*DecisionStrategyProto) Reset 

func (x *DecisionStrategyProto) Reset()

func (*DecisionStrategyProto) String 

func (x *DecisionStrategyProto) String() string

type DecisionStrategyProto_AffineTransformation 

type DecisionStrategyProto_AffineTransformation struct {
	Index         int32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Offset        int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	PositiveCoeff int64 `protobuf:"varint,3,opt,name=positive_coeff,json=positiveCoeff,proto3" json:"positive_coeff,omitempty"`
	// contains filtered or unexported fields
}

Advanced usage. Some of the variable listed above may have been transformed by the presolve so this is needed to properly follow the given selection strategy. Instead of using a value X for variables[index], we will use positive_coeff * X + offset instead.

func (*DecisionStrategyProto_AffineTransformation) Descriptor deprecated 

func (*DecisionStrategyProto_AffineTransformation) Descriptor() ([]byte, []int)

Deprecated: Use DecisionStrategyProto_AffineTransformation.ProtoReflect.Descriptor instead.

func (*DecisionStrategyProto_AffineTransformation) GetIndex 

func (x *DecisionStrategyProto_AffineTransformation) GetIndex() int32

func (*DecisionStrategyProto_AffineTransformation) GetOffset 

func (x *DecisionStrategyProto_AffineTransformation) GetOffset() int64

func (*DecisionStrategyProto_AffineTransformation) GetPositiveCoeff 

func (x *DecisionStrategyProto_AffineTransformation) GetPositiveCoeff() int64

func (*DecisionStrategyProto_AffineTransformation) ProtoMessage 

func (*DecisionStrategyProto_AffineTransformation) ProtoMessage()

func (*DecisionStrategyProto_AffineTransformation) ProtoReflect 

func (x *DecisionStrategyProto_AffineTransformation) ProtoReflect() protoreflect.Message

func (*DecisionStrategyProto_AffineTransformation) Reset 

func (x *DecisionStrategyProto_AffineTransformation) Reset()

func (*DecisionStrategyProto_AffineTransformation) String 

func (x *DecisionStrategyProto_AffineTransformation) String() string

type DecisionStrategyProto_DomainReductionStrategy 

type DecisionStrategyProto_DomainReductionStrategy int32

Once a variable has been chosen, this enum describe what decision is taken on its domain.

TODO(user): extend as needed. 

const (
	DecisionStrategyProto_SELECT_MIN_VALUE    DecisionStrategyProto_DomainReductionStrategy = 0
	DecisionStrategyProto_SELECT_MAX_VALUE    DecisionStrategyProto_DomainReductionStrategy = 1
	DecisionStrategyProto_SELECT_LOWER_HALF   DecisionStrategyProto_DomainReductionStrategy = 2
	DecisionStrategyProto_SELECT_UPPER_HALF   DecisionStrategyProto_DomainReductionStrategy = 3
	DecisionStrategyProto_SELECT_MEDIAN_VALUE DecisionStrategyProto_DomainReductionStrategy = 4
)

func (DecisionStrategyProto_DomainReductionStrategy) Descriptor 

func (DecisionStrategyProto_DomainReductionStrategy) Descriptor() protoreflect.EnumDescriptor

func (DecisionStrategyProto_DomainReductionStrategy) Enum 

func (x DecisionStrategyProto_DomainReductionStrategy) Enum() *DecisionStrategyProto_DomainReductionStrategy

func (DecisionStrategyProto_DomainReductionStrategy) EnumDescriptor deprecated 

func (DecisionStrategyProto_DomainReductionStrategy) EnumDescriptor() ([]byte, []int)

Deprecated: Use DecisionStrategyProto_DomainReductionStrategy.Descriptor instead.

func (DecisionStrategyProto_DomainReductionStrategy) Number 

func (x DecisionStrategyProto_DomainReductionStrategy) Number() protoreflect.EnumNumber

func (DecisionStrategyProto_DomainReductionStrategy) String 

func (x DecisionStrategyProto_DomainReductionStrategy) String() string

func (DecisionStrategyProto_DomainReductionStrategy) Type 

func (DecisionStrategyProto_DomainReductionStrategy) Type() protoreflect.EnumType

type DecisionStrategyProto_VariableSelectionStrategy 

type DecisionStrategyProto_VariableSelectionStrategy int32

The order in which the variables above should be considered. Note that only variables that are not already fixed are considered.

TODO(user): extend as needed. 

const (
	DecisionStrategyProto_CHOOSE_FIRST           DecisionStrategyProto_VariableSelectionStrategy = 0
	DecisionStrategyProto_CHOOSE_LOWEST_MIN      DecisionStrategyProto_VariableSelectionStrategy = 1
	DecisionStrategyProto_CHOOSE_HIGHEST_MAX     DecisionStrategyProto_VariableSelectionStrategy = 2
	DecisionStrategyProto_CHOOSE_MIN_DOMAIN_SIZE DecisionStrategyProto_VariableSelectionStrategy = 3
	DecisionStrategyProto_CHOOSE_MAX_DOMAIN_SIZE DecisionStrategyProto_VariableSelectionStrategy = 4
)

func (DecisionStrategyProto_VariableSelectionStrategy) Descriptor 

func (DecisionStrategyProto_VariableSelectionStrategy) Descriptor() protoreflect.EnumDescriptor

func (DecisionStrategyProto_VariableSelectionStrategy) Enum 

func (x DecisionStrategyProto_VariableSelectionStrategy) Enum() *DecisionStrategyProto_VariableSelectionStrategy

func (DecisionStrategyProto_VariableSelectionStrategy) EnumDescriptor deprecated 

func (DecisionStrategyProto_VariableSelectionStrategy) EnumDescriptor() ([]byte, []int)

Deprecated: Use DecisionStrategyProto_VariableSelectionStrategy.Descriptor instead.

func (DecisionStrategyProto_VariableSelectionStrategy) Number 

func (x DecisionStrategyProto_VariableSelectionStrategy) Number() protoreflect.EnumNumber

func (DecisionStrategyProto_VariableSelectionStrategy) String 

func (x DecisionStrategyProto_VariableSelectionStrategy) String() string

func (DecisionStrategyProto_VariableSelectionStrategy) Type 

func (DecisionStrategyProto_VariableSelectionStrategy) Type() protoreflect.EnumType

type DenseMatrixProto 

type DenseMatrixProto struct {
	NumRows int32   `protobuf:"varint,1,opt,name=num_rows,json=numRows,proto3" json:"num_rows,omitempty"`
	NumCols int32   `protobuf:"varint,2,opt,name=num_cols,json=numCols,proto3" json:"num_cols,omitempty"`
	Entries []int32 `protobuf:"varint,3,rep,packed,name=entries,proto3" json:"entries,omitempty"`
	// contains filtered or unexported fields
}

A dense matrix of numbers encoded in a flat way, row by row. That is matrix[i][j] = entries[i * num_cols + j];

func (*DenseMatrixProto) Descriptor deprecated 

func (*DenseMatrixProto) Descriptor() ([]byte, []int)

Deprecated: Use DenseMatrixProto.ProtoReflect.Descriptor instead.

func (*DenseMatrixProto) GetEntries 

func (x *DenseMatrixProto) GetEntries() []int32

func (*DenseMatrixProto) GetNumCols 

func (x *DenseMatrixProto) GetNumCols() int32

func (*DenseMatrixProto) GetNumRows 

func (x *DenseMatrixProto) GetNumRows() int32

func (*DenseMatrixProto) ProtoMessage 

func (*DenseMatrixProto) ProtoMessage()

func (*DenseMatrixProto) ProtoReflect 

func (x *DenseMatrixProto) ProtoReflect() protoreflect.Message

func (*DenseMatrixProto) Reset 

func (x *DenseMatrixProto) Reset()

func (*DenseMatrixProto) String 

func (x *DenseMatrixProto) String() string

type ElementConstraintProto 

type ElementConstraintProto struct {
	Index  int32   `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Target int32   `protobuf:"varint,2,opt,name=target,proto3" json:"target,omitempty"`
	Vars   []int32 `protobuf:"varint,3,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	// contains filtered or unexported fields
}

The constraint target = vars[index]. This enforces that index takes one of the value in [0, vars_size()).

func (*ElementConstraintProto) Descriptor deprecated 

func (*ElementConstraintProto) Descriptor() ([]byte, []int)

Deprecated: Use ElementConstraintProto.ProtoReflect.Descriptor instead.

func (*ElementConstraintProto) GetIndex 

func (x *ElementConstraintProto) GetIndex() int32

func (*ElementConstraintProto) GetTarget 

func (x *ElementConstraintProto) GetTarget() int32

func (*ElementConstraintProto) GetVars 

func (x *ElementConstraintProto) GetVars() []int32

func (*ElementConstraintProto) ProtoMessage 

func (*ElementConstraintProto) ProtoMessage()

func (*ElementConstraintProto) ProtoReflect 

func (x *ElementConstraintProto) ProtoReflect() protoreflect.Message

func (*ElementConstraintProto) Reset 

func (x *ElementConstraintProto) Reset()

func (*ElementConstraintProto) String 

func (x *ElementConstraintProto) String() string

type IntegerArgumentProto 

type IntegerArgumentProto struct {
	Target int32   `protobuf:"varint,1,opt,name=target,proto3" json:"target,omitempty"`
	Vars   []int32 `protobuf:"varint,2,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	// contains filtered or unexported fields
}

Argument of the constraints of the form target_var = OP(vars).

func (*IntegerArgumentProto) Descriptor deprecated 

func (*IntegerArgumentProto) Descriptor() ([]byte, []int)

Deprecated: Use IntegerArgumentProto.ProtoReflect.Descriptor instead.

func (*IntegerArgumentProto) GetTarget 

func (x *IntegerArgumentProto) GetTarget() int32

func (*IntegerArgumentProto) GetVars 

func (x *IntegerArgumentProto) GetVars() []int32

func (*IntegerArgumentProto) ProtoMessage 

func (*IntegerArgumentProto) ProtoMessage()

func (*IntegerArgumentProto) ProtoReflect 

func (x *IntegerArgumentProto) ProtoReflect() protoreflect.Message

func (*IntegerArgumentProto) Reset 

func (x *IntegerArgumentProto) Reset()

func (*IntegerArgumentProto) String 

func (x *IntegerArgumentProto) String() string

type IntegerVariableProto 

type IntegerVariableProto struct {

	// For debug/logging only. Can be empty.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The variable domain given as a sorted list of n disjoint intervals
	// [min, max] and encoded as [min_0, max_0,  ..., min_{n-1}, max_{n-1}].
	//
	// The most common example being just [min, max].
	// If min == max, then this is a constant variable.
	//
	// We have:
	//  - domain_size() is always even.
	//  - min == domain.front();
	//  - max == domain.back();
	//  - for all i < n   :      min_i <= max_i
	//  - for all i < n-1 :  max_i + 1 < min_{i+1}.
	//
	// Note that we check at validation that a variable domain is small enough so
	// that we don't run into integer overflow in our algorithms. Because of that,
	// you cannot just have "unbounded" variable like [0, kint64max] and should
	// try to specify tighter domains.
	Domain []int64 `protobuf:"varint,2,rep,packed,name=domain,proto3" json:"domain,omitempty"`
	// contains filtered or unexported fields
}

An integer variable.

It will be referred to by an int32 corresponding to its index in a CpModelProto variables field.

Depending on the context, a reference to a variable whose domain is in [0, 1] can also be seen as a Boolean that will be true if the variable value is 1 and false if it is 0. When used in this context, the field name will always contain the word "literal".

Negative reference (advanced usage): to simplify the creation of a model and for efficiency reasons, all the "literal" or "variable" fields can also contain a negative index. A negative index i will refer to the negation of the integer variable at index -i -1 or to NOT the literal at the same index.

Ex: A variable index 4 will refer to the integer variable model.variables(4) and an index of -5 will refer to the negation of the same variable. A literal index 4 will refer to the logical fact that model.variable(4) == 1 and a literal index of -5 will refer to the logical fact model.variable(4) == 0.

func (*IntegerVariableProto) Descriptor deprecated 

func (*IntegerVariableProto) Descriptor() ([]byte, []int)

Deprecated: Use IntegerVariableProto.ProtoReflect.Descriptor instead.

func (*IntegerVariableProto) GetDomain 

func (x *IntegerVariableProto) GetDomain() []int64

func (*IntegerVariableProto) GetName 

func (x *IntegerVariableProto) GetName() string

func (*IntegerVariableProto) ProtoMessage 

func (*IntegerVariableProto) ProtoMessage()

func (*IntegerVariableProto) ProtoReflect 

func (x *IntegerVariableProto) ProtoReflect() protoreflect.Message

func (*IntegerVariableProto) Reset 

func (x *IntegerVariableProto) Reset()

func (*IntegerVariableProto) String 

func (x *IntegerVariableProto) String() string

type IntervalConstraintProto 

type IntervalConstraintProto struct {
	Start int32 `protobuf:"varint,1,opt,name=start,proto3" json:"start,omitempty"`
	End   int32 `protobuf:"varint,2,opt,name=end,proto3" json:"end,omitempty"`
	Size  int32 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`
	// EXPERIMENTAL: This will become the new way to specify an interval.
	// Depending on the parameters, the presolve will convert the old way to the
	// new way. Do not forget to add an associated linear constraint if you use
	// this directly.
	//
	// If any of this field is set, then all must be set and the ones above will
	// be ignored.
	//
	// IMPORTANT: For now, this constraint do not enforce any relations on the
	// view, and a linear constraint must be added together with this to enforce
	// enforcement => start_view + size_view == end_view. An enforcement =>
	// size_view >=0 might also be needed.
	//
	// IMPORTANT: For now, we just support affine relation. We could easily
	// create an intermediate variable to support full linear expression, but this
	// isn't done currently.
	StartView *LinearExpressionProto `protobuf:"bytes,4,opt,name=start_view,json=startView,proto3" json:"start_view,omitempty"`
	EndView   *LinearExpressionProto `protobuf:"bytes,5,opt,name=end_view,json=endView,proto3" json:"end_view,omitempty"`
	SizeView  *LinearExpressionProto `protobuf:"bytes,6,opt,name=size_view,json=sizeView,proto3" json:"size_view,omitempty"`
	// contains filtered or unexported fields
}

This "special" constraint not only enforces (start + size == end) and (size >= 0) but can also be referred by other constraints using this "interval" concept.

func (*IntervalConstraintProto) Descriptor deprecated 

func (*IntervalConstraintProto) Descriptor() ([]byte, []int)

Deprecated: Use IntervalConstraintProto.ProtoReflect.Descriptor instead.

func (*IntervalConstraintProto) GetEnd 

func (x *IntervalConstraintProto) GetEnd() int32

func (*IntervalConstraintProto) GetEndView 

func (x *IntervalConstraintProto) GetEndView() *LinearExpressionProto

func (*IntervalConstraintProto) GetSize 

func (x *IntervalConstraintProto) GetSize() int32

func (*IntervalConstraintProto) GetSizeView 

func (x *IntervalConstraintProto) GetSizeView() *LinearExpressionProto

func (*IntervalConstraintProto) GetStart 

func (x *IntervalConstraintProto) GetStart() int32

func (*IntervalConstraintProto) GetStartView 

func (x *IntervalConstraintProto) GetStartView() *LinearExpressionProto

func (*IntervalConstraintProto) ProtoMessage 

func (*IntervalConstraintProto) ProtoMessage()

func (*IntervalConstraintProto) ProtoReflect 

func (x *IntervalConstraintProto) ProtoReflect() protoreflect.Message

func (*IntervalConstraintProto) Reset 

func (x *IntervalConstraintProto) Reset()

func (*IntervalConstraintProto) String 

func (x *IntervalConstraintProto) String() string

type InverseConstraintProto 

type InverseConstraintProto struct {
	FDirect  []int32 `protobuf:"varint,1,rep,packed,name=f_direct,json=fDirect,proto3" json:"f_direct,omitempty"`
	FInverse []int32 `protobuf:"varint,2,rep,packed,name=f_inverse,json=fInverse,proto3" json:"f_inverse,omitempty"`
	// contains filtered or unexported fields
}

The two arrays of variable each represent a function, the second is the inverse of the first: f_direct[i] == j <=> f_inverse[j] == i.

func (*InverseConstraintProto) Descriptor deprecated 

func (*InverseConstraintProto) Descriptor() ([]byte, []int)

Deprecated: Use InverseConstraintProto.ProtoReflect.Descriptor instead.

func (*InverseConstraintProto) GetFDirect 

func (x *InverseConstraintProto) GetFDirect() []int32

func (*InverseConstraintProto) GetFInverse 

func (x *InverseConstraintProto) GetFInverse() []int32

func (*InverseConstraintProto) ProtoMessage 

func (*InverseConstraintProto) ProtoMessage()

func (*InverseConstraintProto) ProtoReflect 

func (x *InverseConstraintProto) ProtoReflect() protoreflect.Message

func (*InverseConstraintProto) Reset 

func (x *InverseConstraintProto) Reset()

func (*InverseConstraintProto) String 

func (x *InverseConstraintProto) String() string

type LinearArgumentProto 

type LinearArgumentProto struct {
	Target *LinearExpressionProto   `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"`
	Exprs  []*LinearExpressionProto `protobuf:"bytes,2,rep,name=exprs,proto3" json:"exprs,omitempty"`
	// contains filtered or unexported fields
}

func (*LinearArgumentProto) Descriptor deprecated 

func (*LinearArgumentProto) Descriptor() ([]byte, []int)

Deprecated: Use LinearArgumentProto.ProtoReflect.Descriptor instead.

func (*LinearArgumentProto) GetExprs 

func (x *LinearArgumentProto) GetExprs() []*LinearExpressionProto

func (*LinearArgumentProto) GetTarget 

func (x *LinearArgumentProto) GetTarget() *LinearExpressionProto

func (*LinearArgumentProto) ProtoMessage 

func (*LinearArgumentProto) ProtoMessage()

func (*LinearArgumentProto) ProtoReflect 

func (x *LinearArgumentProto) ProtoReflect() protoreflect.Message

func (*LinearArgumentProto) Reset 

func (x *LinearArgumentProto) Reset()

func (*LinearArgumentProto) String 

func (x *LinearArgumentProto) String() string

type LinearConstraintProto 

type LinearConstraintProto struct {
	Vars   []int32 `protobuf:"varint,1,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	Coeffs []int64 `protobuf:"varint,2,rep,packed,name=coeffs,proto3" json:"coeffs,omitempty"` // Same size as vars.
	Domain []int64 `protobuf:"varint,3,rep,packed,name=domain,proto3" json:"domain,omitempty"`
	// contains filtered or unexported fields
}

The linear sum vars[i] * coeffs[i] must fall in the given domain. The domain has the same format as the one in IntegerVariableProto.

Note that the validation code currently checks using the domain of the involved variables that the sum can always be computed without integer overflow and throws an error otherwise.

func (*LinearConstraintProto) Descriptor deprecated 

func (*LinearConstraintProto) Descriptor() ([]byte, []int)

Deprecated: Use LinearConstraintProto.ProtoReflect.Descriptor instead.

func (*LinearConstraintProto) GetCoeffs 

func (x *LinearConstraintProto) GetCoeffs() []int64

func (*LinearConstraintProto) GetDomain 

func (x *LinearConstraintProto) GetDomain() []int64

func (*LinearConstraintProto) GetVars 

func (x *LinearConstraintProto) GetVars() []int32

func (*LinearConstraintProto) ProtoMessage 

func (*LinearConstraintProto) ProtoMessage()

func (*LinearConstraintProto) ProtoReflect 

func (x *LinearConstraintProto) ProtoReflect() protoreflect.Message

func (*LinearConstraintProto) Reset 

func (x *LinearConstraintProto) Reset()

func (*LinearConstraintProto) String 

func (x *LinearConstraintProto) String() string

type LinearExpressionProto 

type LinearExpressionProto struct {
	Vars   []int32 `protobuf:"varint,1,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	Coeffs []int64 `protobuf:"varint,2,rep,packed,name=coeffs,proto3" json:"coeffs,omitempty"`
	Offset int64   `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	// contains filtered or unexported fields
}

Some constraints supports linear expression instead of just using a reference to a variable. This is especially useful during presolve to reduce the model size.

func (*LinearExpressionProto) Descriptor deprecated 

func (*LinearExpressionProto) Descriptor() ([]byte, []int)

Deprecated: Use LinearExpressionProto.ProtoReflect.Descriptor instead.

func (*LinearExpressionProto) GetCoeffs 

func (x *LinearExpressionProto) GetCoeffs() []int64

func (*LinearExpressionProto) GetOffset 

func (x *LinearExpressionProto) GetOffset() int64

func (*LinearExpressionProto) GetVars 

func (x *LinearExpressionProto) GetVars() []int32

func (*LinearExpressionProto) ProtoMessage 

func (*LinearExpressionProto) ProtoMessage()

func (*LinearExpressionProto) ProtoReflect 

func (x *LinearExpressionProto) ProtoReflect() protoreflect.Message

func (*LinearExpressionProto) Reset 

func (x *LinearExpressionProto) Reset()

func (*LinearExpressionProto) String 

func (x *LinearExpressionProto) String() string

type NoOverlap2DConstraintProto 

type NoOverlap2DConstraintProto struct {
	XIntervals                  []int32 `protobuf:"varint,1,rep,packed,name=x_intervals,json=xIntervals,proto3" json:"x_intervals,omitempty"`
	YIntervals                  []int32 `protobuf:"varint,2,rep,packed,name=y_intervals,json=yIntervals,proto3" json:"y_intervals,omitempty"` // Same size as x_intervals.
	BoxesWithNullAreaCanOverlap bool    ``                                                                                                    /* 151-byte string literal not displayed */
	// contains filtered or unexported fields
}

The boxes defined by [start_x, end_x) * [start_y, end_y) cannot overlap.

func (*NoOverlap2DConstraintProto) Descriptor deprecated 

func (*NoOverlap2DConstraintProto) Descriptor() ([]byte, []int)

Deprecated: Use NoOverlap2DConstraintProto.ProtoReflect.Descriptor instead.

func (*NoOverlap2DConstraintProto) GetBoxesWithNullAreaCanOverlap 

func (x *NoOverlap2DConstraintProto) GetBoxesWithNullAreaCanOverlap() bool

func (*NoOverlap2DConstraintProto) GetXIntervals 

func (x *NoOverlap2DConstraintProto) GetXIntervals() []int32

func (*NoOverlap2DConstraintProto) GetYIntervals 

func (x *NoOverlap2DConstraintProto) GetYIntervals() []int32

func (*NoOverlap2DConstraintProto) ProtoMessage 

func (*NoOverlap2DConstraintProto) ProtoMessage()

func (*NoOverlap2DConstraintProto) ProtoReflect 

func (x *NoOverlap2DConstraintProto) ProtoReflect() protoreflect.Message

func (*NoOverlap2DConstraintProto) Reset 

func (x *NoOverlap2DConstraintProto) Reset()

func (*NoOverlap2DConstraintProto) String 

func (x *NoOverlap2DConstraintProto) String() string

type NoOverlapConstraintProto 

type NoOverlapConstraintProto struct {
	Intervals []int32 `protobuf:"varint,1,rep,packed,name=intervals,proto3" json:"intervals,omitempty"`
	// contains filtered or unexported fields
}

All the intervals (index of IntervalConstraintProto) must be disjoint. More formally, there must exist a sequence so that for each consecutive intervals, we have end_i <= start_{i+1}. In particular, intervals of size zero do matter for this constraint. This is also known as a disjunctive constraint in scheduling.

func (*NoOverlapConstraintProto) Descriptor deprecated 

func (*NoOverlapConstraintProto) Descriptor() ([]byte, []int)

Deprecated: Use NoOverlapConstraintProto.ProtoReflect.Descriptor instead.

func (*NoOverlapConstraintProto) GetIntervals 

func (x *NoOverlapConstraintProto) GetIntervals() []int32

func (*NoOverlapConstraintProto) ProtoMessage 

func (*NoOverlapConstraintProto) ProtoMessage()

func (*NoOverlapConstraintProto) ProtoReflect 

func (x *NoOverlapConstraintProto) ProtoReflect() protoreflect.Message

func (*NoOverlapConstraintProto) Reset 

func (x *NoOverlapConstraintProto) Reset()

func (*NoOverlapConstraintProto) String 

func (x *NoOverlapConstraintProto) String() string

type PartialVariableAssignment 

type PartialVariableAssignment struct {
	Vars   []int32 `protobuf:"varint,1,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	Values []int64 `protobuf:"varint,2,rep,packed,name=values,proto3" json:"values,omitempty"`
	// contains filtered or unexported fields
}

This message encodes a partial (or full) assignment of the variables of a CpModelProto. The variable indices should be unique and valid variable indices.

func (*PartialVariableAssignment) Descriptor deprecated 

func (*PartialVariableAssignment) Descriptor() ([]byte, []int)

Deprecated: Use PartialVariableAssignment.ProtoReflect.Descriptor instead.

func (*PartialVariableAssignment) GetValues 

func (x *PartialVariableAssignment) GetValues() []int64

func (*PartialVariableAssignment) GetVars 

func (x *PartialVariableAssignment) GetVars() []int32

func (*PartialVariableAssignment) ProtoMessage 

func (*PartialVariableAssignment) ProtoMessage()

func (*PartialVariableAssignment) ProtoReflect 

func (x *PartialVariableAssignment) ProtoReflect() protoreflect.Message

func (*PartialVariableAssignment) Reset 

func (x *PartialVariableAssignment) Reset()

func (*PartialVariableAssignment) String 

func (x *PartialVariableAssignment) String() string

type ReservoirConstraintProto 

type ReservoirConstraintProto struct {
	MinLevel int64   `protobuf:"varint,1,opt,name=min_level,json=minLevel,proto3" json:"min_level,omitempty"`
	MaxLevel int64   `protobuf:"varint,2,opt,name=max_level,json=maxLevel,proto3" json:"max_level,omitempty"`
	Times    []int32 `protobuf:"varint,3,rep,packed,name=times,proto3" json:"times,omitempty"`     // variables.
	Demands  []int64 `protobuf:"varint,4,rep,packed,name=demands,proto3" json:"demands,omitempty"` // constants, can be negative.
	Actives  []int32 `protobuf:"varint,5,rep,packed,name=actives,proto3" json:"actives,omitempty"` // literals.
	// contains filtered or unexported fields
}

Maintain a reservoir level within bounds. The water level starts at 0, and at any time, it must be within [min_level, max_level].

If the variable actives[i] is true, and if the variable times[i] is assigned a value t, then the current level changes by demands[i] (which is constant) at the time t. Therefore, at any time t: 

sum(demands[i] * actives[i] if times[i] <= t) in [min_level, max_level]

Note that min level must be <= 0, and the max level must be >= 0. Please use fixed demands to simulate initial state.

The array of boolean variables 'actives', if defined, indicates which actions are actually performed. If this array is not defined, then it is assumed that all actions will be performed.

func (*ReservoirConstraintProto) Descriptor deprecated 

func (*ReservoirConstraintProto) Descriptor() ([]byte, []int)

Deprecated: Use ReservoirConstraintProto.ProtoReflect.Descriptor instead.

func (*ReservoirConstraintProto) GetActives 

func (x *ReservoirConstraintProto) GetActives() []int32

func (*ReservoirConstraintProto) GetDemands 

func (x *ReservoirConstraintProto) GetDemands() []int64

func (*ReservoirConstraintProto) GetMaxLevel 

func (x *ReservoirConstraintProto) GetMaxLevel() int64

func (*ReservoirConstraintProto) GetMinLevel 

func (x *ReservoirConstraintProto) GetMinLevel() int64

func (*ReservoirConstraintProto) GetTimes 

func (x *ReservoirConstraintProto) GetTimes() []int32

func (*ReservoirConstraintProto) ProtoMessage 

func (*ReservoirConstraintProto) ProtoMessage()

func (*ReservoirConstraintProto) ProtoReflect 

func (x *ReservoirConstraintProto) ProtoReflect() protoreflect.Message

func (*ReservoirConstraintProto) Reset 

func (x *ReservoirConstraintProto) Reset()

func (*ReservoirConstraintProto) String 

func (x *ReservoirConstraintProto) String() string

type RoutesConstraintProto 

type RoutesConstraintProto struct {
	Tails    []int32 `protobuf:"varint,1,rep,packed,name=tails,proto3" json:"tails,omitempty"`
	Heads    []int32 `protobuf:"varint,2,rep,packed,name=heads,proto3" json:"heads,omitempty"`
	Literals []int32 `protobuf:"varint,3,rep,packed,name=literals,proto3" json:"literals,omitempty"`
	// Experimental. The demands for each node, and the maximum capacity for each
	// route. Note that this is currently only used for the LP relaxation and one
	// need to add the corresponding constraint to enforce this outside of the LP.
	//
	// TODO(user): Ideally, we should be able to extract any dimension like these
	// (i.e. capacity, route_length, etc..) automatically from the encoding. The
	// classical way to encode that is to have "current_capacity" variables along
	// the route and linear equations of the form:
	//   arc_literal => (current_capacity_tail + demand <= current_capacity_head)
	Demands  []int32 `protobuf:"varint,4,rep,packed,name=demands,proto3" json:"demands,omitempty"`
	Capacity int64   `protobuf:"varint,5,opt,name=capacity,proto3" json:"capacity,omitempty"`
	// contains filtered or unexported fields
}

The "VRP" (Vehicle Routing Problem) constraint.

The direct graph where arc #i (from tails[i] to head[i]) is present iff literals[i] is true must satisfy this set of properties: - #incoming arcs == 1 except for node 0. - #outgoing arcs == 1 except for node 0. - for node zero, #incoming arcs == #outgoing arcs. - There are no duplicate arcs. - Self-arcs are allowed except for node 0. - There is no cycle in this graph, except through node 0.

TODO(user): It is probably possible to generalize this constraint to a no-cycle in a general graph, or a no-cycle with sum incoming <= 1 and sum outgoing <= 1 (more efficient implementation). On the other hand, having this specific constraint allow us to add specific "cuts" to a VRP problem.

func (*RoutesConstraintProto) Descriptor deprecated 

func (*RoutesConstraintProto) Descriptor() ([]byte, []int)

Deprecated: Use RoutesConstraintProto.ProtoReflect.Descriptor instead.

func (*RoutesConstraintProto) GetCapacity 

func (x *RoutesConstraintProto) GetCapacity() int64

func (*RoutesConstraintProto) GetDemands 

func (x *RoutesConstraintProto) GetDemands() []int32

func (*RoutesConstraintProto) GetHeads 

func (x *RoutesConstraintProto) GetHeads() []int32

func (*RoutesConstraintProto) GetLiterals 

func (x *RoutesConstraintProto) GetLiterals() []int32

func (*RoutesConstraintProto) GetTails 

func (x *RoutesConstraintProto) GetTails() []int32

func (*RoutesConstraintProto) ProtoMessage 

func (*RoutesConstraintProto) ProtoMessage()

func (*RoutesConstraintProto) ProtoReflect 

func (x *RoutesConstraintProto) ProtoReflect() protoreflect.Message

func (*RoutesConstraintProto) Reset 

func (x *RoutesConstraintProto) Reset()

func (*RoutesConstraintProto) String 

func (x *RoutesConstraintProto) String() string

type SatParameters 

type SatParameters struct {

	// In some context, like in a portfolio of search, it makes sense to name a
	// given parameters set for logging purpose.
	Name                   *string                      `protobuf:"bytes,171,opt,name=name,def=" json:"name,omitempty"`
	PreferredVariableOrder *SatParameters_VariableOrder `` /* 186-byte string literal not displayed */
	InitialPolarity        *SatParameters_Polarity      `` /* 158-byte string literal not displayed */
	// If this is true, then the polarity of a variable will be the last value it
	// was assigned to, or its default polarity if it was never assigned since the
	// call to ResetDecisionHeuristic().
	//
	// Actually, we use a newer version where we follow the last value in the
	// longest non-conflicting partial assignment in the current phase.
	//
	// This is called 'literal phase saving'. For details see 'A Lightweight
	// Component Caching Scheme for Satisfiability Solvers' K. Pipatsrisawat and
	// A.Darwiche, In 10th International Conference on Theory and Applications of
	// Satisfiability Testing, 2007.
	UsePhaseSaving *bool `protobuf:"varint,44,opt,name=use_phase_saving,json=usePhaseSaving,def=1" json:"use_phase_saving,omitempty"`
	// If non-zero, then we change the polarity heuristic after that many number
	// of conflicts in an arithmetically increasing fashion. So x the first time,
	// 2 * x the second time, etc...
	PolarityRephaseIncrement *int32 `` /* 140-byte string literal not displayed */
	// The proportion of polarity chosen at random. Note that this take
	// precedence over the phase saving heuristic. This is different from
	// initial_polarity:POLARITY_RANDOM because it will select a new random
	// polarity each time the variable is branched upon instead of selecting one
	// initially and then always taking this choice.
	RandomPolarityRatio *float64 `protobuf:"fixed64,45,opt,name=random_polarity_ratio,json=randomPolarityRatio,def=0" json:"random_polarity_ratio,omitempty"`
	// A number between 0 and 1 that indicates the proportion of branching
	// variables that are selected randomly instead of choosing the first variable
	// from the given variable_ordering strategy.
	RandomBranchesRatio *float64 `protobuf:"fixed64,32,opt,name=random_branches_ratio,json=randomBranchesRatio,def=0" json:"random_branches_ratio,omitempty"`
	// Whether we use the ERWA (Exponential Recency Weighted Average) heuristic as
	// described in "Learning Rate Based Branching Heuristic for SAT solvers",
	// J.H.Liang, V. Ganesh, P. Poupart, K.Czarnecki, SAT 2016.
	UseErwaHeuristic *bool `protobuf:"varint,75,opt,name=use_erwa_heuristic,json=useErwaHeuristic,def=0" json:"use_erwa_heuristic,omitempty"`
	// The initial value of the variables activity. A non-zero value only make
	// sense when use_erwa_heuristic is true. Experiments with a value of 1e-2
	// together with the ERWA heuristic showed slighthly better result than simply
	// using zero. The idea is that when the "learning rate" of a variable becomes
	// lower than this value, then we prefer to branch on never explored before
	// variables. This is not in the ERWA paper.
	InitialVariablesActivity *float64 `` /* 137-byte string literal not displayed */
	// When this is true, then the variables that appear in any of the reason of
	// the variables in a conflict have their activity bumped. This is addition to
	// the variables in the conflict, and the one that were used during conflict
	// resolution.
	AlsoBumpVariablesInConflictReasons *bool                                        `` /* 172-byte string literal not displayed */
	MinimizationAlgorithm              *SatParameters_ConflictMinimizationAlgorithm `` /* 197-byte string literal not displayed */
	BinaryMinimizationAlgorithm        *SatParameters_BinaryMinizationAlgorithm     `` /* 214-byte string literal not displayed */
	// At a really low cost, during the 1-UIP conflict computation, it is easy to
	// detect if some of the involved reasons are subsumed by the current
	// conflict. When this is true, such clauses are detached and later removed
	// from the problem.
	SubsumptionDuringConflictAnalysis *bool `` /* 165-byte string literal not displayed */
	// Trigger a cleanup when this number of "deletable" clauses is learned.
	ClauseCleanupPeriod *int32 `protobuf:"varint,11,opt,name=clause_cleanup_period,json=clauseCleanupPeriod,def=10000" json:"clause_cleanup_period,omitempty"`
	// During a cleanup, we will always keep that number of "deletable" clauses.
	// Note that this doesn't include the "protected" clauses.
	ClauseCleanupTarget     *int32                          `protobuf:"varint,13,opt,name=clause_cleanup_target,json=clauseCleanupTarget,def=10000" json:"clause_cleanup_target,omitempty"`
	ClauseCleanupProtection *SatParameters_ClauseProtection `` /* 193-byte string literal not displayed */
	// All the clauses with a LBD (literal blocks distance) lower or equal to this
	// parameters will always be kept.
	ClauseCleanupLbdBound *int32                        `` /* 129-byte string literal not displayed */
	ClauseCleanupOrdering *SatParameters_ClauseOrdering `` /* 185-byte string literal not displayed */
	// Same as for the clauses, but for the learned pseudo-Boolean constraints.
	PbCleanupIncrement *int32   `protobuf:"varint,46,opt,name=pb_cleanup_increment,json=pbCleanupIncrement,def=200" json:"pb_cleanup_increment,omitempty"`
	PbCleanupRatio     *float64 `protobuf:"fixed64,47,opt,name=pb_cleanup_ratio,json=pbCleanupRatio,def=0.5" json:"pb_cleanup_ratio,omitempty"`
	// Parameters for an heuristic similar to the one descibed in "An effective
	// learnt clause minimization approach for CDCL Sat Solvers",
	// https://www.ijcai.org/proceedings/2017/0098.pdf
	//
	// For now, we have a somewhat simpler implementation where every x restart we
	// spend y decisions on clause minimization. The minimization technique is the
	// same as the one used to minimize core in max-sat. We also minimize problem
	// clauses and not just the learned clause that we keep forever like in the
	// paper.
	//
	// Changing these parameters or the kind of clause we minimize seems to have
	// a big impact on the overall perf on our benchmarks. So this technique seems
	// definitely useful, but it is hard to tune properly.
	MinimizeWithPropagationRestartPeriod *int32 `` /* 177-byte string literal not displayed */
	MinimizeWithPropagationNumDecisions  *int32 `` /* 176-byte string literal not displayed */
	// Each time a conflict is found, the activities of some variables are
	// increased by one. Then, the activity of all variables are multiplied by
	// variable_activity_decay.
	//
	// To implement this efficiently, the activity of all the variables is not
	// decayed at each conflict. Instead, the activity increment is multiplied by
	// 1 / decay. When an activity reach max_variable_activity_value, all the
	// activity are multiplied by 1 / max_variable_activity_value.
	VariableActivityDecay    *float64 `` /* 130-byte string literal not displayed */
	MaxVariableActivityValue *float64 `` /* 144-byte string literal not displayed */
	// The activity starts at 0.8 and increment by 0.01 every 5000 conflicts until
	// 0.95. This "hack" seems to work well and comes from:
	//
	// Glucose 2.3 in the SAT 2013 Competition - SAT Competition 2013
	// http://edacc4.informatik.uni-ulm.de/SC13/solver-description-download/136
	GlucoseMaxDecay             *float64 `protobuf:"fixed64,22,opt,name=glucose_max_decay,json=glucoseMaxDecay,def=0.95" json:"glucose_max_decay,omitempty"`
	GlucoseDecayIncrement       *float64 `` /* 131-byte string literal not displayed */
	GlucoseDecayIncrementPeriod *int32   `` /* 150-byte string literal not displayed */
	// Clause activity parameters (same effect as the one on the variables).
	ClauseActivityDecay    *float64 `` /* 126-byte string literal not displayed */
	MaxClauseActivityValue *float64 `` /* 137-byte string literal not displayed */
	// The restart strategies will change each time the strategy_counter is
	// increased. The current strategy will simply be the one at index
	// strategy_counter modulo the number of strategy. Note that if this list
	// includes a NO_RESTART, nothing will change when it is reached because the
	// strategy_counter will only increment after a restart.
	//
	// The idea of switching of search strategy tailored for SAT/UNSAT comes from
	// Chanseok Oh with his COMiniSatPS solver, see http://cs.nyu.edu/~chanseok/.
	// But more generally, it seems REALLY beneficial to try different strategy.
	RestartAlgorithms        []SatParameters_RestartAlgorithm `` /* 167-byte string literal not displayed */
	DefaultRestartAlgorithms *string                          `` /* 199-byte string literal not displayed */
	// Restart period for the FIXED_RESTART strategy. This is also the multiplier
	// used by the LUBY_RESTART strategy.
	RestartPeriod *int32 `protobuf:"varint,30,opt,name=restart_period,json=restartPeriod,def=50" json:"restart_period,omitempty"`
	// Size of the window for the moving average restarts.
	RestartRunningWindowSize *int32 `` /* 139-byte string literal not displayed */
	// In the moving average restart algorithms, a restart is triggered if the
	// window average times this ratio is greater that the global average.
	RestartDlAverageRatio  *float64 `` /* 130-byte string literal not displayed */
	RestartLbdAverageRatio *float64 `` /* 133-byte string literal not displayed */
	// Block a moving restart algorithm if the trail size of the current conflict
	// is greater than the multiplier times the moving average of the trail size
	// at the previous conflicts.
	UseBlockingRestart        *bool    `protobuf:"varint,64,opt,name=use_blocking_restart,json=useBlockingRestart,def=0" json:"use_blocking_restart,omitempty"`
	BlockingRestartWindowSize *int32   `` /* 144-byte string literal not displayed */
	BlockingRestartMultiplier *float64 `` /* 142-byte string literal not displayed */
	// After each restart, if the number of conflict since the last strategy
	// change is greater that this, then we increment a "strategy_counter" that
	// can be use to change the search strategy used by the following restarts.
	NumConflictsBeforeStrategyChanges *int32 `` /* 167-byte string literal not displayed */
	// The parameter num_conflicts_before_strategy_changes is increased by that
	// much after each strategy change.
	StrategyChangeIncreaseRatio *float64 `` /* 148-byte string literal not displayed */
	// Maximum time allowed in seconds to solve a problem.
	// The counter will starts at the beginning of the Solve() call.
	MaxTimeInSeconds *float64 `protobuf:"fixed64,36,opt,name=max_time_in_seconds,json=maxTimeInSeconds,def=inf" json:"max_time_in_seconds,omitempty"`
	// Maximum time allowed in deterministic time to solve a problem.
	// The deterministic time should be correlated with the real time used by the
	// solver, the time unit being as close as possible to a second.
	MaxDeterministicTime *float64 `` /* 127-byte string literal not displayed */
	// Maximum number of conflicts allowed to solve a problem.
	//
	// TODO(user,user): Maybe change the way the conflict limit is enforced?
	// currently it is enforced on each independent internal SAT solve, rather
	// than on the overall number of conflicts across all solves. So in the
	// context of an optimization problem, this is not really usable directly by a
	// client.
	MaxNumberOfConflicts *int64 `` // kint64max
	/* 144-byte string literal not displayed */
	// Maximum memory allowed for the whole thread containing the solver. The
	// solver will abort as soon as it detects that this limit is crossed. As a
	// result, this limit is approximative, but usually the solver will not go too
	// much over.
	MaxMemoryInMb *int64 `protobuf:"varint,40,opt,name=max_memory_in_mb,json=maxMemoryInMb,def=10000" json:"max_memory_in_mb,omitempty"`
	// Stop the search when the gap between the best feasible objective (O) and
	// our best objective bound (B) is smaller than a limit.
	// The exact definition is:
	// - Absolute: abs(O - B)
	// - Relative: abs(O - B) / max(1, abs(O)).
	//
	// Important: The relative gap depends on the objective offset! If you
	// artificially shift the objective, you will get widely different value of
	// the relative gap.
	//
	// Note that if the gap is reached, the search status will be OPTIMAL. But
	// one can check the best objective bound to see the actual gap.
	AbsoluteGapLimit *float64 `protobuf:"fixed64,159,opt,name=absolute_gap_limit,json=absoluteGapLimit,def=0" json:"absolute_gap_limit,omitempty"`
	RelativeGapLimit *float64 `protobuf:"fixed64,160,opt,name=relative_gap_limit,json=relativeGapLimit,def=0" json:"relative_gap_limit,omitempty"`
	// If true, the binary clauses are treated separately from the others. This
	// should be faster and uses less memory. However it changes the propagation
	// order.
	TreatBinaryClausesSeparately *bool `` /* 150-byte string literal not displayed */
	// At the beginning of each solve, the random number generator used in some
	// part of the solver is reinitialized to this seed. If you change the random
	// seed, the solver may make different choices during the solving process.
	//
	// For some problems, the running time may vary a lot depending on small
	// change in the solving algorithm. Running the solver with different seeds
	// enables to have more robust benchmarks when evaluating new features.
	RandomSeed *int32 `protobuf:"varint,31,opt,name=random_seed,json=randomSeed,def=1" json:"random_seed,omitempty"`
	// This is mainly here to test the solver variability. Note that in tests, if
	// not explicitly set to false, all 3 options will be set to true so that
	// clients do not rely on the solver returning a specific solution if they are
	// many equivalent optimal solutions.
	PermuteVariableRandomly        *bool `` /* 134-byte string literal not displayed */
	PermutePresolveConstraintOrder *bool `` /* 157-byte string literal not displayed */
	UseAbslRandom                  *bool `protobuf:"varint,180,opt,name=use_absl_random,json=useAbslRandom,def=0" json:"use_absl_random,omitempty"`
	// Whether the solver should log the search progress. By default, it logs to
	// LOG(INFO). This can be overwritten by the log_destination parameter.
	LogSearchProgress *bool `protobuf:"varint,41,opt,name=log_search_progress,json=logSearchProgress,def=0" json:"log_search_progress,omitempty"`
	// Add a prefix to all logs.
	LogPrefix *string `protobuf:"bytes,185,opt,name=log_prefix,json=logPrefix,def=" json:"log_prefix,omitempty"`
	// Log to stdout.
	LogToStdout *bool `protobuf:"varint,186,opt,name=log_to_stdout,json=logToStdout,def=1" json:"log_to_stdout,omitempty"`
	// Log to response proto.
	LogToResponse *bool `protobuf:"varint,187,opt,name=log_to_response,json=logToResponse,def=0" json:"log_to_response,omitempty"`
	// Whether to use pseudo-Boolean resolution to analyze a conflict. Note that
	// this option only make sense if your problem is modelized using
	// pseudo-Boolean constraints. If you only have clauses, this shouldn't change
	// anything (except slow the solver down).
	UsePbResolution *bool `protobuf:"varint,43,opt,name=use_pb_resolution,json=usePbResolution,def=0" json:"use_pb_resolution,omitempty"`
	// A different algorithm during PB resolution. It minimizes the number of
	// calls to ReduceCoefficients() which can be time consuming. However, the
	// search space will be different and if the coefficients are large, this may
	// lead to integer overflows that could otherwise be prevented.
	MinimizeReductionDuringPbResolution *bool `` /* 173-byte string literal not displayed */
	// Whether or not the assumption levels are taken into account during the LBD
	// computation. According to the reference below, not counting them improves
	// the solver in some situation. Note that this only impact solves under
	// assumptions.
	//
	// Gilles Audemard, Jean-Marie Lagniez, Laurent Simon, "Improving Glucose for
	// Incremental SAT Solving with Assumptions: Application to MUS Extraction"
	// Theory and Applications of Satisfiability Testing - SAT 2013, Lecture Notes
	// in Computer Science Volume 7962, 2013, pp 309-317.
	CountAssumptionLevelsInLbd *bool `` /* 146-byte string literal not displayed */
	// During presolve, only try to perform the bounded variable elimination (BVE)
	// of a variable x if the number of occurrences of x times the number of
	// occurrences of not(x) is not greater than this parameter.
	PresolveBveThreshold *int32 `` /* 126-byte string literal not displayed */
	// During presolve, we apply BVE only if this weight times the number of
	// clauses plus the number of clause literals is not increased.
	PresolveBveClauseWeight *int32 `` /* 135-byte string literal not displayed */
	// The maximum "deterministic" time limit to spend in probing. A value of
	// zero will disable the probing.
	PresolveProbingDeterministicTimeLimit *float64 `` /* 181-byte string literal not displayed */
	// Whether we use an heuristic to detect some basic case of blocked clause
	// in the SAT presolve.
	PresolveBlockedClause *bool `` /* 127-byte string literal not displayed */
	// Whether or not we use Bounded Variable Addition (BVA) in the presolve.
	PresolveUseBva *bool `protobuf:"varint,72,opt,name=presolve_use_bva,json=presolveUseBva,def=1" json:"presolve_use_bva,omitempty"`
	// Apply Bounded Variable Addition (BVA) if the number of clauses is reduced
	// by stricly more than this threshold. The algorithm described in the paper
	// uses 0, but quick experiments showed that 1 is a good value. It may not be
	// worth it to add a new variable just to remove one clause.
	PresolveBvaThreshold *int32 `protobuf:"varint,73,opt,name=presolve_bva_threshold,json=presolveBvaThreshold,def=1" json:"presolve_bva_threshold,omitempty"`
	// In case of large reduction in a presolve iteration, we perform multiple
	// presolve iterations. This parameter controls the maximum number of such
	// presolve iterations.
	MaxPresolveIterations *int32 `` /* 128-byte string literal not displayed */
	// Whether we presolve the cp_model before solving it.
	CpModelPresolve *bool `protobuf:"varint,86,opt,name=cp_model_presolve,json=cpModelPresolve,def=1" json:"cp_model_presolve,omitempty"`
	// Advanced usage. We have two different postsolve code. The default one
	// should be better and it allows for a more powerful presolve, but some
	// rarely used features like not fully assigning all variables require the
	// other one.
	CpModelPostsolveWithFullSolver *bool `` /* 161-byte string literal not displayed */
	// If positive, try to stop just after that many presolve rules have been
	// applied. This is mainly useful for debugging presolve.
	CpModelMaxNumPresolveOperations *int32 `` /* 164-byte string literal not displayed */
	// How much effort do we spend on probing. 0 disables it completely.
	CpModelProbingLevel *int32 `protobuf:"varint,110,opt,name=cp_model_probing_level,json=cpModelProbingLevel,def=2" json:"cp_model_probing_level,omitempty"`
	// Whether we also use the sat presolve when cp_model_presolve is true.
	CpModelUseSatPresolve *bool `` /* 131-byte string literal not displayed */
	UseSatInprocessing    *bool `protobuf:"varint,163,opt,name=use_sat_inprocessing,json=useSatInprocessing,def=0" json:"use_sat_inprocessing,omitempty"`
	// If true, the element constraints are expanded into many
	// linear constraints of the form (index == i) => (element[i] == target).
	ExpandElementConstraints *bool `` /* 137-byte string literal not displayed */
	// If true, the automaton constraints are expanded.
	ExpandAutomatonConstraints *bool `` /* 143-byte string literal not displayed */
	// If true, the positive table constraints are expanded.
	// Note that currently, negative table constraints are always expanded.
	ExpandTableConstraints *bool `` /* 131-byte string literal not displayed */
	// If true, expand all_different constraints that are not permutations.
	// Permutations (#Variables = #Values) are always expanded.
	ExpandAlldiffConstraints *bool `` /* 137-byte string literal not displayed */
	// If true, expand the reservoir constraints by creating booleans for all
	// possible precedences between event and encoding the constraint.
	ExpandReservoirConstraints *bool `` /* 143-byte string literal not displayed */
	// If true, it disable all constraint expansion.
	// This should only be used to test the presolve of expanded constraints.
	DisableConstraintExpansion *bool `` /* 143-byte string literal not displayed */
	// During presolve, we use a maximum clique heuristic to merge together
	// no-overlap constraints or at most one constraints. This code can be slow,
	// so we have a limit in place on the number of explored nodes in the
	// underlying graph. The internal limit is an int64, but we use double here to
	// simplify manual input.
	MergeNoOverlapWorkLimit *float64 `` /* 143-byte string literal not displayed */
	MergeAtMostOneWorkLimit *float64 `` /* 145-byte string literal not displayed */
	// How much substitution (also called free variable aggregation in MIP
	// litterature) should we perform at presolve. This currently only concerns
	// variable appearing only in linear constraints. For now the value 0 turns it
	// off and any positive value performs substitution.
	PresolveSubstitutionLevel *int32 `` /* 140-byte string literal not displayed */
	// If true, we will extract from linear constraints, enforcement literals of
	// the form "integer variable at bound => simplified constraint". This should
	// always be beneficial except that we don't always handle them as efficiently
	// as we could for now. This causes problem on manna81.mps (LP relaxation not
	// as tight it seems) and on neos-3354841-apure.mps.gz (too many literals
	// created this way).
	PresolveExtractIntegerEnforcement *bool `` /* 166-byte string literal not displayed */
	// For an optimization problem, whether we follow some hints in order to find
	// a better first solution. For a variable with hint, the solver will always
	// try to follow the hint. It will revert to the variable_branching default
	// otherwise.
	UseOptimizationHints *bool `protobuf:"varint,35,opt,name=use_optimization_hints,json=useOptimizationHints,def=1" json:"use_optimization_hints,omitempty"`
	// Whether we use a simple heuristic to try to minimize an UNSAT core.
	MinimizeCore *bool `protobuf:"varint,50,opt,name=minimize_core,json=minimizeCore,def=1" json:"minimize_core,omitempty"`
	// Whether we try to find more independent cores for a given set of
	// assumptions in the core based max-SAT algorithms.
	FindMultipleCores *bool `protobuf:"varint,84,opt,name=find_multiple_cores,json=findMultipleCores,def=1" json:"find_multiple_cores,omitempty"`
	// If true, when the max-sat algo find a core, we compute the minimal number
	// of literals in the core that needs to be true to have a feasible solution.
	CoverOptimization     *bool                                `protobuf:"varint,89,opt,name=cover_optimization,json=coverOptimization,def=1" json:"cover_optimization,omitempty"`
	MaxSatAssumptionOrder *SatParameters_MaxSatAssumptionOrder `` /* 194-byte string literal not displayed */
	// If true, adds the assumption in the reverse order of the one defined by
	// max_sat_assumption_order.
	MaxSatReverseAssumptionOrder *bool                                        `` /* 152-byte string literal not displayed */
	MaxSatStratification         *SatParameters_MaxSatStratificationAlgorithm `` /* 197-byte string literal not displayed */
	// When this is true, then a disjunctive constraint will try to use the
	// precedence relations between time intervals to propagate their bounds
	// further. For instance if task A and B are both before C and task A and B
	// are in disjunction, then we can deduce that task C must start after
	// duration(A) + duration(B) instead of simply max(duration(A), duration(B)),
	// provided that the start time for all task was currently zero.
	//
	// This always result in better propagation, but it is usually slow, so
	// depending on the problem, turning this off may lead to a faster solution.
	UsePrecedencesInDisjunctiveConstraint *bool `` /* 179-byte string literal not displayed */
	// When this is true, the cumulative constraint is reinforced with overload
	// checking, i.e., an additional level of reasoning based on energy. This
	// additional level supplements the default level of reasoning as well as
	// timetable edge finding.
	//
	// This always result in better propagation, but it is usually slow, so
	// depending on the problem, turning this off may lead to a faster solution.
	UseOverloadCheckerInCumulativeConstraint *bool `` /* 190-byte string literal not displayed */
	// When this is true, the cumulative constraint is reinforced with timetable
	// edge finding, i.e., an additional level of reasoning based on the
	// conjunction of energy and mandatory parts. This additional level
	// supplements the default level of reasoning as well as overload_checker.
	//
	// This always result in better propagation, but it is usually slow, so
	// depending on the problem, turning this off may lead to a faster solution.
	UseTimetableEdgeFindingInCumulativeConstraint *bool `` /* 207-byte string literal not displayed */
	// When this is true, the cumulative constraint is reinforced with propagators
	// from the disjunctive constraint to improve the inference on a set of tasks
	// that are disjunctive at the root of the problem. This additional level
	// supplements the default level of reasoning.
	//
	// Propagators of the cumulative constraint will not be used at all if all the
	// tasks are disjunctive at root node.
	//
	// This always result in better propagation, but it is usually slow, so
	// depending on the problem, turning this off may lead to a faster solution.
	UseDisjunctiveConstraintInCumulativeConstraint *bool `` /* 208-byte string literal not displayed */
	// A non-negative level indicating the type of constraints we consider in the
	// LP relaxation. At level zero, no LP relaxation is used. At level 1, only
	// the linear constraint and full encoding are added. At level 2, we also add
	// all the Boolean constraints.
	LinearizationLevel *int32 `protobuf:"varint,90,opt,name=linearization_level,json=linearizationLevel,def=1" json:"linearization_level,omitempty"`
	// A non-negative level indicating how much we should try to fully encode
	// Integer variables as Boolean.
	BooleanEncodingLevel *int32 `protobuf:"varint,107,opt,name=boolean_encoding_level,json=booleanEncodingLevel,def=1" json:"boolean_encoding_level,omitempty"`
	// The limit on the number of cuts in our cut pool. When this is reached we do
	// not generate cuts anymore.
	//
	// TODO(user): We should probably remove this parameters, and just always
	// generate cuts but only keep the best n or something.
	MaxNumCuts *int32 `protobuf:"varint,91,opt,name=max_num_cuts,json=maxNumCuts,def=10000" json:"max_num_cuts,omitempty"`
	// For the cut that can be generated at any level, this control if we only
	// try to generate them at the root node.
	OnlyAddCutsAtLevelZero *bool `` /* 136-byte string literal not displayed */
	// Whether we generate knapsack cuts. Note that in our setting where all
	// variables are integer and bounded on both side, such a cut could be applied
	// to any constraint.
	AddKnapsackCuts *bool `protobuf:"varint,111,opt,name=add_knapsack_cuts,json=addKnapsackCuts,def=0" json:"add_knapsack_cuts,omitempty"`
	// Whether we generate and add Chvatal-Gomory cuts to the LP at root node.
	// Note that for now, this is not heavily tuned.
	AddCgCuts *bool `protobuf:"varint,117,opt,name=add_cg_cuts,json=addCgCuts,def=1" json:"add_cg_cuts,omitempty"`
	// Whether we generate MIR cuts at root node.
	// Note that for now, this is not heavily tuned.
	AddMirCuts *bool `protobuf:"varint,120,opt,name=add_mir_cuts,json=addMirCuts,def=1" json:"add_mir_cuts,omitempty"`
	// Whether we generate Zero-Half cuts at root node.
	// Note that for now, this is not heavily tuned.
	AddZeroHalfCuts *bool `protobuf:"varint,169,opt,name=add_zero_half_cuts,json=addZeroHalfCuts,def=1" json:"add_zero_half_cuts,omitempty"`
	// Whether we generate clique cuts from the binary implication graph. Note
	// that as the search goes on, this graph will contains new binary clauses
	// learned by the SAT engine.
	AddCliqueCuts *bool `protobuf:"varint,172,opt,name=add_clique_cuts,json=addCliqueCuts,def=1" json:"add_clique_cuts,omitempty"`
	// Cut generator for all diffs can add too many cuts for large all_diff
	// constraints. This parameter restricts the large all_diff constraints to
	// have a cut generator.
	MaxAllDiffCutSize *int32 `protobuf:"varint,148,opt,name=max_all_diff_cut_size,json=maxAllDiffCutSize,def=7" json:"max_all_diff_cut_size,omitempty"`
	// For the lin max constraints, generates the cuts described in "Strong
	// mixed-integer programming formulations for trained neural networks" by Ross
	// Anderson et. (https://arxiv.org/pdf/1811.01988.pdf)
	AddLinMaxCuts *bool `protobuf:"varint,152,opt,name=add_lin_max_cuts,json=addLinMaxCuts,def=1" json:"add_lin_max_cuts,omitempty"`
	// In the integer rounding procedure used for MIR and Gomory cut, the maximum
	// "scaling" we use (must be positive). The lower this is, the lower the
	// integer coefficients of the cut will be. Note that cut generated by lower
	// values are not necessarily worse than cut generated by larger value. There
	// is no strict dominance relationship.
	//
	// Setting this to 2 result in the "strong fractional rouding" of Letchford
	// and Lodi.
	MaxIntegerRoundingScaling *int32 `` /* 144-byte string literal not displayed */
	// If true, we start by an empty LP, and only add constraints not satisfied
	// by the current LP solution batch by batch. A constraint that is only added
	// like this is known as a "lazy" constraint in the literature, except that we
	// currently consider all constraints as lazy here.
	AddLpConstraintsLazily *bool `` /* 133-byte string literal not displayed */
	// While adding constraints, skip the constraints which have orthogonality
	// less than 'min_orthogonality_for_lp_constraints' with already added
	// constraints during current call. Orthogonality is defined as 1 -
	// cosine(vector angle between constraints). A value of zero disable this
	// feature.
	MinOrthogonalityForLpConstraints *float64 `` /* 169-byte string literal not displayed */
	// Max number of time we perform cut generation and resolve the LP at level 0.
	MaxCutRoundsAtLevelZero *int32 `` /* 140-byte string literal not displayed */
	// If a constraint/cut in LP is not active for that many consecutive OPTIMAL
	// solves, remove it from the LP. Note that it might be added again later if
	// it become violated by the current LP solution.
	MaxConsecutiveInactiveCount *int32 `` /* 150-byte string literal not displayed */
	// These parameters are similar to sat clause management activity parameters.
	// They are effective only if the number of generated cuts exceed the storage
	// limit. Default values are based on a few experiments on miplib instances.
	CutMaxActiveCountValue *float64 `` /* 140-byte string literal not displayed */
	CutActiveCountDecay    *float64 `` /* 127-byte string literal not displayed */
	// Target number of constraints to remove during cleanup.
	CutCleanupTarget *int32 `protobuf:"varint,157,opt,name=cut_cleanup_target,json=cutCleanupTarget,def=1000" json:"cut_cleanup_target,omitempty"`
	// Add that many lazy constraints (or cuts) at once in the LP. Note that at
	// the beginning of the solve, we do add more than this.
	NewConstraintsBatchSize *int32                         `` /* 137-byte string literal not displayed */
	SearchBranching         *SatParameters_SearchBranching `` /* 166-byte string literal not displayed */
	// Conflict limit used in the phase that exploit the solution hint.
	HintConflictLimit *int32 `protobuf:"varint,153,opt,name=hint_conflict_limit,json=hintConflictLimit,def=10" json:"hint_conflict_limit,omitempty"`
	// If true, the solver tries to repair the solution given in the hint. This
	// search terminates after the 'hint_conflict_limit' is reached and the solver
	// switches to regular search. If false, then  we do a FIXED_SEARCH using the
	// hint until the hint_conflict_limit is reached.
	RepairHint *bool `protobuf:"varint,167,opt,name=repair_hint,json=repairHint,def=0" json:"repair_hint,omitempty"`
	// If true and the Lp relaxation of the problem has an integer optimal
	// solution, try to exploit it. Note that since the LP relaxation may not
	// contain all the constraints, such a solution is not necessarily a solution
	// of the full problem.
	ExploitIntegerLpSolution *bool `` /* 138-byte string literal not displayed */
	// If true and the Lp relaxation of the problem has a solution, try to exploit
	// it. This is same as above except in this case the lp solution might not be
	// an integer solution.
	ExploitAllLpSolution *bool `` /* 127-byte string literal not displayed */
	// When branching on a variable, follow the last best solution value.
	ExploitBestSolution *bool `protobuf:"varint,130,opt,name=exploit_best_solution,json=exploitBestSolution,def=0" json:"exploit_best_solution,omitempty"`
	// When branching on a variable, follow the last best relaxation solution
	// value. We use the relaxation with the tightest bound on the objective as
	// the best relaxation solution.
	ExploitRelaxationSolution *bool `` /* 140-byte string literal not displayed */
	// When branching an a variable that directly affect the objective,
	// branch on the value that lead to the best objective first.
	ExploitObjective *bool `protobuf:"varint,131,opt,name=exploit_objective,json=exploitObjective,def=1" json:"exploit_objective,omitempty"`
	// If set at zero (the default), it is disabled. Otherwise the solver attempts
	// probing at every 'probing_period' root node. Period of 1 enables probing at
	// every root node.
	ProbingPeriodAtRoot *int64 `protobuf:"varint,142,opt,name=probing_period_at_root,json=probingPeriodAtRoot,def=0" json:"probing_period_at_root,omitempty"`
	// If true, search will continuously probe Boolean variables, and integer
	// variable bounds.
	UseProbingSearch *bool `protobuf:"varint,176,opt,name=use_probing_search,json=useProbingSearch,def=0" json:"use_probing_search,omitempty"`
	// The solver ignores the pseudo costs of variables with number of recordings
	// less than this threshold.
	PseudoCostReliabilityThreshold *int64 `` /* 159-byte string literal not displayed */
	// The default optimization method is a simple "linear scan", each time trying
	// to find a better solution than the previous one. If this is true, then we
	// use a core-based approach (like in max-SAT) when we try to increase the
	// lower bound instead.
	OptimizeWithCore *bool `protobuf:"varint,83,opt,name=optimize_with_core,json=optimizeWithCore,def=0" json:"optimize_with_core,omitempty"`
	// If non-negative, perform a binary search on the objective variable in order
	// to find an [min, max] interval outside of which the solver proved unsat/sat
	// under this amount of conflict. This can quickly reduce the objective domain
	// on some problems.
	BinarySearchNumConflicts *int32 `` /* 139-byte string literal not displayed */
	// This has no effect if optimize_with_core is false. If true, use a different
	// core-based algorithm similar to the max-HS algo for max-SAT. This is a
	// hybrid MIP/CP approach and it uses a MIP solver in addition to the CP/SAT
	// one. This is also related to the PhD work of tobyodavies@
	// "Automatic Logic-Based Benders Decomposition with MiniZinc"
	// http://aaai.org/ocs/index.php/AAAI/AAAI17/paper/view/14489
	OptimizeWithMaxHs *bool `protobuf:"varint,85,opt,name=optimize_with_max_hs,json=optimizeWithMaxHs,def=0" json:"optimize_with_max_hs,omitempty"`
	// Whether we enumerate all solutions of a problem without objective. Note
	// that setting this to true automatically disable the presolve. This is
	// because the presolve rules only guarantee the existence of one feasible
	// solution to the presolved problem.
	//
	// TODO(user): Do not disable the presolve and let the user choose what
	// behavior is best by setting keep_all_feasible_solutions_in_presolve.
	EnumerateAllSolutions *bool `` /* 127-byte string literal not displayed */
	// If true, we disable the presolve reductions that remove feasible solutions
	// from the search space. Such solution are usually dominated by a "better"
	// solution that is kept, but depending on the situation, we might want to
	// keep all solutions.
	//
	// A trivial example is when a variable is unused. If this is true, then the
	// presolve will not fix it to an arbitrary value and it will stay in the
	// search space.
	KeepAllFeasibleSolutionsInPresolve *bool `` /* 173-byte string literal not displayed */
	// If true, add information about the derived variable domains to the
	// CpSolverResponse. It is an option because it makes the response slighly
	// bigger and there is a bit more work involved during the postsolve to
	// construct it, but it should still have a low overhead. See the
	// tightened_variables field in CpSolverResponse for more details.
	FillTightenedDomainsInResponse *bool `` /* 159-byte string literal not displayed */
	// If true, the solver will add a default integer branching strategy to the
	// already defined search strategy.
	InstantiateAllVariables *bool `` /* 134-byte string literal not displayed */
	// If true, then the precedences propagator try to detect for each variable if
	// it has a set of "optional incoming arc" for which at least one of them is
	// present. This is usually useful to have but can be slow on model with a lot
	// of precedence.
	AutoDetectGreaterThanAtLeastOneOf *bool `` /* 173-byte string literal not displayed */
	// For an optimization problem, stop the solver as soon as we have a solution.
	StopAfterFirstSolution *bool `` /* 132-byte string literal not displayed */
	// Mainly used when improving the presolver. When true, stops the solver after
	// the presolve is complete.
	StopAfterPresolve *bool `protobuf:"varint,149,opt,name=stop_after_presolve,json=stopAfterPresolve,def=0" json:"stop_after_presolve,omitempty"`
	// Specify the number of parallel workers to use during search.
	// A number <= 1 means no parallelism.
	// As of 2020-04-10, if you're using SAT via MPSolver (to solve integer
	// programs) this field is overridden with a value of 8, if the field is not
	// set *explicitly*. Thus, always set this field explicitly or via
	// MPSolver::SetNumThreads().
	NumSearchWorkers *int32 `protobuf:"varint,100,opt,name=num_search_workers,json=numSearchWorkers,def=1" json:"num_search_workers,omitempty"`
	// Experimental. If this is true, then we interleave all our major search
	// strategy and distribute the work amongst num_search_workers.
	//
	// The search is deterministic (independently of num_search_workers!), and we
	// schedule and wait for interleave_batch_size task to be completed before
	// synchronizing and scheduling the next batch of tasks.
	InterleaveSearch    *bool  `protobuf:"varint,136,opt,name=interleave_search,json=interleaveSearch,def=0" json:"interleave_search,omitempty"`
	InterleaveBatchSize *int32 `protobuf:"varint,134,opt,name=interleave_batch_size,json=interleaveBatchSize,def=1" json:"interleave_batch_size,omitempty"`
	// Temporary parameter until the memory usage is more optimized.
	ReduceMemoryUsageInInterleaveMode *bool `` /* 170-byte string literal not displayed */
	// Allows objective sharing between workers.
	ShareObjectiveBounds *bool `protobuf:"varint,113,opt,name=share_objective_bounds,json=shareObjectiveBounds,def=1" json:"share_objective_bounds,omitempty"`
	// Allows sharing of the bounds of modified variables at level 0.
	ShareLevelZeroBounds *bool `` /* 127-byte string literal not displayed */
	// LNS parameters.
	UseLnsOnly                          *bool `protobuf:"varint,101,opt,name=use_lns_only,json=useLnsOnly,def=0" json:"use_lns_only,omitempty"`
	LnsFocusOnDecisionVariables         *bool `` /* 150-byte string literal not displayed */
	LnsExpandIntervalsInConstraintGraph *bool `` /* 176-byte string literal not displayed */
	// Turns on relaxation induced neighborhood generator.
	UseRinsLns *bool `protobuf:"varint,129,opt,name=use_rins_lns,json=useRinsLns,def=1" json:"use_rins_lns,omitempty"`
	// Adds a feasibility pump subsolver along with lns subsolvers.
	UseFeasibilityPump *bool                           `protobuf:"varint,164,opt,name=use_feasibility_pump,json=useFeasibilityPump,def=1" json:"use_feasibility_pump,omitempty"`
	FpRounding         *SatParameters_FPRoundingMethod `` /* 153-byte string literal not displayed */
	// Turns on a lns worker which solves relaxed version of the original problem
	// by removing constraints from the problem in order to get better bounds.
	UseRelaxationLns *bool `protobuf:"varint,150,opt,name=use_relaxation_lns,json=useRelaxationLns,def=0" json:"use_relaxation_lns,omitempty"`
	// If true, registers more lns subsolvers with different parameters.
	DiversifyLnsParams *bool `protobuf:"varint,137,opt,name=diversify_lns_params,json=diversifyLnsParams,def=0" json:"diversify_lns_params,omitempty"`
	// Randomize fixed search.
	RandomizeSearch *bool `protobuf:"varint,103,opt,name=randomize_search,json=randomizeSearch,def=0" json:"randomize_search,omitempty"`
	// Search randomization will collect equivalent 'max valued' variables, and
	// pick one randomly. For instance, if the variable strategy is CHOOSE_FIRST,
	// all unassigned variables are equivalent. If the variable strategy is
	// CHOOSE_LOWEST_MIN, and `lm` is the current lowest min of all unassigned
	// variables, then the set of max valued variables will be all unassigned
	// variables where
	//    lm <= variable min <= lm + search_randomization_tolerance
	SearchRandomizationTolerance *int64 `` /* 149-byte string literal not displayed */
	// If true, we automatically detect variables whose constraint are always
	// enforced by the same literal and we mark them as optional. This allows
	// to propagate them as if they were present in some situation.
	UseOptionalVariables *bool `protobuf:"varint,108,opt,name=use_optional_variables,json=useOptionalVariables,def=1" json:"use_optional_variables,omitempty"`
	// The solver usually exploit the LP relaxation of a model. If this option is
	// true, then whatever is infered by the LP will be used like an heuristic to
	// compute EXACT propagation on the IP. So with this option, there is no
	// numerical imprecision issues.
	UseExactLpReason *bool `protobuf:"varint,109,opt,name=use_exact_lp_reason,json=useExactLpReason,def=1" json:"use_exact_lp_reason,omitempty"`
	// If true, the solver attemts to generate more info inside lp propagator by
	// branching on some variables if certain criteria are met during the search
	// tree exploration.
	UseBranchingInLp *bool `protobuf:"varint,139,opt,name=use_branching_in_lp,json=useBranchingInLp,def=0" json:"use_branching_in_lp,omitempty"`
	// This can be beneficial if there is a lot of no-overlap constraints but a
	// relatively low number of different intervals in the problem. Like 1000
	// intervals, but 1M intervals in the no-overlap constraints covering them.
	UseCombinedNoOverlap *bool `` /* 127-byte string literal not displayed */
	// Indicates if the CP-SAT layer should catch Control-C (SIGINT) signals
	// when calling solve. If set, catching the SIGINT signal will terminate the
	// search gracefully, as if a time limit was reached.
	CatchSigintSignal *bool `protobuf:"varint,135,opt,name=catch_sigint_signal,json=catchSigintSignal,def=1" json:"catch_sigint_signal,omitempty"`
	// Stores and exploits "implied-bounds" in the solver. That is, relations of
	// the form literal => (var >= bound). This is currently used to derive
	// stronger cuts.
	UseImpliedBounds *bool `protobuf:"varint,144,opt,name=use_implied_bounds,json=useImpliedBounds,def=1" json:"use_implied_bounds,omitempty"`
	// Whether we try to do a few degenerate iteration at the end of an LP solve
	// to minimize the fractionality of the integer variable in the basis. This
	// helps on some problems, but not so much on others. It also cost of bit of
	// time to do such polish step.
	PolishLpSolution *bool `protobuf:"varint,175,opt,name=polish_lp_solution,json=polishLpSolution,def=0" json:"polish_lp_solution,omitempty"`
	// Temporary flag util the feature is more mature. This convert intervals to
	// the newer proto format that support affine start/var/end instead of just
	// variables. It changes a bit the search and is not always better currently.
	ConvertIntervals *bool `protobuf:"varint,177,opt,name=convert_intervals,json=convertIntervals,def=0" json:"convert_intervals,omitempty"`
	// Whether we try to automatically detect the symmetries in a model and
	// exploit them. Currently, at level 1 we detect them in presolve and try
	// to fix Booleans. At level 2, we also do some form of dynamic symmetry
	// breaking during search.
	SymmetryLevel *int32 `protobuf:"varint,183,opt,name=symmetry_level,json=symmetryLevel,def=2" json:"symmetry_level,omitempty"`
	// We need to bound the maximum magnitude of the variables for CP-SAT, and
	// that is the bound we use. If the MIP model expect larger variable value in
	// the solution, then the converted model will likely not be relevant.
	MipMaxBound *float64 `protobuf:"fixed64,124,opt,name=mip_max_bound,json=mipMaxBound,def=1e+07" json:"mip_max_bound,omitempty"`
	// All continuous variable of the problem will be multiplied by this factor.
	// By default, we don't do any variable scaling and rely on the MIP model to
	// specify continuous variable domain with the wanted precision.
	MipVarScaling *float64 `protobuf:"fixed64,125,opt,name=mip_var_scaling,json=mipVarScaling,def=1" json:"mip_var_scaling,omitempty"`
	// If true, some continuous variable might be automatially scaled. For now,
	// this is only the case where we detect that a variable is actually an
	// integer multiple of a constant. For instance, variables of the form k * 0.5
	// are quite frequent, and if we detect this, we will scale such variable
	// domain by 2 to make it implied integer.
	MipAutomaticallyScaleVariables *bool `` /* 157-byte string literal not displayed */
	// When scaling constraint with double coefficients to integer coefficients,
	// we will multiply by a power of 2 and round the coefficients. We will choose
	// the lowest power such that we have no potential overflow and the worst case
	// constraint activity error do not exceed this threshold relative to the
	// constraint bounds.
	//
	// We also use this to decide by how much we relax the constraint bounds so
	// that we can have a feasible integer solution of constraints involving
	// continuous variable. This is required for instance when you have an == rhs
	// constraint as in many situation you cannot have a perfect equality with
	// integer variables and coefficients.
	MipWantedPrecision *float64 `protobuf:"fixed64,126,opt,name=mip_wanted_precision,json=mipWantedPrecision,def=1e-06" json:"mip_wanted_precision,omitempty"`
	// To avoid integer overflow, we always force the maximum possible constraint
	// activity (and objective value) according to the initial variable domain to
	// be smaller than 2 to this given power. Because of this, we cannot always
	// reach the "mip_wanted_precision" parameter above.
	//
	// This can go as high as 62, but some internal algo currently abort early if
	// they might run into integer overflow, so it is better to keep it a bit
	// lower than this.
	MipMaxActivityExponent *int32 `` /* 134-byte string literal not displayed */
	// As explained in mip_precision and mip_max_activity_exponent, we cannot
	// always reach the wanted precision during scaling. We use this threshold to
	// enphasize in the logs when the precision seems bad.
	MipCheckPrecision *float64 `protobuf:"fixed64,128,opt,name=mip_check_precision,json=mipCheckPrecision,def=0.0001" json:"mip_check_precision,omitempty"`
	// contains filtered or unexported fields
}

Contains the definitions for all the sat algorithm parameters and their default values.

NEXT TAG: 188

func (*SatParameters) Descriptor deprecated 

func (*SatParameters) Descriptor() ([]byte, []int)

Deprecated: Use SatParameters.ProtoReflect.Descriptor instead.

func (*SatParameters) GetAbsoluteGapLimit 

func (x *SatParameters) GetAbsoluteGapLimit() float64

func (*SatParameters) GetAddCgCuts 

func (x *SatParameters) GetAddCgCuts() bool

func (*SatParameters) GetAddCliqueCuts 

func (x *SatParameters) GetAddCliqueCuts() bool

func (*SatParameters) GetAddKnapsackCuts 

func (x *SatParameters) GetAddKnapsackCuts() bool

func (*SatParameters) GetAddLinMaxCuts 

func (x *SatParameters) GetAddLinMaxCuts() bool

func (*SatParameters) GetAddLpConstraintsLazily 

func (x *SatParameters) GetAddLpConstraintsLazily() bool

func (*SatParameters) GetAddMirCuts 

func (x *SatParameters) GetAddMirCuts() bool

func (*SatParameters) GetAddZeroHalfCuts 

func (x *SatParameters) GetAddZeroHalfCuts() bool

func (*SatParameters) GetAlsoBumpVariablesInConflictReasons 

func (x *SatParameters) GetAlsoBumpVariablesInConflictReasons() bool

func (*SatParameters) GetAutoDetectGreaterThanAtLeastOneOf 

func (x *SatParameters) GetAutoDetectGreaterThanAtLeastOneOf() bool

func (*SatParameters) GetBinaryMinimizationAlgorithm 

func (x *SatParameters) GetBinaryMinimizationAlgorithm() SatParameters_BinaryMinizationAlgorithm

func (*SatParameters) GetBinarySearchNumConflicts 

func (x *SatParameters) GetBinarySearchNumConflicts() int32

func (*SatParameters) GetBlockingRestartMultiplier 

func (x *SatParameters) GetBlockingRestartMultiplier() float64

func (*SatParameters) GetBlockingRestartWindowSize 

func (x *SatParameters) GetBlockingRestartWindowSize() int32

func (*SatParameters) GetBooleanEncodingLevel 

func (x *SatParameters) GetBooleanEncodingLevel() int32

func (*SatParameters) GetCatchSigintSignal 

func (x *SatParameters) GetCatchSigintSignal() bool

func (*SatParameters) GetClauseActivityDecay 

func (x *SatParameters) GetClauseActivityDecay() float64

func (*SatParameters) GetClauseCleanupLbdBound 

func (x *SatParameters) GetClauseCleanupLbdBound() int32

func (*SatParameters) GetClauseCleanupOrdering 

func (x *SatParameters) GetClauseCleanupOrdering() SatParameters_ClauseOrdering

func (*SatParameters) GetClauseCleanupPeriod 

func (x *SatParameters) GetClauseCleanupPeriod() int32

func (*SatParameters) GetClauseCleanupProtection 

func (x *SatParameters) GetClauseCleanupProtection() SatParameters_ClauseProtection

func (*SatParameters) GetClauseCleanupTarget 

func (x *SatParameters) GetClauseCleanupTarget() int32

func (*SatParameters) GetConvertIntervals 

func (x *SatParameters) GetConvertIntervals() bool

func (*SatParameters) GetCountAssumptionLevelsInLbd 

func (x *SatParameters) GetCountAssumptionLevelsInLbd() bool

func (*SatParameters) GetCoverOptimization 

func (x *SatParameters) GetCoverOptimization() bool

func (*SatParameters) GetCpModelMaxNumPresolveOperations 

func (x *SatParameters) GetCpModelMaxNumPresolveOperations() int32

func (*SatParameters) GetCpModelPostsolveWithFullSolver 

func (x *SatParameters) GetCpModelPostsolveWithFullSolver() bool

func (*SatParameters) GetCpModelPresolve 

func (x *SatParameters) GetCpModelPresolve() bool

func (*SatParameters) GetCpModelProbingLevel 

func (x *SatParameters) GetCpModelProbingLevel() int32

func (*SatParameters) GetCpModelUseSatPresolve 

func (x *SatParameters) GetCpModelUseSatPresolve() bool

func (*SatParameters) GetCutActiveCountDecay 

func (x *SatParameters) GetCutActiveCountDecay() float64

func (*SatParameters) GetCutCleanupTarget 

func (x *SatParameters) GetCutCleanupTarget() int32

func (*SatParameters) GetCutMaxActiveCountValue 

func (x *SatParameters) GetCutMaxActiveCountValue() float64

func (*SatParameters) GetDefaultRestartAlgorithms 

func (x *SatParameters) GetDefaultRestartAlgorithms() string

func (*SatParameters) GetDisableConstraintExpansion 

func (x *SatParameters) GetDisableConstraintExpansion() bool

func (*SatParameters) GetDiversifyLnsParams 

func (x *SatParameters) GetDiversifyLnsParams() bool

func (*SatParameters) GetEnumerateAllSolutions 

func (x *SatParameters) GetEnumerateAllSolutions() bool

func (*SatParameters) GetExpandAlldiffConstraints 

func (x *SatParameters) GetExpandAlldiffConstraints() bool

func (*SatParameters) GetExpandAutomatonConstraints 

func (x *SatParameters) GetExpandAutomatonConstraints() bool

func (*SatParameters) GetExpandElementConstraints 

func (x *SatParameters) GetExpandElementConstraints() bool

func (*SatParameters) GetExpandReservoirConstraints 

func (x *SatParameters) GetExpandReservoirConstraints() bool

func (*SatParameters) GetExpandTableConstraints 

func (x *SatParameters) GetExpandTableConstraints() bool

func (*SatParameters) GetExploitAllLpSolution 

func (x *SatParameters) GetExploitAllLpSolution() bool

func (*SatParameters) GetExploitBestSolution 

func (x *SatParameters) GetExploitBestSolution() bool

func (*SatParameters) GetExploitIntegerLpSolution 

func (x *SatParameters) GetExploitIntegerLpSolution() bool

func (*SatParameters) GetExploitObjective 

func (x *SatParameters) GetExploitObjective() bool

func (*SatParameters) GetExploitRelaxationSolution 

func (x *SatParameters) GetExploitRelaxationSolution() bool

func (*SatParameters) GetFillTightenedDomainsInResponse 

func (x *SatParameters) GetFillTightenedDomainsInResponse() bool

func (*SatParameters) GetFindMultipleCores 

func (x *SatParameters) GetFindMultipleCores() bool

func (*SatParameters) GetFpRounding 

func (x *SatParameters) GetFpRounding() SatParameters_FPRoundingMethod

func (*SatParameters) GetGlucoseDecayIncrement 

func (x *SatParameters) GetGlucoseDecayIncrement() float64

func (*SatParameters) GetGlucoseDecayIncrementPeriod 

func (x *SatParameters) GetGlucoseDecayIncrementPeriod() int32

func (*SatParameters) GetGlucoseMaxDecay 

func (x *SatParameters) GetGlucoseMaxDecay() float64

func (*SatParameters) GetHintConflictLimit 

func (x *SatParameters) GetHintConflictLimit() int32

func (*SatParameters) GetInitialPolarity 

func (x *SatParameters) GetInitialPolarity() SatParameters_Polarity

func (*SatParameters) GetInitialVariablesActivity 

func (x *SatParameters) GetInitialVariablesActivity() float64

func (*SatParameters) GetInstantiateAllVariables 

func (x *SatParameters) GetInstantiateAllVariables() bool

func (*SatParameters) GetInterleaveBatchSize 

func (x *SatParameters) GetInterleaveBatchSize() int32

func (*SatParameters) GetInterleaveSearch 

func (x *SatParameters) GetInterleaveSearch() bool

func (*SatParameters) GetKeepAllFeasibleSolutionsInPresolve 

func (x *SatParameters) GetKeepAllFeasibleSolutionsInPresolve() bool

func (*SatParameters) GetLinearizationLevel 

func (x *SatParameters) GetLinearizationLevel() int32

func (*SatParameters) GetLnsExpandIntervalsInConstraintGraph 

func (x *SatParameters) GetLnsExpandIntervalsInConstraintGraph() bool

func (*SatParameters) GetLnsFocusOnDecisionVariables 

func (x *SatParameters) GetLnsFocusOnDecisionVariables() bool

func (*SatParameters) GetLogPrefix 

func (x *SatParameters) GetLogPrefix() string

func (*SatParameters) GetLogSearchProgress 

func (x *SatParameters) GetLogSearchProgress() bool

func (*SatParameters) GetLogToResponse 

func (x *SatParameters) GetLogToResponse() bool

func (*SatParameters) GetLogToStdout 

func (x *SatParameters) GetLogToStdout() bool

func (*SatParameters) GetMaxAllDiffCutSize 

func (x *SatParameters) GetMaxAllDiffCutSize() int32

func (*SatParameters) GetMaxClauseActivityValue 

func (x *SatParameters) GetMaxClauseActivityValue() float64

func (*SatParameters) GetMaxConsecutiveInactiveCount 

func (x *SatParameters) GetMaxConsecutiveInactiveCount() int32

func (*SatParameters) GetMaxCutRoundsAtLevelZero 

func (x *SatParameters) GetMaxCutRoundsAtLevelZero() int32

func (*SatParameters) GetMaxDeterministicTime 

func (x *SatParameters) GetMaxDeterministicTime() float64

func (*SatParameters) GetMaxIntegerRoundingScaling 

func (x *SatParameters) GetMaxIntegerRoundingScaling() int32

func (*SatParameters) GetMaxMemoryInMb 

func (x *SatParameters) GetMaxMemoryInMb() int64

func (*SatParameters) GetMaxNumCuts 

func (x *SatParameters) GetMaxNumCuts() int32

func (*SatParameters) GetMaxNumberOfConflicts 

func (x *SatParameters) GetMaxNumberOfConflicts() int64

func (*SatParameters) GetMaxPresolveIterations 

func (x *SatParameters) GetMaxPresolveIterations() int32

func (*SatParameters) GetMaxSatAssumptionOrder 

func (x *SatParameters) GetMaxSatAssumptionOrder() SatParameters_MaxSatAssumptionOrder

func (*SatParameters) GetMaxSatReverseAssumptionOrder 

func (x *SatParameters) GetMaxSatReverseAssumptionOrder() bool

func (*SatParameters) GetMaxSatStratification 

func (x *SatParameters) GetMaxSatStratification() SatParameters_MaxSatStratificationAlgorithm

func (*SatParameters) GetMaxTimeInSeconds 

func (x *SatParameters) GetMaxTimeInSeconds() float64

func (*SatParameters) GetMaxVariableActivityValue 

func (x *SatParameters) GetMaxVariableActivityValue() float64

func (*SatParameters) GetMergeAtMostOneWorkLimit 

func (x *SatParameters) GetMergeAtMostOneWorkLimit() float64

func (*SatParameters) GetMergeNoOverlapWorkLimit 

func (x *SatParameters) GetMergeNoOverlapWorkLimit() float64

func (*SatParameters) GetMinOrthogonalityForLpConstraints 

func (x *SatParameters) GetMinOrthogonalityForLpConstraints() float64

func (*SatParameters) GetMinimizationAlgorithm 

func (x *SatParameters) GetMinimizationAlgorithm() SatParameters_ConflictMinimizationAlgorithm

func (*SatParameters) GetMinimizeCore 

func (x *SatParameters) GetMinimizeCore() bool

func (*SatParameters) GetMinimizeReductionDuringPbResolution 

func (x *SatParameters) GetMinimizeReductionDuringPbResolution() bool

func (*SatParameters) GetMinimizeWithPropagationNumDecisions 

func (x *SatParameters) GetMinimizeWithPropagationNumDecisions() int32

func (*SatParameters) GetMinimizeWithPropagationRestartPeriod 

func (x *SatParameters) GetMinimizeWithPropagationRestartPeriod() int32

func (*SatParameters) GetMipAutomaticallyScaleVariables 

func (x *SatParameters) GetMipAutomaticallyScaleVariables() bool

func (*SatParameters) GetMipCheckPrecision 

func (x *SatParameters) GetMipCheckPrecision() float64

func (*SatParameters) GetMipMaxActivityExponent 

func (x *SatParameters) GetMipMaxActivityExponent() int32

func (*SatParameters) GetMipMaxBound 

func (x *SatParameters) GetMipMaxBound() float64

func (*SatParameters) GetMipVarScaling 

func (x *SatParameters) GetMipVarScaling() float64

func (*SatParameters) GetMipWantedPrecision 

func (x *SatParameters) GetMipWantedPrecision() float64

func (*SatParameters) GetName 

func (x *SatParameters) GetName() string

func (*SatParameters) GetNewConstraintsBatchSize 

func (x *SatParameters) GetNewConstraintsBatchSize() int32

func (*SatParameters) GetNumConflictsBeforeStrategyChanges 

func (x *SatParameters) GetNumConflictsBeforeStrategyChanges() int32

func (*SatParameters) GetNumSearchWorkers 

func (x *SatParameters) GetNumSearchWorkers() int32

func (*SatParameters) GetOnlyAddCutsAtLevelZero 

func (x *SatParameters) GetOnlyAddCutsAtLevelZero() bool

func (*SatParameters) GetOptimizeWithCore 

func (x *SatParameters) GetOptimizeWithCore() bool

func (*SatParameters) GetOptimizeWithMaxHs 

func (x *SatParameters) GetOptimizeWithMaxHs() bool

func (*SatParameters) GetPbCleanupIncrement 

func (x *SatParameters) GetPbCleanupIncrement() int32

func (*SatParameters) GetPbCleanupRatio 

func (x *SatParameters) GetPbCleanupRatio() float64

func (*SatParameters) GetPermutePresolveConstraintOrder 

func (x *SatParameters) GetPermutePresolveConstraintOrder() bool

func (*SatParameters) GetPermuteVariableRandomly 

func (x *SatParameters) GetPermuteVariableRandomly() bool

func (*SatParameters) GetPolarityRephaseIncrement 

func (x *SatParameters) GetPolarityRephaseIncrement() int32

func (*SatParameters) GetPolishLpSolution 

func (x *SatParameters) GetPolishLpSolution() bool

func (*SatParameters) GetPreferredVariableOrder 

func (x *SatParameters) GetPreferredVariableOrder() SatParameters_VariableOrder

func (*SatParameters) GetPresolveBlockedClause 

func (x *SatParameters) GetPresolveBlockedClause() bool

func (*SatParameters) GetPresolveBvaThreshold 

func (x *SatParameters) GetPresolveBvaThreshold() int32

func (*SatParameters) GetPresolveBveClauseWeight 

func (x *SatParameters) GetPresolveBveClauseWeight() int32

func (*SatParameters) GetPresolveBveThreshold 

func (x *SatParameters) GetPresolveBveThreshold() int32

func (*SatParameters) GetPresolveExtractIntegerEnforcement 

func (x *SatParameters) GetPresolveExtractIntegerEnforcement() bool

func (*SatParameters) GetPresolveProbingDeterministicTimeLimit 

func (x *SatParameters) GetPresolveProbingDeterministicTimeLimit() float64

func (*SatParameters) GetPresolveSubstitutionLevel 

func (x *SatParameters) GetPresolveSubstitutionLevel() int32

func (*SatParameters) GetPresolveUseBva 

func (x *SatParameters) GetPresolveUseBva() bool

func (*SatParameters) GetProbingPeriodAtRoot 

func (x *SatParameters) GetProbingPeriodAtRoot() int64

func (*SatParameters) GetPseudoCostReliabilityThreshold 

func (x *SatParameters) GetPseudoCostReliabilityThreshold() int64

func (*SatParameters) GetRandomBranchesRatio 

func (x *SatParameters) GetRandomBranchesRatio() float64

func (*SatParameters) GetRandomPolarityRatio 

func (x *SatParameters) GetRandomPolarityRatio() float64

func (*SatParameters) GetRandomSeed 

func (x *SatParameters) GetRandomSeed() int32

func (*SatParameters) GetRandomizeSearch 

func (x *SatParameters) GetRandomizeSearch() bool

func (*SatParameters) GetReduceMemoryUsageInInterleaveMode 

func (x *SatParameters) GetReduceMemoryUsageInInterleaveMode() bool

func (*SatParameters) GetRelativeGapLimit 

func (x *SatParameters) GetRelativeGapLimit() float64

func (*SatParameters) GetRepairHint 

func (x *SatParameters) GetRepairHint() bool

func (*SatParameters) GetRestartAlgorithms 

func (x *SatParameters) GetRestartAlgorithms() []SatParameters_RestartAlgorithm

func (*SatParameters) GetRestartDlAverageRatio 

func (x *SatParameters) GetRestartDlAverageRatio() float64

func (*SatParameters) GetRestartLbdAverageRatio 

func (x *SatParameters) GetRestartLbdAverageRatio() float64

func (*SatParameters) GetRestartPeriod 

func (x *SatParameters) GetRestartPeriod() int32

func (*SatParameters) GetRestartRunningWindowSize 

func (x *SatParameters) GetRestartRunningWindowSize() int32

func (*SatParameters) GetSearchBranching 

func (x *SatParameters) GetSearchBranching() SatParameters_SearchBranching

func (*SatParameters) GetSearchRandomizationTolerance 

func (x *SatParameters) GetSearchRandomizationTolerance() int64

func (*SatParameters) GetShareLevelZeroBounds 

func (x *SatParameters) GetShareLevelZeroBounds() bool

func (*SatParameters) GetShareObjectiveBounds 

func (x *SatParameters) GetShareObjectiveBounds() bool

func (*SatParameters) GetStopAfterFirstSolution 

func (x *SatParameters) GetStopAfterFirstSolution() bool

func (*SatParameters) GetStopAfterPresolve 

func (x *SatParameters) GetStopAfterPresolve() bool

func (*SatParameters) GetStrategyChangeIncreaseRatio 

func (x *SatParameters) GetStrategyChangeIncreaseRatio() float64

func (*SatParameters) GetSubsumptionDuringConflictAnalysis 

func (x *SatParameters) GetSubsumptionDuringConflictAnalysis() bool

func (*SatParameters) GetSymmetryLevel 

func (x *SatParameters) GetSymmetryLevel() int32

func (*SatParameters) GetTreatBinaryClausesSeparately 

func (x *SatParameters) GetTreatBinaryClausesSeparately() bool

func (*SatParameters) GetUseAbslRandom 

func (x *SatParameters) GetUseAbslRandom() bool

func (*SatParameters) GetUseBlockingRestart 

func (x *SatParameters) GetUseBlockingRestart() bool

func (*SatParameters) GetUseBranchingInLp 

func (x *SatParameters) GetUseBranchingInLp() bool

func (*SatParameters) GetUseCombinedNoOverlap 

func (x *SatParameters) GetUseCombinedNoOverlap() bool

func (*SatParameters) GetUseDisjunctiveConstraintInCumulativeConstraint 

func (x *SatParameters) GetUseDisjunctiveConstraintInCumulativeConstraint() bool

func (*SatParameters) GetUseErwaHeuristic 

func (x *SatParameters) GetUseErwaHeuristic() bool

func (*SatParameters) GetUseExactLpReason 

func (x *SatParameters) GetUseExactLpReason() bool

func (*SatParameters) GetUseFeasibilityPump 

func (x *SatParameters) GetUseFeasibilityPump() bool

func (*SatParameters) GetUseImpliedBounds 

func (x *SatParameters) GetUseImpliedBounds() bool

func (*SatParameters) GetUseLnsOnly 

func (x *SatParameters) GetUseLnsOnly() bool

func (*SatParameters) GetUseOptimizationHints 

func (x *SatParameters) GetUseOptimizationHints() bool

func (*SatParameters) GetUseOptionalVariables 

func (x *SatParameters) GetUseOptionalVariables() bool

func (*SatParameters) GetUseOverloadCheckerInCumulativeConstraint 

func (x *SatParameters) GetUseOverloadCheckerInCumulativeConstraint() bool

func (*SatParameters) GetUsePbResolution 

func (x *SatParameters) GetUsePbResolution() bool

func (*SatParameters) GetUsePhaseSaving 

func (x *SatParameters) GetUsePhaseSaving() bool

func (*SatParameters) GetUsePrecedencesInDisjunctiveConstraint 

func (x *SatParameters) GetUsePrecedencesInDisjunctiveConstraint() bool

func (*SatParameters) GetUseProbingSearch 

func (x *SatParameters) GetUseProbingSearch() bool

func (*SatParameters) GetUseRelaxationLns 

func (x *SatParameters) GetUseRelaxationLns() bool

func (*SatParameters) GetUseRinsLns 

func (x *SatParameters) GetUseRinsLns() bool

func (*SatParameters) GetUseSatInprocessing 

func (x *SatParameters) GetUseSatInprocessing() bool

func (*SatParameters) GetUseTimetableEdgeFindingInCumulativeConstraint 

func (x *SatParameters) GetUseTimetableEdgeFindingInCumulativeConstraint() bool

func (*SatParameters) GetVariableActivityDecay 

func (x *SatParameters) GetVariableActivityDecay() float64

func (*SatParameters) ProtoMessage 

func (*SatParameters) ProtoMessage()

func (*SatParameters) ProtoReflect 

func (x *SatParameters) ProtoReflect() protoreflect.Message

func (*SatParameters) Reset 

func (x *SatParameters) Reset()

func (*SatParameters) String 

func (x *SatParameters) String() string

type SatParameters_BinaryMinizationAlgorithm 

type SatParameters_BinaryMinizationAlgorithm int32

Whether to expoit the binary clause to minimize learned clauses further. This will have an effect only if treat_binary_clauses_separately is true. 

const (
	SatParameters_NO_BINARY_MINIMIZATION                              SatParameters_BinaryMinizationAlgorithm = 0
	SatParameters_BINARY_MINIMIZATION_FIRST                           SatParameters_BinaryMinizationAlgorithm = 1
	SatParameters_BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION SatParameters_BinaryMinizationAlgorithm = 4
	SatParameters_BINARY_MINIMIZATION_WITH_REACHABILITY               SatParameters_BinaryMinizationAlgorithm = 2
	SatParameters_EXPERIMENTAL_BINARY_MINIMIZATION                    SatParameters_BinaryMinizationAlgorithm = 3
)

func (SatParameters_BinaryMinizationAlgorithm) Descriptor 

func (SatParameters_BinaryMinizationAlgorithm) Descriptor() protoreflect.EnumDescriptor

func (SatParameters_BinaryMinizationAlgorithm) Enum 

func (x SatParameters_BinaryMinizationAlgorithm) Enum() *SatParameters_BinaryMinizationAlgorithm

func (SatParameters_BinaryMinizationAlgorithm) EnumDescriptor deprecated 

func (SatParameters_BinaryMinizationAlgorithm) EnumDescriptor() ([]byte, []int)

Deprecated: Use SatParameters_BinaryMinizationAlgorithm.Descriptor instead.

func (SatParameters_BinaryMinizationAlgorithm) Number 

func (x SatParameters_BinaryMinizationAlgorithm) Number() protoreflect.EnumNumber

func (SatParameters_BinaryMinizationAlgorithm) String 

func (x SatParameters_BinaryMinizationAlgorithm) String() string

func (SatParameters_BinaryMinizationAlgorithm) Type 

func (SatParameters_BinaryMinizationAlgorithm) Type() protoreflect.EnumType

func (*SatParameters_BinaryMinizationAlgorithm) UnmarshalJSON deprecated 

func (x *SatParameters_BinaryMinizationAlgorithm) UnmarshalJSON(b []byte) error

Deprecated: Do not use.

type SatParameters_ClauseOrdering 

type SatParameters_ClauseOrdering int32

The clauses that will be kept during a cleanup are the ones that come first under this order. We always keep or exclude ties together. 

const (
	// Order clause by decreasing activity, then by increasing LBD.
	SatParameters_CLAUSE_ACTIVITY SatParameters_ClauseOrdering = 0
	// Order clause by increasing LBD, then by decreasing activity.
	SatParameters_CLAUSE_LBD SatParameters_ClauseOrdering = 1
)

func (SatParameters_ClauseOrdering) Descriptor 

func (SatParameters_ClauseOrdering) Descriptor() protoreflect.EnumDescriptor

func (SatParameters_ClauseOrdering) Enum 

func (x SatParameters_ClauseOrdering) Enum() *SatParameters_ClauseOrdering

func (SatParameters_ClauseOrdering) EnumDescriptor deprecated 

func (SatParameters_ClauseOrdering) EnumDescriptor() ([]byte, []int)

Deprecated: Use SatParameters_ClauseOrdering.Descriptor instead.

func (SatParameters_ClauseOrdering) Number 

func (x SatParameters_ClauseOrdering) Number() protoreflect.EnumNumber

func (SatParameters_ClauseOrdering) String 

func (x SatParameters_ClauseOrdering) String() string

func (SatParameters_ClauseOrdering) Type 

func (SatParameters_ClauseOrdering) Type() protoreflect.EnumType

func (*SatParameters_ClauseOrdering) UnmarshalJSON deprecated 

func (x *SatParameters_ClauseOrdering) UnmarshalJSON(b []byte) error

Deprecated: Do not use.

type SatParameters_ClauseProtection 

type SatParameters_ClauseProtection int32

Each time a clause activity is bumped, the clause has a chance to be protected during the next cleanup phase. Note that clauses used as a reason are always protected. 

const (
	SatParameters_PROTECTION_NONE   SatParameters_ClauseProtection = 0 // No protection.
	SatParameters_PROTECTION_ALWAYS SatParameters_ClauseProtection = 1 // Protect all clauses whose activity is bumped.
	SatParameters_PROTECTION_LBD    SatParameters_ClauseProtection = 2 // Only protect clause with a better LBD.
)

func (SatParameters_ClauseProtection) Descriptor 

func (SatParameters_ClauseProtection) Descriptor() protoreflect.EnumDescriptor

func (SatParameters_ClauseProtection) Enum 

func (x SatParameters_ClauseProtection) Enum() *SatParameters_ClauseProtection

func (SatParameters_ClauseProtection) EnumDescriptor deprecated 

func (SatParameters_ClauseProtection) EnumDescriptor() ([]byte, []int)

Deprecated: Use SatParameters_ClauseProtection.Descriptor instead.

func (SatParameters_ClauseProtection) Number 

func (x SatParameters_ClauseProtection) Number() protoreflect.EnumNumber

func (SatParameters_ClauseProtection) String 

func (x SatParameters_ClauseProtection) String() string

func (SatParameters_ClauseProtection) Type 

func (SatParameters_ClauseProtection) Type() protoreflect.EnumType

func (*SatParameters_ClauseProtection) UnmarshalJSON deprecated 

func (x *SatParameters_ClauseProtection) UnmarshalJSON(b []byte) error

Deprecated: Do not use.

type SatParameters_ConflictMinimizationAlgorithm 

type SatParameters_ConflictMinimizationAlgorithm int32

Do we try to minimize conflicts (greedily) when creating them. 

const (
	SatParameters_NONE         SatParameters_ConflictMinimizationAlgorithm = 0
	SatParameters_SIMPLE       SatParameters_ConflictMinimizationAlgorithm = 1
	SatParameters_RECURSIVE    SatParameters_ConflictMinimizationAlgorithm = 2
	SatParameters_EXPERIMENTAL SatParameters_ConflictMinimizationAlgorithm = 3
)

func (SatParameters_ConflictMinimizationAlgorithm) Descriptor 

func (SatParameters_ConflictMinimizationAlgorithm) Descriptor() protoreflect.EnumDescriptor

func (SatParameters_ConflictMinimizationAlgorithm) Enum 

func (x SatParameters_ConflictMinimizationAlgorithm) Enum() *SatParameters_ConflictMinimizationAlgorithm

func (SatParameters_ConflictMinimizationAlgorithm) EnumDescriptor deprecated 

func (SatParameters_ConflictMinimizationAlgorithm) EnumDescriptor() ([]byte, []int)

Deprecated: Use SatParameters_ConflictMinimizationAlgorithm.Descriptor instead.

func (SatParameters_ConflictMinimizationAlgorithm) Number 

func (x SatParameters_ConflictMinimizationAlgorithm) Number() protoreflect.EnumNumber

func (SatParameters_ConflictMinimizationAlgorithm) String 

func (x SatParameters_ConflictMinimizationAlgorithm) String() string

func (SatParameters_ConflictMinimizationAlgorithm) Type 

func (SatParameters_ConflictMinimizationAlgorithm) Type() protoreflect.EnumType

func (*SatParameters_ConflictMinimizationAlgorithm) UnmarshalJSON deprecated 

func (x *SatParameters_ConflictMinimizationAlgorithm) UnmarshalJSON(b []byte) error

Deprecated: Do not use.

type SatParameters_FPRoundingMethod 

type SatParameters_FPRoundingMethod int32

Rounding method to use for feasibility pump. 

const (
	// Rounds to the nearest integer value.
	SatParameters_NEAREST_INTEGER SatParameters_FPRoundingMethod = 0
	// Counts the number of linear constraints restricting the variable in the
	// increasing values (up locks) and decreasing values (down locks). Rounds
	// the variable in the direction of lesser locks.
	SatParameters_LOCK_BASED SatParameters_FPRoundingMethod = 1
	// Similar to lock based rounding except this only considers locks of active
	// constraints from the last lp solve.
	SatParameters_ACTIVE_LOCK_BASED SatParameters_FPRoundingMethod = 3
	// This is expensive rounding algorithm. We round variables one by one and
	// propagate the bounds in between. If none of the rounded values fall in
	// the continuous domain specified by lower and upper bound, we use the
	// current lower/upper bound (whichever one is closest) instead of rounding
	// the fractional lp solution value. If both the rounded values are in the
	// domain, we round to nearest integer.
	SatParameters_PROPAGATION_ASSISTED SatParameters_FPRoundingMethod = 2
)

func (SatParameters_FPRoundingMethod) Descriptor 

func (SatParameters_FPRoundingMethod) Descriptor() protoreflect.EnumDescriptor

func (SatParameters_FPRoundingMethod) Enum 

func (x SatParameters_FPRoundingMethod) Enum() *SatParameters_FPRoundingMethod

func (SatParameters_FPRoundingMethod) EnumDescriptor deprecated 

func (SatParameters_FPRoundingMethod) EnumDescriptor() ([]byte, []int)

Deprecated: Use SatParameters_FPRoundingMethod.Descriptor instead.

func (SatParameters_FPRoundingMethod) Number 

func (x SatParameters_FPRoundingMethod) Number() protoreflect.EnumNumber

func (SatParameters_FPRoundingMethod) String 

func (x SatParameters_FPRoundingMethod) String() string

func (SatParameters_FPRoundingMethod) Type 

func (SatParameters_FPRoundingMethod) Type() protoreflect.EnumType

func (*SatParameters_FPRoundingMethod) UnmarshalJSON deprecated 

func (x *SatParameters_FPRoundingMethod) UnmarshalJSON(b []byte) error

Deprecated: Do not use.

type SatParameters_MaxSatAssumptionOrder 

type SatParameters_MaxSatAssumptionOrder int32

In what order do we add the assumptions in a core-based max-sat algorithm 

const (
	SatParameters_DEFAULT_ASSUMPTION_ORDER   SatParameters_MaxSatAssumptionOrder = 0
	SatParameters_ORDER_ASSUMPTION_BY_DEPTH  SatParameters_MaxSatAssumptionOrder = 1
	SatParameters_ORDER_ASSUMPTION_BY_WEIGHT SatParameters_MaxSatAssumptionOrder = 2
)

func (SatParameters_MaxSatAssumptionOrder) Descriptor 

func (SatParameters_MaxSatAssumptionOrder) Descriptor() protoreflect.EnumDescriptor

func (SatParameters_MaxSatAssumptionOrder) Enum 

func (x SatParameters_MaxSatAssumptionOrder) Enum() *SatParameters_MaxSatAssumptionOrder

func (SatParameters_MaxSatAssumptionOrder) EnumDescriptor deprecated 

func (SatParameters_MaxSatAssumptionOrder) EnumDescriptor() ([]byte, []int)

Deprecated: Use SatParameters_MaxSatAssumptionOrder.Descriptor instead.

func (SatParameters_MaxSatAssumptionOrder) Number 

func (x SatParameters_MaxSatAssumptionOrder) Number() protoreflect.EnumNumber

func (SatParameters_MaxSatAssumptionOrder) String 

func (x SatParameters_MaxSatAssumptionOrder) String() string

func (SatParameters_MaxSatAssumptionOrder) Type 

func (SatParameters_MaxSatAssumptionOrder) Type() protoreflect.EnumType

func (*SatParameters_MaxSatAssumptionOrder) UnmarshalJSON deprecated 

func (x *SatParameters_MaxSatAssumptionOrder) UnmarshalJSON(b []byte) error

Deprecated: Do not use.

type SatParameters_MaxSatStratificationAlgorithm 

type SatParameters_MaxSatStratificationAlgorithm int32

What stratification algorithm we use in the presence of weight. 

const (
	// No stratification of the problem.
	SatParameters_STRATIFICATION_NONE SatParameters_MaxSatStratificationAlgorithm = 0
	// Start with literals with the highest weight, and when SAT, add the
	// literals with the next highest weight and so on.
	SatParameters_STRATIFICATION_DESCENT SatParameters_MaxSatStratificationAlgorithm = 1
	// Start with all literals. Each time a core is found with a given minimum
	// weight, do not consider literals with a lower weight for the next core
	// computation. If the subproblem is SAT, do like in STRATIFICATION_DESCENT
	// and just add the literals with the next highest weight.
	SatParameters_STRATIFICATION_ASCENT SatParameters_MaxSatStratificationAlgorithm = 2
)

func (SatParameters_MaxSatStratificationAlgorithm) Descriptor 

func (SatParameters_MaxSatStratificationAlgorithm) Descriptor() protoreflect.EnumDescriptor

func (SatParameters_MaxSatStratificationAlgorithm) Enum 

func (x SatParameters_MaxSatStratificationAlgorithm) Enum() *SatParameters_MaxSatStratificationAlgorithm

func (SatParameters_MaxSatStratificationAlgorithm) EnumDescriptor deprecated 

func (SatParameters_MaxSatStratificationAlgorithm) EnumDescriptor() ([]byte, []int)

Deprecated: Use SatParameters_MaxSatStratificationAlgorithm.Descriptor instead.

func (SatParameters_MaxSatStratificationAlgorithm) Number 

func (x SatParameters_MaxSatStratificationAlgorithm) Number() protoreflect.EnumNumber

func (SatParameters_MaxSatStratificationAlgorithm) String 

func (x SatParameters_MaxSatStratificationAlgorithm) String() string

func (SatParameters_MaxSatStratificationAlgorithm) Type 

func (SatParameters_MaxSatStratificationAlgorithm) Type() protoreflect.EnumType

func (*SatParameters_MaxSatStratificationAlgorithm) UnmarshalJSON deprecated 

func (x *SatParameters_MaxSatStratificationAlgorithm) UnmarshalJSON(b []byte) error

Deprecated: Do not use.

type SatParameters_Polarity 

type SatParameters_Polarity int32

Specifies the initial polarity (true/false) when the solver branches on a variable. This can be modified later by the user, or the phase saving heuristic.

Note(user): POLARITY_FALSE is usually a good choice because of the "natural" way to express a linear boolean problem. 

const (
	SatParameters_POLARITY_TRUE   SatParameters_Polarity = 0
	SatParameters_POLARITY_FALSE  SatParameters_Polarity = 1
	SatParameters_POLARITY_RANDOM SatParameters_Polarity = 2
	// Choose the sign that tends to satisfy the most constraints. This is
	// computed using a weighted sum: if a literal l appears in a constraint of
	// the form: ... + coeff * l +... <= rhs with positive coefficients and
	// rhs, then -sign(l) * coeff / rhs is added to the weight of l.variable().
	SatParameters_POLARITY_WEIGHTED_SIGN SatParameters_Polarity = 3
	// The opposite choice of POLARITY_WEIGHTED_SIGN.
	SatParameters_POLARITY_REVERSE_WEIGHTED_SIGN SatParameters_Polarity = 4
)

func (SatParameters_Polarity) Descriptor 

func (SatParameters_Polarity) Descriptor() protoreflect.EnumDescriptor

func (SatParameters_Polarity) Enum 

func (x SatParameters_Polarity) Enum() *SatParameters_Polarity

func (SatParameters_Polarity) EnumDescriptor deprecated 

func (SatParameters_Polarity) EnumDescriptor() ([]byte, []int)

Deprecated: Use SatParameters_Polarity.Descriptor instead.

func (SatParameters_Polarity) Number 

func (x SatParameters_Polarity) Number() protoreflect.EnumNumber

func (SatParameters_Polarity) String 

func (x SatParameters_Polarity) String() string

func (SatParameters_Polarity) Type 

func (SatParameters_Polarity) Type() protoreflect.EnumType

func (*SatParameters_Polarity) UnmarshalJSON deprecated 

func (x *SatParameters_Polarity) UnmarshalJSON(b []byte) error

Deprecated: Do not use.

type SatParameters_RestartAlgorithm 

type SatParameters_RestartAlgorithm int32

Restart algorithms.

A reference for the more advanced ones is: Gilles Audemard, Laurent Simon, "Refining Restarts Strategies for SAT and UNSAT", Principles and Practice of Constraint Programming Lecture Notes in Computer Science 2012, pp 118-126 

const (
	SatParameters_NO_RESTART SatParameters_RestartAlgorithm = 0
	// Just follow a Luby sequence times restart_period.
	SatParameters_LUBY_RESTART SatParameters_RestartAlgorithm = 1
	// Moving average restart based on the decision level of conflicts.
	SatParameters_DL_MOVING_AVERAGE_RESTART SatParameters_RestartAlgorithm = 2
	// Moving average restart based on the LBD of conflicts.
	SatParameters_LBD_MOVING_AVERAGE_RESTART SatParameters_RestartAlgorithm = 3
	// Fixed period restart every restart period.
	SatParameters_FIXED_RESTART SatParameters_RestartAlgorithm = 4
)

func (SatParameters_RestartAlgorithm) Descriptor 

func (SatParameters_RestartAlgorithm) Descriptor() protoreflect.EnumDescriptor

func (SatParameters_RestartAlgorithm) Enum 

func (x SatParameters_RestartAlgorithm) Enum() *SatParameters_RestartAlgorithm

func (SatParameters_RestartAlgorithm) EnumDescriptor deprecated 

func (SatParameters_RestartAlgorithm) EnumDescriptor() ([]byte, []int)

Deprecated: Use SatParameters_RestartAlgorithm.Descriptor instead.

func (SatParameters_RestartAlgorithm) Number 

func (x SatParameters_RestartAlgorithm) Number() protoreflect.EnumNumber

func (SatParameters_RestartAlgorithm) String 

func (x SatParameters_RestartAlgorithm) String() string

func (SatParameters_RestartAlgorithm) Type 

func (SatParameters_RestartAlgorithm) Type() protoreflect.EnumType

func (*SatParameters_RestartAlgorithm) UnmarshalJSON deprecated 

func (x *SatParameters_RestartAlgorithm) UnmarshalJSON(b []byte) error

Deprecated: Do not use.

type SatParameters_SearchBranching 

type SatParameters_SearchBranching int32

The search branching will be used to decide how to branch on unfixed nodes. 

const (
	// Try to fix all literals using the underlying SAT solver's heuristics,
	// then generate and fix literals until integer variables are fixed.
	SatParameters_AUTOMATIC_SEARCH SatParameters_SearchBranching = 0
	// If used then all decisions taken by the solver are made using a fixed
	// order as specified in the API or in the CpModelProto search_strategy
	// field.
	SatParameters_FIXED_SEARCH SatParameters_SearchBranching = 1
	// If used, the solver will use various generic heuristics in turn.
	SatParameters_PORTFOLIO_SEARCH SatParameters_SearchBranching = 2
	// If used, the solver will use heuristics from the LP relaxation. This
	// exploit the reduced costs of the variables in the relaxation.
	//
	// TODO(user): Maybe rename REDUCED_COST_SEARCH?
	SatParameters_LP_SEARCH SatParameters_SearchBranching = 3
	// If used, the solver uses the pseudo costs for branching. Pseudo costs
	// are computed using the historical change in objective bounds when some
	// decision are taken.
	SatParameters_PSEUDO_COST_SEARCH SatParameters_SearchBranching = 4
	// Mainly exposed here for testing. This quickly tries a lot of randomized
	// heuristics with a low conflict limit. It usually provides a good first
	// solution.
	SatParameters_PORTFOLIO_WITH_QUICK_RESTART_SEARCH SatParameters_SearchBranching = 5
	// Mainly used internally. This is like FIXED_SEARCH, except we follow the
	// solution_hint field of the CpModelProto rather than using the information
	// provided in the search_strategy.
	SatParameters_HINT_SEARCH SatParameters_SearchBranching = 6
)

func (SatParameters_SearchBranching) Descriptor 

func (SatParameters_SearchBranching) Descriptor() protoreflect.EnumDescriptor

func (SatParameters_SearchBranching) Enum 

func (x SatParameters_SearchBranching) Enum() *SatParameters_SearchBranching

func (SatParameters_SearchBranching) EnumDescriptor deprecated 

func (SatParameters_SearchBranching) EnumDescriptor() ([]byte, []int)

Deprecated: Use SatParameters_SearchBranching.Descriptor instead.

func (SatParameters_SearchBranching) Number 

func (x SatParameters_SearchBranching) Number() protoreflect.EnumNumber

func (SatParameters_SearchBranching) String 

func (x SatParameters_SearchBranching) String() string

func (SatParameters_SearchBranching) Type 

func (SatParameters_SearchBranching) Type() protoreflect.EnumType

func (*SatParameters_SearchBranching) UnmarshalJSON deprecated 

func (x *SatParameters_SearchBranching) UnmarshalJSON(b []byte) error

Deprecated: Do not use.

type SatParameters_VariableOrder 

type SatParameters_VariableOrder int32

Variables without activity (i.e. at the beginning of the search) will be tried in this preferred order. 

const (
	SatParameters_IN_ORDER         SatParameters_VariableOrder = 0 // As specified by the problem.
	SatParameters_IN_REVERSE_ORDER SatParameters_VariableOrder = 1
	SatParameters_IN_RANDOM_ORDER  SatParameters_VariableOrder = 2
)

func (SatParameters_VariableOrder) Descriptor 

func (SatParameters_VariableOrder) Descriptor() protoreflect.EnumDescriptor

func (SatParameters_VariableOrder) Enum 

func (x SatParameters_VariableOrder) Enum() *SatParameters_VariableOrder

func (SatParameters_VariableOrder) EnumDescriptor deprecated 

func (SatParameters_VariableOrder) EnumDescriptor() ([]byte, []int)

Deprecated: Use SatParameters_VariableOrder.Descriptor instead.

func (SatParameters_VariableOrder) Number 

func (x SatParameters_VariableOrder) Number() protoreflect.EnumNumber

func (SatParameters_VariableOrder) String 

func (x SatParameters_VariableOrder) String() string

func (SatParameters_VariableOrder) Type 

func (SatParameters_VariableOrder) Type() protoreflect.EnumType

func (*SatParameters_VariableOrder) UnmarshalJSON deprecated 

func (x *SatParameters_VariableOrder) UnmarshalJSON(b []byte) error

Deprecated: Do not use.

type SparsePermutationProto 

type SparsePermutationProto struct {

	// Each cycle is listed one after the other in the support field.
	// The size of each cycle is given (in order) in the cycle_sizes field.
	Support    []int32 `protobuf:"varint,1,rep,packed,name=support,proto3" json:"support,omitempty"`
	CycleSizes []int32 `protobuf:"varint,2,rep,packed,name=cycle_sizes,json=cycleSizes,proto3" json:"cycle_sizes,omitempty"`
	// contains filtered or unexported fields
}

A permutation of integers encoded as a list of cycles, hence the "sparse" format. The image of an element cycle[i] is cycle[(i + 1) % cycle_length].

func (*SparsePermutationProto) Descriptor deprecated 

func (*SparsePermutationProto) Descriptor() ([]byte, []int)

Deprecated: Use SparsePermutationProto.ProtoReflect.Descriptor instead.

func (*SparsePermutationProto) GetCycleSizes 

func (x *SparsePermutationProto) GetCycleSizes() []int32

func (*SparsePermutationProto) GetSupport 

func (x *SparsePermutationProto) GetSupport() []int32

func (*SparsePermutationProto) ProtoMessage 

func (*SparsePermutationProto) ProtoMessage()

func (*SparsePermutationProto) ProtoReflect 

func (x *SparsePermutationProto) ProtoReflect() protoreflect.Message

func (*SparsePermutationProto) Reset 

func (x *SparsePermutationProto) Reset()

func (*SparsePermutationProto) String 

func (x *SparsePermutationProto) String() string

type SymmetryProto 

type SymmetryProto struct {

	// A list of variable indices permutations that leave the feasible space of
	// solution invariant. Usually, we only encode a set of generators of the
	// group.
	Permutations []*SparsePermutationProto `protobuf:"bytes,1,rep,name=permutations,proto3" json:"permutations,omitempty"`
	// An orbitope is a special symmetry structure of the solution space. If the
	// variable indices are arranged in a matrix (with no duplicates), then any
	// permutation of the columns will be a valid permutation of the feasible
	// space.
	//
	// This arise quite often. The typical example is a graph coloring problem
	// where for each node i, you have j booleans to indicate its color. If the
	// variables color_of_i_is_j are arranged in a matrix[i][j], then any columns
	// permutations leave the problem invariant.
	Orbitopes []*DenseMatrixProto `protobuf:"bytes,2,rep,name=orbitopes,proto3" json:"orbitopes,omitempty"`
	// contains filtered or unexported fields
}

Experimental. For now, this is meant to be used by the solver and not filled by clients.

Hold symmetry information about the set of feasible solutions. If we permute the variable values of any feasible solution using one of the permutation described here, we should always get another feasible solution.

We usually also enforce that the objective of the new solution is the same.

The group of permutations encoded here is usually computed from the encoding of the model, so it is not meant to be a complete representation of the feasible solution symmetries, just a valid subgroup.

func (*SymmetryProto) Descriptor deprecated 

func (*SymmetryProto) Descriptor() ([]byte, []int)

Deprecated: Use SymmetryProto.ProtoReflect.Descriptor instead.

func (*SymmetryProto) GetOrbitopes 

func (x *SymmetryProto) GetOrbitopes() []*DenseMatrixProto

func (*SymmetryProto) GetPermutations 

func (x *SymmetryProto) GetPermutations() []*SparsePermutationProto

func (*SymmetryProto) ProtoMessage 

func (*SymmetryProto) ProtoMessage()

func (*SymmetryProto) ProtoReflect 

func (x *SymmetryProto) ProtoReflect() protoreflect.Message

func (*SymmetryProto) Reset 

func (x *SymmetryProto) Reset()

func (*SymmetryProto) String 

func (x *SymmetryProto) String() string

type TableConstraintProto 

type TableConstraintProto struct {
	Vars   []int32 `protobuf:"varint,1,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	Values []int64 `protobuf:"varint,2,rep,packed,name=values,proto3" json:"values,omitempty"`
	// If true, the meaning is "negated", that is we forbid any of the given
	// tuple from a feasible assignment.
	Negated bool `protobuf:"varint,3,opt,name=negated,proto3" json:"negated,omitempty"`
	// contains filtered or unexported fields
}

The values of the n-tuple formed by the given variables can only be one of the listed n-tuples in values. The n-tuples are encoded in a flattened way: 

[tuple0_v0, tuple0_v1, ..., tuple0_v{n-1}, tuple1_v0, ...].

func (*TableConstraintProto) Descriptor deprecated 

func (*TableConstraintProto) Descriptor() ([]byte, []int)

Deprecated: Use TableConstraintProto.ProtoReflect.Descriptor instead.

func (*TableConstraintProto) GetNegated 

func (x *TableConstraintProto) GetNegated() bool

func (*TableConstraintProto) GetValues 

func (x *TableConstraintProto) GetValues() []int64

func (*TableConstraintProto) GetVars 

func (x *TableConstraintProto) GetVars() []int32

func (*TableConstraintProto) ProtoMessage 

func (*TableConstraintProto) ProtoMessage()

func (*TableConstraintProto) ProtoReflect 

func (x *TableConstraintProto) ProtoReflect() protoreflect.Message

func (*TableConstraintProto) Reset 

func (x *TableConstraintProto) Reset()

func (*TableConstraintProto) String 

func (x *TableConstraintProto) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.