ortools.sat.python.cp_model_helper

class SolutionCallback(pybind11_builtins.pybind11_object):
SolutionCallback()

__init__(self: ortools.sat.python.cp_model_helper.SolutionCallback) -> None

def OnSolutionCallback(unknown):

OnSolutionCallback(self: ortools.sat.python.cp_model_helper.SolutionCallback) -> None

def BestObjectiveBound(unknown):

BestObjectiveBound(self: ortools.sat.python.cp_model_helper.SolutionCallback) -> float

def DeterministicTime(unknown):

DeterministicTime(self: ortools.sat.python.cp_model_helper.SolutionCallback) -> float

def HasResponse(unknown):

HasResponse(self: ortools.sat.python.cp_model_helper.SolutionCallback) -> bool

def NumBinaryPropagations(unknown):

NumBinaryPropagations(self: ortools.sat.python.cp_model_helper.SolutionCallback) -> int

def NumBooleans(unknown):

NumBooleans(self: ortools.sat.python.cp_model_helper.SolutionCallback) -> int

def NumBranches(unknown):

NumBranches(self: ortools.sat.python.cp_model_helper.SolutionCallback) -> int

def NumConflicts(unknown):

NumConflicts(self: ortools.sat.python.cp_model_helper.SolutionCallback) -> int

def NumIntegerPropagations(unknown):

NumIntegerPropagations(self: ortools.sat.python.cp_model_helper.SolutionCallback) -> int

def ObjectiveValue(unknown):

ObjectiveValue(self: ortools.sat.python.cp_model_helper.SolutionCallback) -> float

def Response(unknown):

Response(self: ortools.sat.python.cp_model_helper.SolutionCallback) -> operations_research::sat::CpSolverResponse

def SolutionBooleanValue(unknown):

SolutionBooleanValue(self: ortools.sat.python.cp_model_helper.SolutionCallback, index: int) -> bool

def SolutionIntegerValue(unknown):

SolutionIntegerValue(self: ortools.sat.python.cp_model_helper.SolutionCallback, index: int) -> int

def StopSearch(unknown):

StopSearch(self: ortools.sat.python.cp_model_helper.SolutionCallback) -> None

def UserTime(unknown):

UserTime(self: ortools.sat.python.cp_model_helper.SolutionCallback) -> float

def WallTime(unknown):

WallTime(self: ortools.sat.python.cp_model_helper.SolutionCallback) -> float

def Value(unknown):

Value(args, *kwargs) Overloaded function.

  1. Value(self: ortools.sat.python.cp_model_helper.SolutionCallback, arg0: operations_research::sat::python::LinearExpr) -> int

Returns the value of a linear expression after solve.

  1. Value(self: ortools.sat.python.cp_model_helper.SolutionCallback, arg0: int) -> int

Returns the value of a linear expression after solve.

def FloatValue(unknown):

FloatValue(args, *kwargs) Overloaded function.

  1. FloatValue(self: ortools.sat.python.cp_model_helper.SolutionCallback, arg0: operations_research::sat::python::LinearExpr) -> float

Returns the value of a floating point linear expression after solve.

  1. FloatValue(self: ortools.sat.python.cp_model_helper.SolutionCallback, arg0: float) -> float

Returns the value of a floating point linear expression after solve.

def BooleanValue(unknown):

BooleanValue(args, *kwargs) Overloaded function.

  1. BooleanValue(self: ortools.sat.python.cp_model_helper.SolutionCallback, arg0: operations_research::sat::python::Literal) -> bool

Returns the Boolean value of a literal after solve.

  1. BooleanValue(self: ortools.sat.python.cp_model_helper.SolutionCallback, arg0: bool) -> bool

Returns the Boolean value of a literal after solve.

class ResponseHelper(pybind11_builtins.pybind11_object):
ResponseHelper(*args, **kwargs)
def boolean_value(unknown):

boolean_value(args, *kwargs) Overloaded function.

  1. boolean_value(response: operations_research::sat::CpSolverResponse, lit: operations_research::sat::python::Literal) -> bool

  2. boolean_value(response: operations_research::sat::CpSolverResponse, lit: bool) -> bool

def float_value(unknown):

float_value(args, *kwargs) Overloaded function.

  1. float_value(response: operations_research::sat::CpSolverResponse, expr: operations_research::sat::python::LinearExpr) -> float

  2. float_value(response: operations_research::sat::CpSolverResponse, value: float) -> float

def sufficient_assumptions_for_infeasibility(unknown):

sufficient_assumptions_for_infeasibility(response: operations_research::sat::CpSolverResponse) -> list[int]

def value(unknown):

value(args, *kwargs) Overloaded function.

  1. value(response: operations_research::sat::CpSolverResponse, expr: operations_research::sat::python::LinearExpr) -> int

  2. value(response: operations_research::sat::CpSolverResponse, value: int) -> int

class SolveWrapper(pybind11_builtins.pybind11_object):
SolveWrapper()

__init__(self: ortools.sat.python.cp_model_helper.SolveWrapper) -> None

def add_log_callback(unknown):

add_log_callback(self: ortools.sat.python.cp_model_helper.SolveWrapper, log_callback: Callable[[str], None]) -> None

def add_solution_callback(unknown):

add_solution_callback(self: ortools.sat.python.cp_model_helper.SolveWrapper, callback: ortools.sat.python.cp_model_helper.SolutionCallback) -> None

def clear_solution_callback(unknown):

clear_solution_callback(self: ortools.sat.python.cp_model_helper.SolveWrapper, arg0: ortools.sat.python.cp_model_helper.SolutionCallback) -> None

def add_best_bound_callback(unknown):

add_best_bound_callback(self: ortools.sat.python.cp_model_helper.SolveWrapper, best_bound_callback: Callable[[float], None]) -> None

def set_parameters(unknown):

set_parameters(self: ortools.sat.python.cp_model_helper.SolveWrapper, parameters: operations_research::sat::SatParameters) -> None

def solve(unknown):

solve(self: ortools.sat.python.cp_model_helper.SolveWrapper, model_proto: operations_research::sat::CpModelProto) -> operations_research::sat::CpSolverResponse

class CpSatHelper(pybind11_builtins.pybind11_object):
CpSatHelper(*args, **kwargs)
def model_stats(unknown):

model_stats(model_proto: operations_research::sat::CpModelProto) -> str

def solver_response_stats(unknown):

solver_response_stats(response: operations_research::sat::CpSolverResponse) -> str

def validate_model(unknown):

validate_model(model_proto: operations_research::sat::CpModelProto) -> str

def write_model_to_file(unknown):

write_model_to_file(model_proto: operations_research::sat::CpModelProto, filename: str) -> bool

class LinearExpr(pybind11_builtins.pybind11_object):

A class to hold an integer or floating point linear expression.

A linear expression is built from (integer or floating point) constants and variables. For example, x + 2 * (y - z + 1).

Linear expressions are used in CP-SAT models in constraints and in the objective.

Note that constraints only accept linear expressions with integral coefficients and constants. On the other hand, The objective can be a linear expression with floating point coefficients and constants.

You can define linear constraints as in:

model.add(x + 2 * y <= 5)
model.add(sum(array_of_vars) == 5)
  • In CP-SAT, the objective is a linear expression:
model.minimize(x + 2 * y + z)
  • For large arrays, using the LinearExpr class is faster that using the python sum() function. You can create constraints and the objective from lists of linear expressions or coefficients as follows:
model.minimize(cp_model.LinearExpr.sum(expressions))
model.add(cp_model.LinearExpr.weighted_sum(expressions, coefficients) >= 0)
LinearExpr(*args, **kwargs)
def sum(unknown):

sum(*args) -> ortools.sat.python.cp_model_helper.LinearExpr

Returns the sum(expressions).

def weighted_sum(unknown):

weighted_sum(expressions: Sequence, coefficients: Sequence) -> ortools.sat.python.cp_model_helper.LinearExpr

Returns the sum of (expressions[i] * coefficients[i])

def term(unknown):

term(args, *kwargs) Overloaded function.

  1. term(expr: ortools.sat.python.cp_model_helper.LinearExpr, coeff: int) -> ortools.sat.python.cp_model_helper.LinearExpr

Returns expr * coeff.

  1. term(expr: ortools.sat.python.cp_model_helper.LinearExpr, coeff: float) -> ortools.sat.python.cp_model_helper.LinearExpr

Returns expr * coeff.

def affine(unknown):

affine(args, *kwargs) Overloaded function.

  1. affine(expr: ortools.sat.python.cp_model_helper.LinearExpr, coeff: int, offset: int) -> ortools.sat.python.cp_model_helper.LinearExpr

Returns expr * coeff + offset.

  1. affine(expr: ortools.sat.python.cp_model_helper.LinearExpr, coeff: float, offset: float) -> ortools.sat.python.cp_model_helper.LinearExpr

Returns expr * coeff + offset.

def constant(unknown):

constant(args, *kwargs) Overloaded function.

  1. constant(value: int) -> ortools.sat.python.cp_model_helper.LinearExpr

Returns a new LinearExpr that is the given constant.

  1. constant(value: float) -> ortools.sat.python.cp_model_helper.LinearExpr

Returns a new LinearExpr that is the given constant.

def Sum(unknown):

Sum(*args) -> ortools.sat.python.cp_model_helper.LinearExpr

def WeightedSum(unknown):

WeightedSum(expressions: Sequence, coefficients: Sequence) -> ortools.sat.python.cp_model_helper.LinearExpr

def Term(unknown):

Term(args, *kwargs) Overloaded function.

  1. Term(expr: ortools.sat.python.cp_model_helper.LinearExpr, coeff: int) -> ortools.sat.python.cp_model_helper.LinearExpr

Returns expr * coeff.

  1. Term(expr: ortools.sat.python.cp_model_helper.LinearExpr, coeff: float) -> ortools.sat.python.cp_model_helper.LinearExpr

Returns expr * coeff.

def is_integer(unknown):

is_integer(self: ortools.sat.python.cp_model_helper.LinearExpr) -> bool

class FlatFloatExpr(LinearExpr):

A flattened and optimized floating point linear expression.

It can be used to cache complex expressions as parsing them is only done once.

FlatFloatExpr()

__init__(self: ortools.sat.python.cp_model_helper.FlatFloatExpr, arg0: ortools.sat.python.cp_model_helper.LinearExpr) -> None

vars

(arg0: ortools.sat.python.cp_model_helper.FlatFloatExpr) -> list[operations_research::sat::python::IntVar]

coeffs

(arg0: ortools.sat.python.cp_model_helper.FlatFloatExpr) -> list[float]

Inherited Members
LinearExpr
sum
weighted_sum
term
affine
constant
Sum
WeightedSum
Term
is_integer
class FlatIntExpr(LinearExpr):

A flattened and optimized integer linear expression.

It can be used to cache complex expressions as parsing them is only done once.

FlatIntExpr()

__init__(self: ortools.sat.python.cp_model_helper.FlatIntExpr, arg0: ortools.sat.python.cp_model_helper.LinearExpr) -> None

vars

(arg0: ortools.sat.python.cp_model_helper.FlatIntExpr) -> list[operations_research::sat::python::IntVar]

Inherited Members
LinearExpr
sum
weighted_sum
term
affine
constant
Sum
WeightedSum
Term
is_integer
class SumArray(LinearExpr):

A class to hold a sum of linear expressions, and optional integer and double offsets (at most one of them can be non-zero, this is DCHECKed).

SumArray()

__init__(self: ortools.sat.python.cp_model_helper.SumArray, arg0: list[ortools.sat.python.cp_model_helper.LinearExpr], arg1: int, arg2: float) -> None

double_offset

(arg0: ortools.sat.python.cp_model_helper.SumArray) -> float

Inherited Members
LinearExpr
sum
weighted_sum
term
affine
constant
Sum
WeightedSum
Term
is_integer
class FloatAffine(LinearExpr):

A class to hold linear_expr * a = b (a and b are floating point numbers).

FloatAffine()

__init__(self: ortools.sat.python.cp_model_helper.FloatAffine, arg0: ortools.sat.python.cp_model_helper.LinearExpr, arg1: float, arg2: float) -> None

coefficient

(arg0: ortools.sat.python.cp_model_helper.FloatAffine) -> float

Inherited Members
LinearExpr
sum
weighted_sum
term
affine
constant
Sum
WeightedSum
Term
is_integer
class IntAffine(LinearExpr):

A class to hold linear_expr * a = b (a and b are integers).

IntAffine()

__init__(self: ortools.sat.python.cp_model_helper.IntAffine, arg0: ortools.sat.python.cp_model_helper.LinearExpr, arg1: int, arg2: int) -> None

Inherited Members
LinearExpr
sum
weighted_sum
term
affine
constant
Sum
WeightedSum
Term
is_integer
class Literal(LinearExpr):

A class to hold a Boolean literal.

A literal is a Boolean variable or its negation.

Literals are used in CP-SAT models in constraints and in the objective.

  • You can define literal as in:
b1 = model.new_bool_var()
b2 = model.new_bool_var()
# Simple Boolean constraint.
model.add_bool_or(b1, b2.negated())
# We can use the ~ operator to negate a literal.
model.add_bool_or(b1, ~b2)
# Enforcement literals must be literals.
x = model.new_int_var(0, 10, 'x')
model.add(x == 5).only_enforced_if(~b1)
  • Literals can be used directly in linear constraints or in the objective:
model.minimize(b1  + 2 * ~b2)
Literal(*args, **kwargs)
def negated(unknown):

negated(self: ortools.sat.python.cp_model_helper.Literal) -> ortools.sat.python.cp_model_helper.Literal

Returns the negation of a literal (a Boolean variable or its negation).

This method implements the logical negation of a Boolean variable. It is only valid if the variable has a Boolean domain (0 or 1).

Note that this method is nilpotent: x.negated().negated() == x.

Returns: The negation of the current literal.

def Index(unknown):

Index(self: ortools.sat.python.cp_model_helper.Literal) -> int

Inherited Members
LinearExpr
sum
weighted_sum
term
affine
constant
Sum
WeightedSum
Term
is_integer
class IntVar(Literal):

A class to hold an integer or Boolean variable

IntVar()

__init__(args, *kwargs) Overloaded function.

  1. __init__(self: ortools.sat.python.cp_model_helper.IntVar, arg0: operations_research::sat::CpModelProto, arg1: int) -> None

  2. __init__(self: ortools.sat.python.cp_model_helper.IntVar, arg0: operations_research::sat::CpModelProto) -> None

proto

(arg0: ortools.sat.python.cp_model_helper.IntVar) -> operations_research::sat::IntegerVariableProto

model_proto

(arg0: ortools.sat.python.cp_model_helper.IntVar) -> operations_research::sat::CpModelProto

is_boolean

(arg0: ortools.sat.python.cp_model_helper.IntVar) -> bool

def with_name(unknown):

with_name(self: ortools.sat.python.cp_model_helper.IntVar, name: str) -> ortools.sat.python.cp_model_helper.IntVar

Sets the name of the variable and returns the variable.

def with_domain(unknown):

with_domain(self: ortools.sat.python.cp_model_helper.IntVar, domain: ortools.util.python.sorted_interval_list.Domain) -> ortools.sat.python.cp_model_helper.IntVar

Sets the domain of the variable and returns the variable.

def negated(unknown):

negated(self: ortools.sat.python.cp_model_helper.IntVar) -> ortools.sat.python.cp_model_helper.Literal

Returns the negation of the current variable.

def Name(unknown):

Name(self: ortools.sat.python.cp_model_helper.IntVar) -> str

def Proto(unknown):

Proto(self: ortools.sat.python.cp_model_helper.IntVar) -> operations_research::sat::IntegerVariableProto

def Index(unknown):

Index(self: ortools.sat.python.cp_model_helper.IntVar) -> int

Inherited Members
LinearExpr
sum
weighted_sum
term
affine
constant
Sum
WeightedSum
Term
is_integer
class NotBooleanVariable(Literal):

A class to hold a negated variable index.

NotBooleanVariable(*args, **kwargs)
def negated(unknown):

negated(self: ortools.sat.python.cp_model_helper.NotBooleanVariable) -> ortools.sat.python.cp_model_helper.Literal

Returns the negation of the current literal, that is the original Boolean variable.

def Not(unknown):

Not(self: ortools.sat.python.cp_model_helper.NotBooleanVariable) -> ortools.sat.python.cp_model_helper.Literal

Returns the negation of the current literal, that is the original Boolean variable.

Inherited Members
Literal
Index
LinearExpr
sum
weighted_sum
term
affine
constant
Sum
WeightedSum
Term
is_integer
class BoundedLinearExpression(pybind11_builtins.pybind11_object):

A class to hold a linear expression with bounds.

BoundedLinearExpression()

__init__(args, *kwargs) Overloaded function.

  1. __init__(self: ortools.sat.python.cp_model_helper.BoundedLinearExpression, arg0: ortools.sat.python.cp_model_helper.LinearExpr, arg1: ortools.util.python.sorted_interval_list.Domain) -> None

  2. __init__(self: ortools.sat.python.cp_model_helper.BoundedLinearExpression, arg0: ortools.sat.python.cp_model_helper.LinearExpr, arg1: ortools.sat.python.cp_model_helper.LinearExpr, arg2: ortools.util.python.sorted_interval_list.Domain) -> None

class BoolArgumentConstraint(pybind11_builtins.pybind11_object):

Members:

at_most_one

bool_and

bool_or

bool_xor

exactly_one

BoolArgumentConstraint()

__init__(self: ortools.sat.python.cp_model_helper.BoolArgumentConstraint, value: int) -> None

name

name(self: object) -> str

at_most_one = <BoolArgumentConstraint.at_most_one: 0>
bool_and = <BoolArgumentConstraint.bool_and: 1>
bool_or = <BoolArgumentConstraint.bool_or: 2>
bool_xor = <BoolArgumentConstraint.bool_xor: 3>
exactly_one = <BoolArgumentConstraint.exactly_one: 4>
class LinearArgumentConstraint(pybind11_builtins.pybind11_object):

Members:

div

max

min

mod

prod

LinearArgumentConstraint()

__init__(self: ortools.sat.python.cp_model_helper.LinearArgumentConstraint, value: int) -> None

name

name(self: object) -> str

div = <LinearArgumentConstraint.div: 0>
max = <LinearArgumentConstraint.max: 1>
min = <LinearArgumentConstraint.min: 2>
mod = <LinearArgumentConstraint.mod: 3>
prod = <LinearArgumentConstraint.prod: 4>
class CpBaseModel(pybind11_builtins.pybind11_object):

Base class for the CP model.

CpBaseModel()

__init__(self: ortools.sat.python.cp_model_helper.CpBaseModel, arg0: operations_research::sat::CpModelProto) -> None

model_proto

(arg0: ortools.sat.python.cp_model_helper.CpBaseModel) -> operations_research::sat::CpModelProto

def get_or_make_index_from_constant(unknown):

get_or_make_index_from_constant(self: ortools.sat.python.cp_model_helper.CpBaseModel, value: int) -> int

Returns the index of the given constant value.

def get_or_make_boolean_index(unknown):

get_or_make_boolean_index(self: ortools.sat.python.cp_model_helper.CpBaseModel, value: object) -> int

Returns the index of the given boolean value.

def get_or_make_variable_index(unknown):

get_or_make_variable_index(self: ortools.sat.python.cp_model_helper.CpBaseModel, arg: object) -> int

Returns the index of the given variable or constant variable.

def is_boolean_value(unknown):

is_boolean_value(self: ortools.sat.python.cp_model_helper.CpBaseModel, value: object) -> bool

def rebuild_constant_map(unknown):

rebuild_constant_map(self: ortools.sat.python.cp_model_helper.CpBaseModel) -> None

class Constraint(pybind11_builtins.pybind11_object):

Base class for constraints.

Constraints are built by the CpModel through the add methods. Once created by the CpModel class, they are automatically added to the model. The purpose of this class is to allow specification of enforcement literals for this constraint.

b = model.new_bool_var('b')
x = model.new_int_var(0, 10, 'x')
y = model.new_int_var(0, 10, 'y')

model.add(x + 2 * y == 5).only_enforce_if(b.negated())
Constraint()

__init__(self: ortools.sat.python.cp_model_helper.Constraint, arg0: ortools.sat.python.cp_model_helper.CpBaseModel, arg1: int) -> None

model_proto

(arg0: ortools.sat.python.cp_model_helper.Constraint) -> operations_research::sat::CpModelProto

proto

(arg0: ortools.sat.python.cp_model_helper.Constraint) -> operations_research::sat::ConstraintProto

def with_name(unknown):

with_name(self: ortools.sat.python.cp_model_helper.Constraint, arg0: str) -> ortools.sat.python.cp_model_helper.Constraint

Sets the name of the constraint and returns the constraints

def only_enforce_if(unknown):

only_enforce_if(args, *kwargs) Overloaded function.

  1. only_enforce_if(self: ortools.sat.python.cp_model_helper.Constraint, literal: ortools.sat.python.cp_model_helper.Literal) -> ortools.sat.python.cp_model_helper.Constraint

    Adds one or more enforcement literals to the constraint.

    This method adds one or more literals (that is, a boolean variable or its negation) as enforcement literals. The conjunction of all these literals determines whether the constraint is active or not. It acts as an implication, so if the conjunction is true, it implies that the constraint must be enforced. If it is false, then the constraint is ignored.

    BoolOr, BoolAnd, and linear constraints all support enforcement literals.

    Args: *literals: One or more Boolean literals.

    Returns: self.

  2. only_enforce_if(self: ortools.sat.python.cp_model_helper.Constraint, literal: bool) -> ortools.sat.python.cp_model_helper.Constraint

    Adds one or more enforcement literals to the constraint.

    This method adds one or more literals (that is, a boolean variable or its negation) as enforcement literals. The conjunction of all these literals determines whether the constraint is active or not. It acts as an implication, so if the conjunction is true, it implies that the constraint must be enforced. If it is false, then the constraint is ignored.

    BoolOr, BoolAnd, and linear constraints all support enforcement literals.

    Args: *literals: One or more Boolean literals.

    Returns: self.

  3. only_enforce_if(self: ortools.sat.python.cp_model_helper.Constraint, literals: list[ortools.sat.python.cp_model_helper.Literal]) -> None

    Adds one or more enforcement literals to the constraint.

    This method adds one or more literals (that is, a boolean variable or its negation) as enforcement literals. The conjunction of all these literals determines whether the constraint is active or not. It acts as an implication, so if the conjunction is true, it implies that the constraint must be enforced. If it is false, then the constraint is ignored.

    BoolOr, BoolAnd, and linear constraints all support enforcement literals.

    Args: *literals: One or more Boolean literals.

    Returns: self.

  4. only_enforce_if(self: ortools.sat.python.cp_model_helper.Constraint, *args) -> None

    Adds one or more enforcement literals to the constraint.

    This method adds one or more literals (that is, a boolean variable or its negation) as enforcement literals. The conjunction of all these literals determines whether the constraint is active or not. It acts as an implication, so if the conjunction is true, it implies that the constraint must be enforced. If it is false, then the constraint is ignored.

    BoolOr, BoolAnd, and linear constraints all support enforcement literals.

    Args: *literals: One or more Boolean literals.

    Returns: self.

def Name(unknown):

Name(self: ortools.sat.python.cp_model_helper.Constraint) -> str

def Index(unknown):

Index(self: ortools.sat.python.cp_model_helper.Constraint) -> int

def Proto(unknown):

Proto(self: ortools.sat.python.cp_model_helper.Constraint) -> operations_research::sat::ConstraintProto

def OnlyEnforceIf(unknown):

OnlyEnforceIf(self: ortools.sat.python.cp_model_helper.Constraint, *args) -> None

class IntervalVar(pybind11_builtins.pybind11_object):

Represents an Interval variable.

An interval variable is both a constraint and a variable. It is defined by three integer variables: start, size, and end.

It is a constraint because, internally, it enforces that start + size == end.

It is also a variable as it can appear in specific scheduling constraints: NoOverlap, NoOverlap2D, Cumulative.

Optionally, an enforcement literal can be added to this constraint, in which case these scheduling constraints will ignore interval variables with enforcement literals assigned to false. Conversely, these constraints will also set these enforcement literals to false if they cannot fit these intervals into the schedule.

Raises:
  • ValueError: if start, size, end are not defined, or have the wrong type.
IntervalVar()

__init__(self: ortools.sat.python.cp_model_helper.IntervalVar, arg0: operations_research::sat::CpModelProto, arg1: int) -> None

model_proto

(arg0: ortools.sat.python.cp_model_helper.IntervalVar) -> operations_research::sat::CpModelProto

proto

(arg0: ortools.sat.python.cp_model_helper.IntervalVar) -> operations_research::sat::ConstraintProto

def start_expr(unknown):

start_expr(self: ortools.sat.python.cp_model_helper.IntervalVar) -> object

Returns the start expression of the interval variable.

def size_expr(unknown):

size_expr(self: ortools.sat.python.cp_model_helper.IntervalVar) -> object

Returns the size expression of the interval variable.

def end_expr(unknown):

end_expr(self: ortools.sat.python.cp_model_helper.IntervalVar) -> object

Returns the end expression of the interval variable.

def presence_literals(unknown):

presence_literals(self: ortools.sat.python.cp_model_helper.IntervalVar) -> list[ortools.sat.python.cp_model_helper.Literal]

Returns the list of enforcement literals of the interval variable.

def Proto(unknown):

Proto(self: ortools.sat.python.cp_model_helper.IntervalVar) -> operations_research::sat::ConstraintProto

def Index(unknown):

Index(self: ortools.sat.python.cp_model_helper.IntervalVar) -> int

def Name(unknown):

Name(self: ortools.sat.python.cp_model_helper.IntervalVar) -> str

def StartExpr(unknown):

StartExpr(self: ortools.sat.python.cp_model_helper.IntervalVar) -> object

def SizeExpr(unknown):

SizeExpr(self: ortools.sat.python.cp_model_helper.IntervalVar) -> object

def EndExpr(unknown):

EndExpr(self: ortools.sat.python.cp_model_helper.IntervalVar) -> object

def rebuild_from_linear_expression_proto(unknown):

rebuild_from_linear_expression_proto(proto: operations_research::sat::LinearExpressionProto, model_proto: operations_research::sat::CpModelProto) -> object

class SatParameters(pybind11_builtins.pybind11_object):
SatParameters()

__init__(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.SatParameters, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.SatParameters, arg0: str) -> bool

def clear_name(unknown):

clear_name(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

preferred_variable_order

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> operations_research::sat::SatParameters_VariableOrder

def clear_preferred_variable_order(unknown):

clear_preferred_variable_order(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

initial_polarity

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> operations_research::sat::SatParameters_Polarity

def clear_initial_polarity(unknown):

clear_initial_polarity(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_phase_saving

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_phase_saving(unknown):

clear_use_phase_saving(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

polarity_rephase_increment

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_polarity_rephase_increment(unknown):

clear_polarity_rephase_increment(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

polarity_exploit_ls_hints

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_polarity_exploit_ls_hints(unknown):

clear_polarity_exploit_ls_hints(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

random_polarity_ratio

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_random_polarity_ratio(unknown):

clear_random_polarity_ratio(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

random_branches_ratio

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_random_branches_ratio(unknown):

clear_random_branches_ratio(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_erwa_heuristic

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_erwa_heuristic(unknown):

clear_use_erwa_heuristic(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

initial_variables_activity

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_initial_variables_activity(unknown):

clear_initial_variables_activity(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

also_bump_variables_in_conflict_reasons

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_also_bump_variables_in_conflict_reasons(unknown):

clear_also_bump_variables_in_conflict_reasons(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

minimization_algorithm

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> operations_research::sat::SatParameters_ConflictMinimizationAlgorithm

def clear_minimization_algorithm(unknown):

clear_minimization_algorithm(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

binary_minimization_algorithm

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> operations_research::sat::SatParameters_BinaryMinizationAlgorithm

def clear_binary_minimization_algorithm(unknown):

clear_binary_minimization_algorithm(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

subsumption_during_conflict_analysis

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_subsumption_during_conflict_analysis(unknown):

clear_subsumption_during_conflict_analysis(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

extra_subsumption_during_conflict_analysis

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_extra_subsumption_during_conflict_analysis(unknown):

clear_extra_subsumption_during_conflict_analysis(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

decision_subsumption_during_conflict_analysis

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_decision_subsumption_during_conflict_analysis(unknown):

clear_decision_subsumption_during_conflict_analysis(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

eagerly_subsume_last_n_conflicts

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_eagerly_subsume_last_n_conflicts(unknown):

clear_eagerly_subsume_last_n_conflicts(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

subsume_during_vivification

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_subsume_during_vivification(unknown):

clear_subsume_during_vivification(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_chronological_backtracking

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_chronological_backtracking(unknown):

clear_use_chronological_backtracking(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_backjump_levels

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_max_backjump_levels(unknown):

clear_max_backjump_levels(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

chronological_backtrack_min_conflicts

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_chronological_backtrack_min_conflicts(unknown):

clear_chronological_backtrack_min_conflicts(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

clause_cleanup_period

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_clause_cleanup_period(unknown):

clear_clause_cleanup_period(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

clause_cleanup_period_increment

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_clause_cleanup_period_increment(unknown):

clear_clause_cleanup_period_increment(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

clause_cleanup_target

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_clause_cleanup_target(unknown):

clear_clause_cleanup_target(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

clause_cleanup_ratio

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_clause_cleanup_ratio(unknown):

clear_clause_cleanup_ratio(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

clause_cleanup_lbd_bound

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_clause_cleanup_lbd_bound(unknown):

clear_clause_cleanup_lbd_bound(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

clause_cleanup_lbd_tier1

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_clause_cleanup_lbd_tier1(unknown):

clear_clause_cleanup_lbd_tier1(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

clause_cleanup_lbd_tier2

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_clause_cleanup_lbd_tier2(unknown):

clear_clause_cleanup_lbd_tier2(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

clause_cleanup_ordering

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> operations_research::sat::SatParameters_ClauseOrdering

def clear_clause_cleanup_ordering(unknown):

clear_clause_cleanup_ordering(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

pb_cleanup_increment

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_pb_cleanup_increment(unknown):

clear_pb_cleanup_increment(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

pb_cleanup_ratio

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_pb_cleanup_ratio(unknown):

clear_pb_cleanup_ratio(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

variable_activity_decay

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_variable_activity_decay(unknown):

clear_variable_activity_decay(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_variable_activity_value

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_max_variable_activity_value(unknown):

clear_max_variable_activity_value(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

glucose_max_decay

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_glucose_max_decay(unknown):

clear_glucose_max_decay(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

glucose_decay_increment

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_glucose_decay_increment(unknown):

clear_glucose_decay_increment(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

glucose_decay_increment_period

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_glucose_decay_increment_period(unknown):

clear_glucose_decay_increment_period(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

clause_activity_decay

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_clause_activity_decay(unknown):

clear_clause_activity_decay(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_clause_activity_value

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_max_clause_activity_value(unknown):

clear_max_clause_activity_value(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

restart_algorithms

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> google::protobuf::RepeatedField

default_restart_algorithms

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> str

def clear_default_restart_algorithms(unknown):

clear_default_restart_algorithms(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

restart_period

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_restart_period(unknown):

clear_restart_period(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

restart_running_window_size

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_restart_running_window_size(unknown):

clear_restart_running_window_size(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

restart_dl_average_ratio

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_restart_dl_average_ratio(unknown):

clear_restart_dl_average_ratio(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

restart_lbd_average_ratio

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_restart_lbd_average_ratio(unknown):

clear_restart_lbd_average_ratio(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_blocking_restart

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_blocking_restart(unknown):

clear_use_blocking_restart(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

blocking_restart_window_size

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_blocking_restart_window_size(unknown):

clear_blocking_restart_window_size(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

blocking_restart_multiplier

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_blocking_restart_multiplier(unknown):

clear_blocking_restart_multiplier(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

num_conflicts_before_strategy_changes

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_num_conflicts_before_strategy_changes(unknown):

clear_num_conflicts_before_strategy_changes(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

strategy_change_increase_ratio

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_strategy_change_increase_ratio(unknown):

clear_strategy_change_increase_ratio(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_time_in_seconds

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_max_time_in_seconds(unknown):

clear_max_time_in_seconds(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_deterministic_time

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_max_deterministic_time(unknown):

clear_max_deterministic_time(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_num_deterministic_batches

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_max_num_deterministic_batches(unknown):

clear_max_num_deterministic_batches(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_number_of_conflicts

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_max_number_of_conflicts(unknown):

clear_max_number_of_conflicts(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_memory_in_mb

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_max_memory_in_mb(unknown):

clear_max_memory_in_mb(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

absolute_gap_limit

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_absolute_gap_limit(unknown):

clear_absolute_gap_limit(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

relative_gap_limit

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_relative_gap_limit(unknown):

clear_relative_gap_limit(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

def clear_random_seed(unknown):

clear_random_seed(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

permute_variable_randomly

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_permute_variable_randomly(unknown):

clear_permute_variable_randomly(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

permute_presolve_constraint_order

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_permute_presolve_constraint_order(unknown):

clear_permute_presolve_constraint_order(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_absl_random

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_absl_random(unknown):

clear_use_absl_random(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

log_search_progress

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_log_search_progress(unknown):

clear_log_search_progress(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

log_subsolver_statistics

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_log_subsolver_statistics(unknown):

clear_log_subsolver_statistics(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

def clear_log_prefix(unknown):

clear_log_prefix(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

log_to_stdout

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_log_to_stdout(unknown):

clear_log_to_stdout(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

log_to_response

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_log_to_response(unknown):

clear_log_to_response(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_pb_resolution

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_pb_resolution(unknown):

clear_use_pb_resolution(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

minimize_reduction_during_pb_resolution

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_minimize_reduction_during_pb_resolution(unknown):

clear_minimize_reduction_during_pb_resolution(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

count_assumption_levels_in_lbd

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_count_assumption_levels_in_lbd(unknown):

clear_count_assumption_levels_in_lbd(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

presolve_bve_threshold

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_presolve_bve_threshold(unknown):

clear_presolve_bve_threshold(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

filter_sat_postsolve_clauses

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_filter_sat_postsolve_clauses(unknown):

clear_filter_sat_postsolve_clauses(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

presolve_bve_clause_weight

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_presolve_bve_clause_weight(unknown):

clear_presolve_bve_clause_weight(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

probing_deterministic_time_limit

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_probing_deterministic_time_limit(unknown):

clear_probing_deterministic_time_limit(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

presolve_probing_deterministic_time_limit

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_presolve_probing_deterministic_time_limit(unknown):

clear_presolve_probing_deterministic_time_limit(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

presolve_blocked_clause

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_presolve_blocked_clause(unknown):

clear_presolve_blocked_clause(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

presolve_use_bva

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_presolve_use_bva(unknown):

clear_presolve_use_bva(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

presolve_bva_threshold

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_presolve_bva_threshold(unknown):

clear_presolve_bva_threshold(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_presolve_iterations

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_max_presolve_iterations(unknown):

clear_max_presolve_iterations(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

cp_model_presolve

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_cp_model_presolve(unknown):

clear_cp_model_presolve(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

cp_model_probing_level

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_cp_model_probing_level(unknown):

clear_cp_model_probing_level(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

cp_model_use_sat_presolve

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_cp_model_use_sat_presolve(unknown):

clear_cp_model_use_sat_presolve(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

load_at_most_ones_in_sat_presolve

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_load_at_most_ones_in_sat_presolve(unknown):

clear_load_at_most_ones_in_sat_presolve(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

remove_fixed_variables_early

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_remove_fixed_variables_early(unknown):

clear_remove_fixed_variables_early(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

detect_table_with_cost

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_detect_table_with_cost(unknown):

clear_detect_table_with_cost(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

table_compression_level

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_table_compression_level(unknown):

clear_table_compression_level(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

expand_alldiff_constraints

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_expand_alldiff_constraints(unknown):

clear_expand_alldiff_constraints(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_alldiff_domain_size

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_max_alldiff_domain_size(unknown):

clear_max_alldiff_domain_size(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

expand_reservoir_constraints

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_expand_reservoir_constraints(unknown):

clear_expand_reservoir_constraints(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_domain_size_for_linear2_expansion

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_max_domain_size_for_linear2_expansion(unknown):

clear_max_domain_size_for_linear2_expansion(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

expand_reservoir_using_circuit

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_expand_reservoir_using_circuit(unknown):

clear_expand_reservoir_using_circuit(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

encode_cumulative_as_reservoir

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_encode_cumulative_as_reservoir(unknown):

clear_encode_cumulative_as_reservoir(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_lin_max_size_for_expansion

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_max_lin_max_size_for_expansion(unknown):

clear_max_lin_max_size_for_expansion(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

disable_constraint_expansion

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_disable_constraint_expansion(unknown):

clear_disable_constraint_expansion(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

encode_complex_linear_constraint_with_integer

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_encode_complex_linear_constraint_with_integer(unknown):

clear_encode_complex_linear_constraint_with_integer(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

merge_no_overlap_work_limit

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_merge_no_overlap_work_limit(unknown):

clear_merge_no_overlap_work_limit(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

merge_at_most_one_work_limit

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_merge_at_most_one_work_limit(unknown):

clear_merge_at_most_one_work_limit(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

presolve_substitution_level

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_presolve_substitution_level(unknown):

clear_presolve_substitution_level(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

presolve_extract_integer_enforcement

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_presolve_extract_integer_enforcement(unknown):

clear_presolve_extract_integer_enforcement(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

presolve_inclusion_work_limit

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_presolve_inclusion_work_limit(unknown):

clear_presolve_inclusion_work_limit(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

def clear_ignore_names(unknown):

clear_ignore_names(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

infer_all_diffs

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_infer_all_diffs(unknown):

clear_infer_all_diffs(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

find_big_linear_overlap

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_find_big_linear_overlap(unknown):

clear_find_big_linear_overlap(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

find_clauses_that_are_exactly_one

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_find_clauses_that_are_exactly_one(unknown):

clear_find_clauses_that_are_exactly_one(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_sat_inprocessing

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_sat_inprocessing(unknown):

clear_use_sat_inprocessing(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

inprocessing_dtime_ratio

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_inprocessing_dtime_ratio(unknown):

clear_inprocessing_dtime_ratio(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

inprocessing_probing_dtime

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_inprocessing_probing_dtime(unknown):

clear_inprocessing_probing_dtime(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

inprocessing_minimization_dtime

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_inprocessing_minimization_dtime(unknown):

clear_inprocessing_minimization_dtime(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

inprocessing_minimization_use_conflict_analysis

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_inprocessing_minimization_use_conflict_analysis(unknown):

clear_inprocessing_minimization_use_conflict_analysis(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

inprocessing_minimization_use_all_orderings

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_inprocessing_minimization_use_all_orderings(unknown):

clear_inprocessing_minimization_use_all_orderings(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

inprocessing_use_congruence_closure

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_inprocessing_use_congruence_closure(unknown):

clear_inprocessing_use_congruence_closure(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

inprocessing_use_sat_sweeping

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_inprocessing_use_sat_sweeping(unknown):

clear_inprocessing_use_sat_sweeping(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

def clear_num_workers(unknown):

clear_num_workers(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

num_search_workers

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_num_search_workers(unknown):

clear_num_search_workers(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

num_full_subsolvers

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_num_full_subsolvers(unknown):

clear_num_full_subsolvers(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

subsolvers

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> google::protobuf::RepeatedPtrField, std::allocator > >

extra_subsolvers

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> google::protobuf::RepeatedPtrField, std::allocator > >

ignore_subsolvers

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> google::protobuf::RepeatedPtrField, std::allocator > >

filter_subsolvers

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> google::protobuf::RepeatedPtrField, std::allocator > >

subsolver_params

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> google::protobuf::RepeatedPtrField

interleave_batch_size

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_interleave_batch_size(unknown):

clear_interleave_batch_size(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

share_objective_bounds

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_share_objective_bounds(unknown):

clear_share_objective_bounds(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

share_level_zero_bounds

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_share_level_zero_bounds(unknown):

clear_share_level_zero_bounds(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

share_linear2_bounds

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_share_linear2_bounds(unknown):

clear_share_linear2_bounds(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

share_binary_clauses

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_share_binary_clauses(unknown):

clear_share_binary_clauses(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

share_glue_clauses

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_share_glue_clauses(unknown):

clear_share_glue_clauses(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

minimize_shared_clauses

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_minimize_shared_clauses(unknown):

clear_minimize_shared_clauses(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

share_glue_clauses_dtime

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_share_glue_clauses_dtime(unknown):

clear_share_glue_clauses_dtime(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

check_lrat_proof

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_check_lrat_proof(unknown):

clear_check_lrat_proof(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

check_merged_lrat_proof

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_check_merged_lrat_proof(unknown):

clear_check_merged_lrat_proof(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

output_lrat_proof

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_output_lrat_proof(unknown):

clear_output_lrat_proof(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

check_drat_proof

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_check_drat_proof(unknown):

clear_check_drat_proof(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

output_drat_proof

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_output_drat_proof(unknown):

clear_output_drat_proof(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_drat_time_in_seconds

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_max_drat_time_in_seconds(unknown):

clear_max_drat_time_in_seconds(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

debug_postsolve_with_full_solver

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_debug_postsolve_with_full_solver(unknown):

clear_debug_postsolve_with_full_solver(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

debug_max_num_presolve_operations

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_debug_max_num_presolve_operations(unknown):

clear_debug_max_num_presolve_operations(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

debug_crash_on_bad_hint

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_debug_crash_on_bad_hint(unknown):

clear_debug_crash_on_bad_hint(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

debug_crash_if_presolve_breaks_hint

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_debug_crash_if_presolve_breaks_hint(unknown):

clear_debug_crash_if_presolve_breaks_hint(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

debug_crash_if_lrat_check_fails

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_debug_crash_if_lrat_check_fails(unknown):

clear_debug_crash_if_lrat_check_fails(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_optimization_hints

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_optimization_hints(unknown):

clear_use_optimization_hints(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

core_minimization_level

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_core_minimization_level(unknown):

clear_core_minimization_level(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

find_multiple_cores

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_find_multiple_cores(unknown):

clear_find_multiple_cores(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

cover_optimization

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_cover_optimization(unknown):

clear_cover_optimization(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_sat_assumption_order

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> operations_research::sat::SatParameters_MaxSatAssumptionOrder

def clear_max_sat_assumption_order(unknown):

clear_max_sat_assumption_order(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_sat_reverse_assumption_order

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_max_sat_reverse_assumption_order(unknown):

clear_max_sat_reverse_assumption_order(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_sat_stratification

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> operations_research::sat::SatParameters_MaxSatStratificationAlgorithm

def clear_max_sat_stratification(unknown):

clear_max_sat_stratification(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

propagation_loop_detection_factor

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_propagation_loop_detection_factor(unknown):

clear_propagation_loop_detection_factor(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_precedences_in_disjunctive_constraint

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_precedences_in_disjunctive_constraint(unknown):

clear_use_precedences_in_disjunctive_constraint(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

transitive_precedences_work_limit

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_transitive_precedences_work_limit(unknown):

clear_transitive_precedences_work_limit(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_size_to_create_precedence_literals_in_disjunctive

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_max_size_to_create_precedence_literals_in_disjunctive(unknown):

clear_max_size_to_create_precedence_literals_in_disjunctive(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_strong_propagation_in_disjunctive

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_strong_propagation_in_disjunctive(unknown):

clear_use_strong_propagation_in_disjunctive(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_dynamic_precedence_in_disjunctive

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_dynamic_precedence_in_disjunctive(unknown):

clear_use_dynamic_precedence_in_disjunctive(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_dynamic_precedence_in_cumulative

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_dynamic_precedence_in_cumulative(unknown):

clear_use_dynamic_precedence_in_cumulative(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_overload_checker_in_cumulative

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_overload_checker_in_cumulative(unknown):

clear_use_overload_checker_in_cumulative(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_conservative_scale_overload_checker

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_conservative_scale_overload_checker(unknown):

clear_use_conservative_scale_overload_checker(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_timetable_edge_finding_in_cumulative

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_timetable_edge_finding_in_cumulative(unknown):

clear_use_timetable_edge_finding_in_cumulative(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_num_intervals_for_timetable_edge_finding

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_max_num_intervals_for_timetable_edge_finding(unknown):

clear_max_num_intervals_for_timetable_edge_finding(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_hard_precedences_in_cumulative

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_hard_precedences_in_cumulative(unknown):

clear_use_hard_precedences_in_cumulative(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

exploit_all_precedences

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_exploit_all_precedences(unknown):

clear_exploit_all_precedences(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_disjunctive_constraint_in_cumulative

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_disjunctive_constraint_in_cumulative(unknown):

clear_use_disjunctive_constraint_in_cumulative(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

no_overlap_2d_boolean_relations_limit

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_no_overlap_2d_boolean_relations_limit(unknown):

clear_no_overlap_2d_boolean_relations_limit(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_timetabling_in_no_overlap_2d

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_timetabling_in_no_overlap_2d(unknown):

clear_use_timetabling_in_no_overlap_2d(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_energetic_reasoning_in_no_overlap_2d

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_energetic_reasoning_in_no_overlap_2d(unknown):

clear_use_energetic_reasoning_in_no_overlap_2d(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_area_energetic_reasoning_in_no_overlap_2d

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_area_energetic_reasoning_in_no_overlap_2d(unknown):

clear_use_area_energetic_reasoning_in_no_overlap_2d(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_try_edge_reasoning_in_no_overlap_2d

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_try_edge_reasoning_in_no_overlap_2d(unknown):

clear_use_try_edge_reasoning_in_no_overlap_2d(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_pairs_pairwise_reasoning_in_no_overlap_2d

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_max_pairs_pairwise_reasoning_in_no_overlap_2d(unknown):

clear_max_pairs_pairwise_reasoning_in_no_overlap_2d(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

maximum_regions_to_split_in_disconnected_no_overlap_2d

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_maximum_regions_to_split_in_disconnected_no_overlap_2d(unknown):

clear_maximum_regions_to_split_in_disconnected_no_overlap_2d(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_linear3_for_no_overlap_2d_precedences

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_linear3_for_no_overlap_2d_precedences(unknown):

clear_use_linear3_for_no_overlap_2d_precedences(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_dual_scheduling_heuristics

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_dual_scheduling_heuristics(unknown):

clear_use_dual_scheduling_heuristics(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_all_different_for_circuit

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_all_different_for_circuit(unknown):

clear_use_all_different_for_circuit(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

routing_cut_subset_size_for_binary_relation_bound

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_routing_cut_subset_size_for_binary_relation_bound(unknown):

clear_routing_cut_subset_size_for_binary_relation_bound(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

routing_cut_subset_size_for_tight_binary_relation_bound

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_routing_cut_subset_size_for_tight_binary_relation_bound(unknown):

clear_routing_cut_subset_size_for_tight_binary_relation_bound(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

routing_cut_subset_size_for_exact_binary_relation_bound

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_routing_cut_subset_size_for_exact_binary_relation_bound(unknown):

clear_routing_cut_subset_size_for_exact_binary_relation_bound(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

routing_cut_subset_size_for_shortest_paths_bound

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_routing_cut_subset_size_for_shortest_paths_bound(unknown):

clear_routing_cut_subset_size_for_shortest_paths_bound(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

routing_cut_dp_effort

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_routing_cut_dp_effort(unknown):

clear_routing_cut_dp_effort(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

routing_cut_max_infeasible_path_length

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_routing_cut_max_infeasible_path_length(unknown):

clear_routing_cut_max_infeasible_path_length(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

search_branching

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> operations_research::sat::SatParameters_SearchBranching

def clear_search_branching(unknown):

clear_search_branching(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

hint_conflict_limit

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_hint_conflict_limit(unknown):

clear_hint_conflict_limit(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

def clear_repair_hint(unknown):

clear_repair_hint(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

fix_variables_to_their_hinted_value

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_fix_variables_to_their_hinted_value(unknown):

clear_fix_variables_to_their_hinted_value(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_extended_probing

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_extended_probing(unknown):

clear_use_extended_probing(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

probing_num_combinations_limit

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_probing_num_combinations_limit(unknown):

clear_probing_num_combinations_limit(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

shaving_search_deterministic_time

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_shaving_search_deterministic_time(unknown):

clear_shaving_search_deterministic_time(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

shaving_search_threshold

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_shaving_search_threshold(unknown):

clear_shaving_search_threshold(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

variables_shaving_level

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_variables_shaving_level(unknown):

clear_variables_shaving_level(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

pseudo_cost_reliability_threshold

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_pseudo_cost_reliability_threshold(unknown):

clear_pseudo_cost_reliability_threshold(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

optimize_with_core

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_optimize_with_core(unknown):

clear_optimize_with_core(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

binary_search_num_conflicts

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_binary_search_num_conflicts(unknown):

clear_binary_search_num_conflicts(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

optimize_with_max_hs

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_optimize_with_max_hs(unknown):

clear_optimize_with_max_hs(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_feasibility_jump

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_feasibility_jump(unknown):

clear_use_feasibility_jump(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

def clear_use_ls_only(unknown):

clear_use_ls_only(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

feasibility_jump_decay

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_feasibility_jump_decay(unknown):

clear_feasibility_jump_decay(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

feasibility_jump_linearization_level

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_feasibility_jump_linearization_level(unknown):

clear_feasibility_jump_linearization_level(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

feasibility_jump_restart_factor

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_feasibility_jump_restart_factor(unknown):

clear_feasibility_jump_restart_factor(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

feasibility_jump_batch_dtime

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_feasibility_jump_batch_dtime(unknown):

clear_feasibility_jump_batch_dtime(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

feasibility_jump_var_randomization_probability

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_feasibility_jump_var_randomization_probability(unknown):

clear_feasibility_jump_var_randomization_probability(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

feasibility_jump_var_perburbation_range_ratio

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_feasibility_jump_var_perburbation_range_ratio(unknown):

clear_feasibility_jump_var_perburbation_range_ratio(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

feasibility_jump_enable_restarts

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_feasibility_jump_enable_restarts(unknown):

clear_feasibility_jump_enable_restarts(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

feasibility_jump_max_expanded_constraint_size

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_feasibility_jump_max_expanded_constraint_size(unknown):

clear_feasibility_jump_max_expanded_constraint_size(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

num_violation_ls

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_num_violation_ls(unknown):

clear_num_violation_ls(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

violation_ls_perturbation_period

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_violation_ls_perturbation_period(unknown):

clear_violation_ls_perturbation_period(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

violation_ls_compound_move_probability

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_violation_ls_compound_move_probability(unknown):

clear_violation_ls_compound_move_probability(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

shared_tree_num_workers

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_shared_tree_num_workers(unknown):

clear_shared_tree_num_workers(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

shared_tree_worker_min_restarts_per_subtree

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_shared_tree_worker_min_restarts_per_subtree(unknown):

clear_shared_tree_worker_min_restarts_per_subtree(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

shared_tree_worker_enable_trail_sharing

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_shared_tree_worker_enable_trail_sharing(unknown):

clear_shared_tree_worker_enable_trail_sharing(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

shared_tree_worker_enable_phase_sharing

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_shared_tree_worker_enable_phase_sharing(unknown):

clear_shared_tree_worker_enable_phase_sharing(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

shared_tree_open_leaves_per_worker

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_shared_tree_open_leaves_per_worker(unknown):

clear_shared_tree_open_leaves_per_worker(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

shared_tree_max_nodes_per_worker

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_shared_tree_max_nodes_per_worker(unknown):

clear_shared_tree_max_nodes_per_worker(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

shared_tree_split_strategy

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> operations_research::sat::SatParameters_SharedTreeSplitStrategy

def clear_shared_tree_split_strategy(unknown):

clear_shared_tree_split_strategy(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

shared_tree_balance_tolerance

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_shared_tree_balance_tolerance(unknown):

clear_shared_tree_balance_tolerance(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

shared_tree_split_min_dtime

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_shared_tree_split_min_dtime(unknown):

clear_shared_tree_split_min_dtime(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

enumerate_all_solutions

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_enumerate_all_solutions(unknown):

clear_enumerate_all_solutions(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

keep_all_feasible_solutions_in_presolve

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_keep_all_feasible_solutions_in_presolve(unknown):

clear_keep_all_feasible_solutions_in_presolve(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

fill_tightened_domains_in_response

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_fill_tightened_domains_in_response(unknown):

clear_fill_tightened_domains_in_response(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

fill_additional_solutions_in_response

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_fill_additional_solutions_in_response(unknown):

clear_fill_additional_solutions_in_response(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

instantiate_all_variables

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_instantiate_all_variables(unknown):

clear_instantiate_all_variables(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

auto_detect_greater_than_at_least_one_of

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_auto_detect_greater_than_at_least_one_of(unknown):

clear_auto_detect_greater_than_at_least_one_of(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

stop_after_first_solution

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_stop_after_first_solution(unknown):

clear_stop_after_first_solution(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

stop_after_presolve

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_stop_after_presolve(unknown):

clear_stop_after_presolve(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

stop_after_root_propagation

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_stop_after_root_propagation(unknown):

clear_stop_after_root_propagation(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

lns_initial_difficulty

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_lns_initial_difficulty(unknown):

clear_lns_initial_difficulty(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

lns_initial_deterministic_limit

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_lns_initial_deterministic_limit(unknown):

clear_lns_initial_deterministic_limit(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

def clear_use_lns(unknown):

clear_use_lns(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

def clear_use_lns_only(unknown):

clear_use_lns_only(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

solution_pool_size

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_solution_pool_size(unknown):

clear_solution_pool_size(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

solution_pool_diversity_limit

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_solution_pool_diversity_limit(unknown):

clear_solution_pool_diversity_limit(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

alternative_pool_size

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_alternative_pool_size(unknown):

clear_alternative_pool_size(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

def clear_use_rins_lns(unknown):

clear_use_rins_lns(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_feasibility_pump

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_feasibility_pump(unknown):

clear_use_feasibility_pump(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_lb_relax_lns

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_lb_relax_lns(unknown):

clear_use_lb_relax_lns(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

lb_relax_num_workers_threshold

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_lb_relax_num_workers_threshold(unknown):

clear_lb_relax_num_workers_threshold(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

fp_rounding

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> operations_research::sat::SatParameters_FPRoundingMethod

def clear_fp_rounding(unknown):

clear_fp_rounding(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

diversify_lns_params

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_diversify_lns_params(unknown):

clear_diversify_lns_params(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

search_random_variable_pool_size

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_search_random_variable_pool_size(unknown):

clear_search_random_variable_pool_size(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

push_all_tasks_toward_start

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_push_all_tasks_toward_start(unknown):

clear_push_all_tasks_toward_start(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_optional_variables

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_optional_variables(unknown):

clear_use_optional_variables(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_exact_lp_reason

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_exact_lp_reason(unknown):

clear_use_exact_lp_reason(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_combined_no_overlap

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_combined_no_overlap(unknown):

clear_use_combined_no_overlap(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

at_most_one_max_expansion_size

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_at_most_one_max_expansion_size(unknown):

clear_at_most_one_max_expansion_size(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

catch_sigint_signal

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_catch_sigint_signal(unknown):

clear_catch_sigint_signal(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_implied_bounds

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_implied_bounds(unknown):

clear_use_implied_bounds(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

polish_lp_solution

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_polish_lp_solution(unknown):

clear_polish_lp_solution(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

lp_primal_tolerance

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_lp_primal_tolerance(unknown):

clear_lp_primal_tolerance(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

lp_dual_tolerance

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_lp_dual_tolerance(unknown):

clear_lp_dual_tolerance(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

convert_intervals

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_convert_intervals(unknown):

clear_convert_intervals(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

symmetry_level

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_symmetry_level(unknown):

clear_symmetry_level(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_symmetry_in_lp

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_symmetry_in_lp(unknown):

clear_use_symmetry_in_lp(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

keep_symmetry_in_presolve

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_keep_symmetry_in_presolve(unknown):

clear_keep_symmetry_in_presolve(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

symmetry_detection_deterministic_time_limit

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_symmetry_detection_deterministic_time_limit(unknown):

clear_symmetry_detection_deterministic_time_limit(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

new_linear_propagation

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_new_linear_propagation(unknown):

clear_new_linear_propagation(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

linear_split_size

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_linear_split_size(unknown):

clear_linear_split_size(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

linearization_level

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_linearization_level(unknown):

clear_linearization_level(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

boolean_encoding_level

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_boolean_encoding_level(unknown):

clear_boolean_encoding_level(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_domain_size_when_encoding_eq_neq_constraints

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_max_domain_size_when_encoding_eq_neq_constraints(unknown):

clear_max_domain_size_when_encoding_eq_neq_constraints(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

def clear_max_num_cuts(unknown):

clear_max_num_cuts(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

def clear_cut_level(unknown):

clear_cut_level(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

only_add_cuts_at_level_zero

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_only_add_cuts_at_level_zero(unknown):

clear_only_add_cuts_at_level_zero(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

add_objective_cut

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_add_objective_cut(unknown):

clear_add_objective_cut(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

def clear_add_cg_cuts(unknown):

clear_add_cg_cuts(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

def clear_add_mir_cuts(unknown):

clear_add_mir_cuts(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

add_zero_half_cuts

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_add_zero_half_cuts(unknown):

clear_add_zero_half_cuts(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

add_clique_cuts

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_add_clique_cuts(unknown):

clear_add_clique_cuts(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

def clear_add_rlt_cuts(unknown):

clear_add_rlt_cuts(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_all_diff_cut_size

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_max_all_diff_cut_size(unknown):

clear_max_all_diff_cut_size(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

add_lin_max_cuts

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_add_lin_max_cuts(unknown):

clear_add_lin_max_cuts(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_integer_rounding_scaling

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_max_integer_rounding_scaling(unknown):

clear_max_integer_rounding_scaling(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

add_lp_constraints_lazily

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_add_lp_constraints_lazily(unknown):

clear_add_lp_constraints_lazily(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

root_lp_iterations

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_root_lp_iterations(unknown):

clear_root_lp_iterations(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

min_orthogonality_for_lp_constraints

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_min_orthogonality_for_lp_constraints(unknown):

clear_min_orthogonality_for_lp_constraints(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_cut_rounds_at_level_zero

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_max_cut_rounds_at_level_zero(unknown):

clear_max_cut_rounds_at_level_zero(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

max_consecutive_inactive_count

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_max_consecutive_inactive_count(unknown):

clear_max_consecutive_inactive_count(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

cut_max_active_count_value

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_cut_max_active_count_value(unknown):

clear_cut_max_active_count_value(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

cut_active_count_decay

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_cut_active_count_decay(unknown):

clear_cut_active_count_decay(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

cut_cleanup_target

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_cut_cleanup_target(unknown):

clear_cut_cleanup_target(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

new_constraints_batch_size

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_new_constraints_batch_size(unknown):

clear_new_constraints_batch_size(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

exploit_integer_lp_solution

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_exploit_integer_lp_solution(unknown):

clear_exploit_integer_lp_solution(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

exploit_all_lp_solution

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_exploit_all_lp_solution(unknown):

clear_exploit_all_lp_solution(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

exploit_best_solution

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_exploit_best_solution(unknown):

clear_exploit_best_solution(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

exploit_relaxation_solution

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_exploit_relaxation_solution(unknown):

clear_exploit_relaxation_solution(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

exploit_objective

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_exploit_objective(unknown):

clear_exploit_objective(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

detect_linearized_product

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_detect_linearized_product(unknown):

clear_detect_linearized_product(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

use_new_integer_conflict_resolution

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_use_new_integer_conflict_resolution(unknown):

clear_use_new_integer_conflict_resolution(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

create_1uip_boolean_during_icr

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_create_1uip_boolean_during_icr(unknown):

clear_create_1uip_boolean_during_icr(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

mip_max_bound

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_mip_max_bound(unknown):

clear_mip_max_bound(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

mip_var_scaling

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_mip_var_scaling(unknown):

clear_mip_var_scaling(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

mip_scale_large_domain

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_mip_scale_large_domain(unknown):

clear_mip_scale_large_domain(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

mip_automatically_scale_variables

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_mip_automatically_scale_variables(unknown):

clear_mip_automatically_scale_variables(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

only_solve_ip

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_only_solve_ip(unknown):

clear_only_solve_ip(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

mip_wanted_precision

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_mip_wanted_precision(unknown):

clear_mip_wanted_precision(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

mip_max_activity_exponent

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_mip_max_activity_exponent(unknown):

clear_mip_max_activity_exponent(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

mip_check_precision

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_mip_check_precision(unknown):

clear_mip_check_precision(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

mip_compute_true_objective_bound

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_mip_compute_true_objective_bound(unknown):

clear_mip_compute_true_objective_bound(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

mip_max_valid_magnitude

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_mip_max_valid_magnitude(unknown):

clear_mip_max_valid_magnitude(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

mip_treat_high_magnitude_bounds_as_infinity

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> bool

def clear_mip_treat_high_magnitude_bounds_as_infinity(unknown):

clear_mip_treat_high_magnitude_bounds_as_infinity(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

mip_drop_tolerance

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> float

def clear_mip_drop_tolerance(unknown):

clear_mip_drop_tolerance(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

mip_presolve_level

(arg0: ortools.sat.python.cp_model_helper.SatParameters) -> int

def clear_mip_presolve_level(unknown):

clear_mip_presolve_level(self: ortools.sat.python.cp_model_helper.SatParameters) -> None

STRATIFICATION_NONE = <MaxSatStratificationAlgorithm.STRATIFICATION_NONE: 0>
STRATIFICATION_DESCENT = <MaxSatStratificationAlgorithm.STRATIFICATION_DESCENT: 1>
STRATIFICATION_ASCENT = <MaxSatStratificationAlgorithm.STRATIFICATION_ASCENT: 2>
POLARITY_TRUE = <Polarity.POLARITY_TRUE: 0>
POLARITY_FALSE = <Polarity.POLARITY_FALSE: 1>
POLARITY_RANDOM = <Polarity.POLARITY_RANDOM: 2>
IN_ORDER = <VariableOrder.IN_ORDER: 0>
IN_REVERSE_ORDER = <VariableOrder.IN_REVERSE_ORDER: 1>
IN_RANDOM_ORDER = <VariableOrder.IN_RANDOM_ORDER: 2>
NONE = <ConflictMinimizationAlgorithm.NONE: 0>
SIMPLE = <ConflictMinimizationAlgorithm.SIMPLE: 1>
RECURSIVE = <ConflictMinimizationAlgorithm.RECURSIVE: 2>
CLAUSE_ACTIVITY = <ClauseOrdering.CLAUSE_ACTIVITY: 0>
CLAUSE_LBD = <ClauseOrdering.CLAUSE_LBD: 1>
DEFAULT_ASSUMPTION_ORDER = <MaxSatAssumptionOrder.DEFAULT_ASSUMPTION_ORDER: 0>
ORDER_ASSUMPTION_BY_DEPTH = <MaxSatAssumptionOrder.ORDER_ASSUMPTION_BY_DEPTH: 1>
ORDER_ASSUMPTION_BY_WEIGHT = <MaxSatAssumptionOrder.ORDER_ASSUMPTION_BY_WEIGHT: 2>
NO_BINARY_MINIMIZATION = <BinaryMinizationAlgorithm.NO_BINARY_MINIMIZATION: 0>
BINARY_MINIMIZATION_FROM_UIP = <BinaryMinizationAlgorithm.BINARY_MINIMIZATION_FROM_UIP: 1>
BINARY_MINIMIZATION_FROM_UIP_AND_DECISIONS = <BinaryMinizationAlgorithm.BINARY_MINIMIZATION_FROM_UIP_AND_DECISIONS: 5>
SPLIT_STRATEGY_AUTO = <SharedTreeSplitStrategy.SPLIT_STRATEGY_AUTO: 0>
SPLIT_STRATEGY_DISCREPANCY = <SharedTreeSplitStrategy.SPLIT_STRATEGY_DISCREPANCY: 1>
SPLIT_STRATEGY_OBJECTIVE_LB = <SharedTreeSplitStrategy.SPLIT_STRATEGY_OBJECTIVE_LB: 2>
SPLIT_STRATEGY_BALANCED_TREE = <SharedTreeSplitStrategy.SPLIT_STRATEGY_BALANCED_TREE: 3>
SPLIT_STRATEGY_FIRST_PROPOSAL = <SharedTreeSplitStrategy.SPLIT_STRATEGY_FIRST_PROPOSAL: 4>
NEAREST_INTEGER = <FPRoundingMethod.NEAREST_INTEGER: 0>
LOCK_BASED = <FPRoundingMethod.LOCK_BASED: 1>
ACTIVE_LOCK_BASED = <FPRoundingMethod.ACTIVE_LOCK_BASED: 3>
PROPAGATION_ASSISTED = <FPRoundingMethod.PROPAGATION_ASSISTED: 2>
class SatParameters.SearchBranching(pybind11_builtins.pybind11_object):

Members:

AUTOMATIC_SEARCH

FIXED_SEARCH

PORTFOLIO_SEARCH

LP_SEARCH

PSEUDO_COST_SEARCH

PORTFOLIO_WITH_QUICK_RESTART_SEARCH

HINT_SEARCH

PARTIAL_FIXED_SEARCH

RANDOMIZED_SEARCH

SatParameters.SearchBranching()

__init__(self: ortools.sat.python.cp_model_helper.SatParameters.SearchBranching, value: int) -> None

name

name(self: object) -> str

class SatParameters.MaxSatStratificationAlgorithm(pybind11_builtins.pybind11_object):

Members:

STRATIFICATION_NONE

STRATIFICATION_DESCENT

STRATIFICATION_ASCENT

SatParameters.MaxSatStratificationAlgorithm()

__init__(self: ortools.sat.python.cp_model_helper.SatParameters.MaxSatStratificationAlgorithm, value: int) -> None

name

name(self: object) -> str

STRATIFICATION_NONE = <MaxSatStratificationAlgorithm.STRATIFICATION_NONE: 0>
STRATIFICATION_DESCENT = <MaxSatStratificationAlgorithm.STRATIFICATION_DESCENT: 1>
STRATIFICATION_ASCENT = <MaxSatStratificationAlgorithm.STRATIFICATION_ASCENT: 2>
class SatParameters.Polarity(pybind11_builtins.pybind11_object):

Members:

POLARITY_TRUE

POLARITY_FALSE

POLARITY_RANDOM

SatParameters.Polarity()

__init__(self: ortools.sat.python.cp_model_helper.SatParameters.Polarity, value: int) -> None

name

name(self: object) -> str

POLARITY_TRUE = <Polarity.POLARITY_TRUE: 0>
POLARITY_FALSE = <Polarity.POLARITY_FALSE: 1>
POLARITY_RANDOM = <Polarity.POLARITY_RANDOM: 2>
class SatParameters.VariableOrder(pybind11_builtins.pybind11_object):

Members:

IN_ORDER

IN_REVERSE_ORDER

IN_RANDOM_ORDER

SatParameters.VariableOrder()

__init__(self: ortools.sat.python.cp_model_helper.SatParameters.VariableOrder, value: int) -> None

name

name(self: object) -> str

IN_ORDER = <VariableOrder.IN_ORDER: 0>
IN_REVERSE_ORDER = <VariableOrder.IN_REVERSE_ORDER: 1>
IN_RANDOM_ORDER = <VariableOrder.IN_RANDOM_ORDER: 2>
class SatParameters.ConflictMinimizationAlgorithm(pybind11_builtins.pybind11_object):

Members:

NONE

SIMPLE

RECURSIVE

SatParameters.ConflictMinimizationAlgorithm()

__init__(self: ortools.sat.python.cp_model_helper.SatParameters.ConflictMinimizationAlgorithm, value: int) -> None

name

name(self: object) -> str

NONE = <ConflictMinimizationAlgorithm.NONE: 0>
SIMPLE = <ConflictMinimizationAlgorithm.SIMPLE: 1>
RECURSIVE = <ConflictMinimizationAlgorithm.RECURSIVE: 2>
class SatParameters.ClauseOrdering(pybind11_builtins.pybind11_object):

Members:

CLAUSE_ACTIVITY

CLAUSE_LBD

SatParameters.ClauseOrdering()

__init__(self: ortools.sat.python.cp_model_helper.SatParameters.ClauseOrdering, value: int) -> None

name

name(self: object) -> str

CLAUSE_ACTIVITY = <ClauseOrdering.CLAUSE_ACTIVITY: 0>
CLAUSE_LBD = <ClauseOrdering.CLAUSE_LBD: 1>
class SatParameters.MaxSatAssumptionOrder(pybind11_builtins.pybind11_object):

Members:

DEFAULT_ASSUMPTION_ORDER

ORDER_ASSUMPTION_BY_DEPTH

ORDER_ASSUMPTION_BY_WEIGHT

SatParameters.MaxSatAssumptionOrder()

__init__(self: ortools.sat.python.cp_model_helper.SatParameters.MaxSatAssumptionOrder, value: int) -> None

name

name(self: object) -> str

DEFAULT_ASSUMPTION_ORDER = <MaxSatAssumptionOrder.DEFAULT_ASSUMPTION_ORDER: 0>
ORDER_ASSUMPTION_BY_DEPTH = <MaxSatAssumptionOrder.ORDER_ASSUMPTION_BY_DEPTH: 1>
ORDER_ASSUMPTION_BY_WEIGHT = <MaxSatAssumptionOrder.ORDER_ASSUMPTION_BY_WEIGHT: 2>
class SatParameters.BinaryMinizationAlgorithm(pybind11_builtins.pybind11_object):

Members:

NO_BINARY_MINIMIZATION

BINARY_MINIMIZATION_FROM_UIP

BINARY_MINIMIZATION_FROM_UIP_AND_DECISIONS

SatParameters.BinaryMinizationAlgorithm()

__init__(self: ortools.sat.python.cp_model_helper.SatParameters.BinaryMinizationAlgorithm, value: int) -> None

name

name(self: object) -> str

NO_BINARY_MINIMIZATION = <BinaryMinizationAlgorithm.NO_BINARY_MINIMIZATION: 0>
BINARY_MINIMIZATION_FROM_UIP = <BinaryMinizationAlgorithm.BINARY_MINIMIZATION_FROM_UIP: 1>
BINARY_MINIMIZATION_FROM_UIP_AND_DECISIONS = <BinaryMinizationAlgorithm.BINARY_MINIMIZATION_FROM_UIP_AND_DECISIONS: 5>
class SatParameters.SharedTreeSplitStrategy(pybind11_builtins.pybind11_object):

Members:

SPLIT_STRATEGY_AUTO

SPLIT_STRATEGY_DISCREPANCY

SPLIT_STRATEGY_OBJECTIVE_LB

SPLIT_STRATEGY_BALANCED_TREE

SPLIT_STRATEGY_FIRST_PROPOSAL

SatParameters.SharedTreeSplitStrategy()

__init__(self: ortools.sat.python.cp_model_helper.SatParameters.SharedTreeSplitStrategy, value: int) -> None

name

name(self: object) -> str

SPLIT_STRATEGY_AUTO = <SharedTreeSplitStrategy.SPLIT_STRATEGY_AUTO: 0>
SPLIT_STRATEGY_DISCREPANCY = <SharedTreeSplitStrategy.SPLIT_STRATEGY_DISCREPANCY: 1>
SPLIT_STRATEGY_OBJECTIVE_LB = <SharedTreeSplitStrategy.SPLIT_STRATEGY_OBJECTIVE_LB: 2>
SPLIT_STRATEGY_BALANCED_TREE = <SharedTreeSplitStrategy.SPLIT_STRATEGY_BALANCED_TREE: 3>
SPLIT_STRATEGY_FIRST_PROPOSAL = <SharedTreeSplitStrategy.SPLIT_STRATEGY_FIRST_PROPOSAL: 4>
class SatParameters.FPRoundingMethod(pybind11_builtins.pybind11_object):

Members:

NEAREST_INTEGER

LOCK_BASED

ACTIVE_LOCK_BASED

PROPAGATION_ASSISTED

SatParameters.FPRoundingMethod()

__init__(self: ortools.sat.python.cp_model_helper.SatParameters.FPRoundingMethod, value: int) -> None

name

name(self: object) -> str

NEAREST_INTEGER = <FPRoundingMethod.NEAREST_INTEGER: 0>
LOCK_BASED = <FPRoundingMethod.LOCK_BASED: 1>
ACTIVE_LOCK_BASED = <FPRoundingMethod.ACTIVE_LOCK_BASED: 3>
PROPAGATION_ASSISTED = <FPRoundingMethod.PROPAGATION_ASSISTED: 2>
class CpSolverResponse(pybind11_builtins.pybind11_object):
CpSolverResponse()

__init__(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.CpSolverResponse, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.CpSolverResponse, arg0: str) -> bool

status

(arg0: ortools.sat.python.cp_model_helper.CpSolverResponse) -> operations_research::sat::CpSolverStatus

def clear_status(unknown):

clear_status(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

solution

(arg0: ortools.sat.python.cp_model_helper.CpSolverResponse) -> google::protobuf::RepeatedField

objective_value

(arg0: ortools.sat.python.cp_model_helper.CpSolverResponse) -> float

def clear_objective_value(unknown):

clear_objective_value(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

best_objective_bound

(arg0: ortools.sat.python.cp_model_helper.CpSolverResponse) -> float

def clear_best_objective_bound(unknown):

clear_best_objective_bound(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

additional_solutions

(arg0: ortools.sat.python.cp_model_helper.CpSolverResponse) -> google::protobuf::RepeatedPtrField

tightened_variables

(arg0: ortools.sat.python.cp_model_helper.CpSolverResponse) -> google::protobuf::RepeatedPtrField

sufficient_assumptions_for_infeasibility

(arg0: ortools.sat.python.cp_model_helper.CpSolverResponse) -> google::protobuf::RepeatedField

integer_objective

(arg0: ortools.sat.python.cp_model_helper.CpSolverResponse) -> operations_research::sat::CpObjectiveProto

def clear_integer_objective(unknown):

clear_integer_objective(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

def has_integer_objective(unknown):

has_integer_objective(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> bool

inner_objective_lower_bound

(arg0: ortools.sat.python.cp_model_helper.CpSolverResponse) -> int

def clear_inner_objective_lower_bound(unknown):

clear_inner_objective_lower_bound(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

def clear_num_integers(unknown):

clear_num_integers(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

def clear_num_booleans(unknown):

clear_num_booleans(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

num_fixed_booleans

(arg0: ortools.sat.python.cp_model_helper.CpSolverResponse) -> int

def clear_num_fixed_booleans(unknown):

clear_num_fixed_booleans(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

def clear_num_conflicts(unknown):

clear_num_conflicts(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

def clear_num_branches(unknown):

clear_num_branches(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

num_binary_propagations

(arg0: ortools.sat.python.cp_model_helper.CpSolverResponse) -> int

def clear_num_binary_propagations(unknown):

clear_num_binary_propagations(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

num_integer_propagations

(arg0: ortools.sat.python.cp_model_helper.CpSolverResponse) -> int

def clear_num_integer_propagations(unknown):

clear_num_integer_propagations(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

def clear_num_restarts(unknown):

clear_num_restarts(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

num_lp_iterations

(arg0: ortools.sat.python.cp_model_helper.CpSolverResponse) -> int

def clear_num_lp_iterations(unknown):

clear_num_lp_iterations(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

def clear_wall_time(unknown):

clear_wall_time(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

def clear_user_time(unknown):

clear_user_time(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

deterministic_time

(arg0: ortools.sat.python.cp_model_helper.CpSolverResponse) -> float

def clear_deterministic_time(unknown):

clear_deterministic_time(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

def clear_gap_integral(unknown):

clear_gap_integral(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

def clear_solution_info(unknown):

clear_solution_info(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

def clear_solve_log(unknown):

clear_solve_log(self: ortools.sat.python.cp_model_helper.CpSolverResponse) -> None

class CpObjectiveProto(pybind11_builtins.pybind11_object):
CpObjectiveProto()

__init__(self: ortools.sat.python.cp_model_helper.CpObjectiveProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.CpObjectiveProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.CpObjectiveProto, arg0: str) -> bool

vars

(arg0: ortools.sat.python.cp_model_helper.CpObjectiveProto) -> google::protobuf::RepeatedField

coeffs

(arg0: ortools.sat.python.cp_model_helper.CpObjectiveProto) -> google::protobuf::RepeatedField

def clear_offset(unknown):

clear_offset(self: ortools.sat.python.cp_model_helper.CpObjectiveProto) -> None

scaling_factor

(arg0: ortools.sat.python.cp_model_helper.CpObjectiveProto) -> float

def clear_scaling_factor(unknown):

clear_scaling_factor(self: ortools.sat.python.cp_model_helper.CpObjectiveProto) -> None

domain

(arg0: ortools.sat.python.cp_model_helper.CpObjectiveProto) -> google::protobuf::RepeatedField

scaling_was_exact

(arg0: ortools.sat.python.cp_model_helper.CpObjectiveProto) -> bool

def clear_scaling_was_exact(unknown):

clear_scaling_was_exact(self: ortools.sat.python.cp_model_helper.CpObjectiveProto) -> None

integer_before_offset

(arg0: ortools.sat.python.cp_model_helper.CpObjectiveProto) -> int

def clear_integer_before_offset(unknown):

clear_integer_before_offset(self: ortools.sat.python.cp_model_helper.CpObjectiveProto) -> None

integer_after_offset

(arg0: ortools.sat.python.cp_model_helper.CpObjectiveProto) -> int

def clear_integer_after_offset(unknown):

clear_integer_after_offset(self: ortools.sat.python.cp_model_helper.CpObjectiveProto) -> None

integer_scaling_factor

(arg0: ortools.sat.python.cp_model_helper.CpObjectiveProto) -> int

def clear_integer_scaling_factor(unknown):

clear_integer_scaling_factor(self: ortools.sat.python.cp_model_helper.CpObjectiveProto) -> None

class IntegerVariableProto(pybind11_builtins.pybind11_object):
IntegerVariableProto()

__init__(self: ortools.sat.python.cp_model_helper.IntegerVariableProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.IntegerVariableProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.IntegerVariableProto, arg0: str) -> bool

def clear_name(unknown):

clear_name(self: ortools.sat.python.cp_model_helper.IntegerVariableProto) -> None

domain

(arg0: ortools.sat.python.cp_model_helper.IntegerVariableProto) -> google::protobuf::RepeatedField

class CpSolverSolution(pybind11_builtins.pybind11_object):
CpSolverSolution()

__init__(self: ortools.sat.python.cp_model_helper.CpSolverSolution) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.CpSolverSolution, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.CpSolverSolution, arg0: str) -> bool

values

(arg0: ortools.sat.python.cp_model_helper.CpSolverSolution) -> google::protobuf::RepeatedField

class CpModelProto(pybind11_builtins.pybind11_object):
CpModelProto()

__init__(self: ortools.sat.python.cp_model_helper.CpModelProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.CpModelProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.CpModelProto, arg0: str) -> bool

def clear_name(unknown):

clear_name(self: ortools.sat.python.cp_model_helper.CpModelProto) -> None

variables

(arg0: ortools.sat.python.cp_model_helper.CpModelProto) -> google::protobuf::RepeatedPtrField

constraints

(arg0: ortools.sat.python.cp_model_helper.CpModelProto) -> google::protobuf::RepeatedPtrField

def clear_objective(unknown):

clear_objective(self: ortools.sat.python.cp_model_helper.CpModelProto) -> None

def has_objective(unknown):

has_objective(self: ortools.sat.python.cp_model_helper.CpModelProto) -> bool

floating_point_objective

(arg0: ortools.sat.python.cp_model_helper.CpModelProto) -> operations_research::sat::FloatObjectiveProto

def clear_floating_point_objective(unknown):

clear_floating_point_objective(self: ortools.sat.python.cp_model_helper.CpModelProto) -> None

def has_floating_point_objective(unknown):

has_floating_point_objective(self: ortools.sat.python.cp_model_helper.CpModelProto) -> bool

search_strategy

(arg0: ortools.sat.python.cp_model_helper.CpModelProto) -> google::protobuf::RepeatedPtrField

solution_hint

(arg0: ortools.sat.python.cp_model_helper.CpModelProto) -> operations_research::sat::PartialVariableAssignment

def clear_solution_hint(unknown):

clear_solution_hint(self: ortools.sat.python.cp_model_helper.CpModelProto) -> None

def has_solution_hint(unknown):

has_solution_hint(self: ortools.sat.python.cp_model_helper.CpModelProto) -> bool

assumptions

(arg0: ortools.sat.python.cp_model_helper.CpModelProto) -> google::protobuf::RepeatedField

symmetry

(arg0: ortools.sat.python.cp_model_helper.CpModelProto) -> operations_research::sat::SymmetryProto

def clear_symmetry(unknown):

clear_symmetry(self: ortools.sat.python.cp_model_helper.CpModelProto) -> None

def has_symmetry(unknown):

has_symmetry(self: ortools.sat.python.cp_model_helper.CpModelProto) -> bool

class SymmetryProto(pybind11_builtins.pybind11_object):
SymmetryProto()

__init__(self: ortools.sat.python.cp_model_helper.SymmetryProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.SymmetryProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.SymmetryProto, arg0: str) -> bool

permutations

(arg0: ortools.sat.python.cp_model_helper.SymmetryProto) -> google::protobuf::RepeatedPtrField

orbitopes

(arg0: ortools.sat.python.cp_model_helper.SymmetryProto) -> google::protobuf::RepeatedPtrField

class DenseMatrixProto(pybind11_builtins.pybind11_object):
DenseMatrixProto()

__init__(self: ortools.sat.python.cp_model_helper.DenseMatrixProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.DenseMatrixProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.DenseMatrixProto, arg0: str) -> bool

def clear_num_rows(unknown):

clear_num_rows(self: ortools.sat.python.cp_model_helper.DenseMatrixProto) -> None

def clear_num_cols(unknown):

clear_num_cols(self: ortools.sat.python.cp_model_helper.DenseMatrixProto) -> None

entries

(arg0: ortools.sat.python.cp_model_helper.DenseMatrixProto) -> google::protobuf::RepeatedField

class SparsePermutationProto(pybind11_builtins.pybind11_object):
SparsePermutationProto()

__init__(self: ortools.sat.python.cp_model_helper.SparsePermutationProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.SparsePermutationProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.SparsePermutationProto, arg0: str) -> bool

support

(arg0: ortools.sat.python.cp_model_helper.SparsePermutationProto) -> google::protobuf::RepeatedField

cycle_sizes

(arg0: ortools.sat.python.cp_model_helper.SparsePermutationProto) -> google::protobuf::RepeatedField

class PartialVariableAssignment(pybind11_builtins.pybind11_object):
PartialVariableAssignment()

__init__(self: ortools.sat.python.cp_model_helper.PartialVariableAssignment) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.PartialVariableAssignment, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.PartialVariableAssignment, arg0: str) -> bool

vars

(arg0: ortools.sat.python.cp_model_helper.PartialVariableAssignment) -> google::protobuf::RepeatedField

values

(arg0: ortools.sat.python.cp_model_helper.PartialVariableAssignment) -> google::protobuf::RepeatedField

class DecisionStrategyProto(pybind11_builtins.pybind11_object):
DecisionStrategyProto()

__init__(self: ortools.sat.python.cp_model_helper.DecisionStrategyProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.DecisionStrategyProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.DecisionStrategyProto, arg0: str) -> bool

variables

(arg0: ortools.sat.python.cp_model_helper.DecisionStrategyProto) -> google::protobuf::RepeatedField

exprs

(arg0: ortools.sat.python.cp_model_helper.DecisionStrategyProto) -> google::protobuf::RepeatedPtrField

variable_selection_strategy

(arg0: ortools.sat.python.cp_model_helper.DecisionStrategyProto) -> operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy

def clear_variable_selection_strategy(unknown):

clear_variable_selection_strategy(self: ortools.sat.python.cp_model_helper.DecisionStrategyProto) -> None

domain_reduction_strategy

(arg0: ortools.sat.python.cp_model_helper.DecisionStrategyProto) -> operations_research::sat::DecisionStrategyProto_DomainReductionStrategy

def clear_domain_reduction_strategy(unknown):

clear_domain_reduction_strategy(self: ortools.sat.python.cp_model_helper.DecisionStrategyProto) -> None

CHOOSE_FIRST = <VariableSelectionStrategy.CHOOSE_FIRST: 0>
CHOOSE_LOWEST_MIN = <VariableSelectionStrategy.CHOOSE_LOWEST_MIN: 1>
CHOOSE_HIGHEST_MAX = <VariableSelectionStrategy.CHOOSE_HIGHEST_MAX: 2>
CHOOSE_MIN_DOMAIN_SIZE = <VariableSelectionStrategy.CHOOSE_MIN_DOMAIN_SIZE: 3>
CHOOSE_MAX_DOMAIN_SIZE = <VariableSelectionStrategy.CHOOSE_MAX_DOMAIN_SIZE: 4>
SELECT_MIN_VALUE = <DomainReductionStrategy.SELECT_MIN_VALUE: 0>
SELECT_MAX_VALUE = <DomainReductionStrategy.SELECT_MAX_VALUE: 1>
SELECT_LOWER_HALF = <DomainReductionStrategy.SELECT_LOWER_HALF: 2>
SELECT_UPPER_HALF = <DomainReductionStrategy.SELECT_UPPER_HALF: 3>
SELECT_MEDIAN_VALUE = <DomainReductionStrategy.SELECT_MEDIAN_VALUE: 4>
SELECT_RANDOM_HALF = <DomainReductionStrategy.SELECT_RANDOM_HALF: 5>
class DecisionStrategyProto.VariableSelectionStrategy(pybind11_builtins.pybind11_object):

Members:

CHOOSE_FIRST

CHOOSE_LOWEST_MIN

CHOOSE_HIGHEST_MAX

CHOOSE_MIN_DOMAIN_SIZE

CHOOSE_MAX_DOMAIN_SIZE

DecisionStrategyProto.VariableSelectionStrategy()

__init__(self: ortools.sat.python.cp_model_helper.DecisionStrategyProto.VariableSelectionStrategy, value: int) -> None

name

name(self: object) -> str

CHOOSE_FIRST = <VariableSelectionStrategy.CHOOSE_FIRST: 0>
CHOOSE_LOWEST_MIN = <VariableSelectionStrategy.CHOOSE_LOWEST_MIN: 1>
CHOOSE_HIGHEST_MAX = <VariableSelectionStrategy.CHOOSE_HIGHEST_MAX: 2>
CHOOSE_MIN_DOMAIN_SIZE = <VariableSelectionStrategy.CHOOSE_MIN_DOMAIN_SIZE: 3>
CHOOSE_MAX_DOMAIN_SIZE = <VariableSelectionStrategy.CHOOSE_MAX_DOMAIN_SIZE: 4>
class DecisionStrategyProto.DomainReductionStrategy(pybind11_builtins.pybind11_object):

Members:

SELECT_MIN_VALUE

SELECT_MAX_VALUE

SELECT_LOWER_HALF

SELECT_UPPER_HALF

SELECT_MEDIAN_VALUE

SELECT_RANDOM_HALF

DecisionStrategyProto.DomainReductionStrategy()

__init__(self: ortools.sat.python.cp_model_helper.DecisionStrategyProto.DomainReductionStrategy, value: int) -> None

name

name(self: object) -> str

SELECT_MIN_VALUE = <DomainReductionStrategy.SELECT_MIN_VALUE: 0>
SELECT_MAX_VALUE = <DomainReductionStrategy.SELECT_MAX_VALUE: 1>
SELECT_LOWER_HALF = <DomainReductionStrategy.SELECT_LOWER_HALF: 2>
SELECT_UPPER_HALF = <DomainReductionStrategy.SELECT_UPPER_HALF: 3>
SELECT_MEDIAN_VALUE = <DomainReductionStrategy.SELECT_MEDIAN_VALUE: 4>
SELECT_RANDOM_HALF = <DomainReductionStrategy.SELECT_RANDOM_HALF: 5>
class LinearExpressionProto(pybind11_builtins.pybind11_object):
LinearExpressionProto()

__init__(self: ortools.sat.python.cp_model_helper.LinearExpressionProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.LinearExpressionProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.LinearExpressionProto, arg0: str) -> bool

vars

(arg0: ortools.sat.python.cp_model_helper.LinearExpressionProto) -> google::protobuf::RepeatedField

coeffs

(arg0: ortools.sat.python.cp_model_helper.LinearExpressionProto) -> google::protobuf::RepeatedField

def clear_offset(unknown):

clear_offset(self: ortools.sat.python.cp_model_helper.LinearExpressionProto) -> None

class FloatObjectiveProto(pybind11_builtins.pybind11_object):
FloatObjectiveProto()

__init__(self: ortools.sat.python.cp_model_helper.FloatObjectiveProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.FloatObjectiveProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.FloatObjectiveProto, arg0: str) -> bool

vars

(arg0: ortools.sat.python.cp_model_helper.FloatObjectiveProto) -> google::protobuf::RepeatedField

coeffs

(arg0: ortools.sat.python.cp_model_helper.FloatObjectiveProto) -> google::protobuf::RepeatedField

def clear_offset(unknown):

clear_offset(self: ortools.sat.python.cp_model_helper.FloatObjectiveProto) -> None

def clear_maximize(unknown):

clear_maximize(self: ortools.sat.python.cp_model_helper.FloatObjectiveProto) -> None

class ConstraintProto(pybind11_builtins.pybind11_object):
ConstraintProto()

__init__(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.ConstraintProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.ConstraintProto, arg0: str) -> bool

def clear_name(unknown):

clear_name(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

enforcement_literal

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> google::protobuf::RepeatedField

bool_or

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::BoolArgumentProto

def clear_bool_or(unknown):

clear_bool_or(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_bool_or(unknown):

has_bool_or(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

bool_and

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::BoolArgumentProto

def clear_bool_and(unknown):

clear_bool_and(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_bool_and(unknown):

has_bool_and(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

at_most_one

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::BoolArgumentProto

def clear_at_most_one(unknown):

clear_at_most_one(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_at_most_one(unknown):

has_at_most_one(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

exactly_one

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::BoolArgumentProto

def clear_exactly_one(unknown):

clear_exactly_one(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_exactly_one(unknown):

has_exactly_one(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

bool_xor

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::BoolArgumentProto

def clear_bool_xor(unknown):

clear_bool_xor(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_bool_xor(unknown):

has_bool_xor(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

int_div

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::LinearArgumentProto

def clear_int_div(unknown):

clear_int_div(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_int_div(unknown):

has_int_div(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

int_mod

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::LinearArgumentProto

def clear_int_mod(unknown):

clear_int_mod(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_int_mod(unknown):

has_int_mod(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

int_prod

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::LinearArgumentProto

def clear_int_prod(unknown):

clear_int_prod(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_int_prod(unknown):

has_int_prod(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

lin_max

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::LinearArgumentProto

def clear_lin_max(unknown):

clear_lin_max(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_lin_max(unknown):

has_lin_max(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

linear

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::LinearConstraintProto

def clear_linear(unknown):

clear_linear(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_linear(unknown):

has_linear(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

all_diff

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::AllDifferentConstraintProto

def clear_all_diff(unknown):

clear_all_diff(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_all_diff(unknown):

has_all_diff(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

element

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::ElementConstraintProto

def clear_element(unknown):

clear_element(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_element(unknown):

has_element(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

circuit

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::CircuitConstraintProto

def clear_circuit(unknown):

clear_circuit(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_circuit(unknown):

has_circuit(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

routes

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::RoutesConstraintProto

def clear_routes(unknown):

clear_routes(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_routes(unknown):

has_routes(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

table

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::TableConstraintProto

def clear_table(unknown):

clear_table(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_table(unknown):

has_table(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

automaton

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::AutomatonConstraintProto

def clear_automaton(unknown):

clear_automaton(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_automaton(unknown):

has_automaton(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

inverse

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::InverseConstraintProto

def clear_inverse(unknown):

clear_inverse(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_inverse(unknown):

has_inverse(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

reservoir

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::ReservoirConstraintProto

def clear_reservoir(unknown):

clear_reservoir(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_reservoir(unknown):

has_reservoir(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

interval

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::IntervalConstraintProto

def clear_interval(unknown):

clear_interval(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_interval(unknown):

has_interval(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

no_overlap

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::NoOverlapConstraintProto

def clear_no_overlap(unknown):

clear_no_overlap(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_no_overlap(unknown):

has_no_overlap(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

no_overlap_2d

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::NoOverlap2DConstraintProto

def clear_no_overlap_2d(unknown):

clear_no_overlap_2d(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_no_overlap_2d(unknown):

has_no_overlap_2d(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

cumulative

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::CumulativeConstraintProto

def clear_cumulative(unknown):

clear_cumulative(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_cumulative(unknown):

has_cumulative(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

dummy_constraint

(arg0: ortools.sat.python.cp_model_helper.ConstraintProto) -> operations_research::sat::ListOfVariablesProto

def clear_dummy_constraint(unknown):

clear_dummy_constraint(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> None

def has_dummy_constraint(unknown):

has_dummy_constraint(self: ortools.sat.python.cp_model_helper.ConstraintProto) -> bool

class ListOfVariablesProto(pybind11_builtins.pybind11_object):
ListOfVariablesProto()

__init__(self: ortools.sat.python.cp_model_helper.ListOfVariablesProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.ListOfVariablesProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.ListOfVariablesProto, arg0: str) -> bool

vars

(arg0: ortools.sat.python.cp_model_helper.ListOfVariablesProto) -> google::protobuf::RepeatedField

class CumulativeConstraintProto(pybind11_builtins.pybind11_object):
CumulativeConstraintProto()

__init__(self: ortools.sat.python.cp_model_helper.CumulativeConstraintProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.CumulativeConstraintProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.CumulativeConstraintProto, arg0: str) -> bool

def clear_capacity(unknown):

clear_capacity(self: ortools.sat.python.cp_model_helper.CumulativeConstraintProto) -> None

def has_capacity(unknown):

has_capacity(self: ortools.sat.python.cp_model_helper.CumulativeConstraintProto) -> bool

intervals

(arg0: ortools.sat.python.cp_model_helper.CumulativeConstraintProto) -> google::protobuf::RepeatedField

demands

(arg0: ortools.sat.python.cp_model_helper.CumulativeConstraintProto) -> google::protobuf::RepeatedPtrField

class NoOverlap2DConstraintProto(pybind11_builtins.pybind11_object):
NoOverlap2DConstraintProto()

__init__(self: ortools.sat.python.cp_model_helper.NoOverlap2DConstraintProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.NoOverlap2DConstraintProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.NoOverlap2DConstraintProto, arg0: str) -> bool

x_intervals

(arg0: ortools.sat.python.cp_model_helper.NoOverlap2DConstraintProto) -> google::protobuf::RepeatedField

y_intervals

(arg0: ortools.sat.python.cp_model_helper.NoOverlap2DConstraintProto) -> google::protobuf::RepeatedField

class NoOverlapConstraintProto(pybind11_builtins.pybind11_object):
NoOverlapConstraintProto()

__init__(self: ortools.sat.python.cp_model_helper.NoOverlapConstraintProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.NoOverlapConstraintProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.NoOverlapConstraintProto, arg0: str) -> bool

intervals

(arg0: ortools.sat.python.cp_model_helper.NoOverlapConstraintProto) -> google::protobuf::RepeatedField

class IntervalConstraintProto(pybind11_builtins.pybind11_object):
IntervalConstraintProto()

__init__(self: ortools.sat.python.cp_model_helper.IntervalConstraintProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.IntervalConstraintProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.IntervalConstraintProto, arg0: str) -> bool

def clear_start(unknown):

clear_start(self: ortools.sat.python.cp_model_helper.IntervalConstraintProto) -> None

def has_start(unknown):

has_start(self: ortools.sat.python.cp_model_helper.IntervalConstraintProto) -> bool

def clear_end(unknown):

clear_end(self: ortools.sat.python.cp_model_helper.IntervalConstraintProto) -> None

def has_end(unknown):

has_end(self: ortools.sat.python.cp_model_helper.IntervalConstraintProto) -> bool

def clear_size(unknown):

clear_size(self: ortools.sat.python.cp_model_helper.IntervalConstraintProto) -> None

def has_size(unknown):

has_size(self: ortools.sat.python.cp_model_helper.IntervalConstraintProto) -> bool

class ReservoirConstraintProto(pybind11_builtins.pybind11_object):
ReservoirConstraintProto()

__init__(self: ortools.sat.python.cp_model_helper.ReservoirConstraintProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.ReservoirConstraintProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.ReservoirConstraintProto, arg0: str) -> bool

def clear_min_level(unknown):

clear_min_level(self: ortools.sat.python.cp_model_helper.ReservoirConstraintProto) -> None

def clear_max_level(unknown):

clear_max_level(self: ortools.sat.python.cp_model_helper.ReservoirConstraintProto) -> None

time_exprs

(arg0: ortools.sat.python.cp_model_helper.ReservoirConstraintProto) -> google::protobuf::RepeatedPtrField

level_changes

(arg0: ortools.sat.python.cp_model_helper.ReservoirConstraintProto) -> google::protobuf::RepeatedPtrField

active_literals

(arg0: ortools.sat.python.cp_model_helper.ReservoirConstraintProto) -> google::protobuf::RepeatedField

class InverseConstraintProto(pybind11_builtins.pybind11_object):
InverseConstraintProto()

__init__(self: ortools.sat.python.cp_model_helper.InverseConstraintProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.InverseConstraintProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.InverseConstraintProto, arg0: str) -> bool

f_direct

(arg0: ortools.sat.python.cp_model_helper.InverseConstraintProto) -> google::protobuf::RepeatedField

f_inverse

(arg0: ortools.sat.python.cp_model_helper.InverseConstraintProto) -> google::protobuf::RepeatedField

class AutomatonConstraintProto(pybind11_builtins.pybind11_object):
AutomatonConstraintProto()

__init__(self: ortools.sat.python.cp_model_helper.AutomatonConstraintProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.AutomatonConstraintProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.AutomatonConstraintProto, arg0: str) -> bool

def clear_starting_state(unknown):

clear_starting_state(self: ortools.sat.python.cp_model_helper.AutomatonConstraintProto) -> None

final_states

(arg0: ortools.sat.python.cp_model_helper.AutomatonConstraintProto) -> google::protobuf::RepeatedField

transition_tail

(arg0: ortools.sat.python.cp_model_helper.AutomatonConstraintProto) -> google::protobuf::RepeatedField

transition_head

(arg0: ortools.sat.python.cp_model_helper.AutomatonConstraintProto) -> google::protobuf::RepeatedField

transition_label

(arg0: ortools.sat.python.cp_model_helper.AutomatonConstraintProto) -> google::protobuf::RepeatedField

vars

(arg0: ortools.sat.python.cp_model_helper.AutomatonConstraintProto) -> google::protobuf::RepeatedField

exprs

(arg0: ortools.sat.python.cp_model_helper.AutomatonConstraintProto) -> google::protobuf::RepeatedPtrField

class TableConstraintProto(pybind11_builtins.pybind11_object):
TableConstraintProto()

__init__(self: ortools.sat.python.cp_model_helper.TableConstraintProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.TableConstraintProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.TableConstraintProto, arg0: str) -> bool

vars

(arg0: ortools.sat.python.cp_model_helper.TableConstraintProto) -> google::protobuf::RepeatedField

values

(arg0: ortools.sat.python.cp_model_helper.TableConstraintProto) -> google::protobuf::RepeatedField

exprs

(arg0: ortools.sat.python.cp_model_helper.TableConstraintProto) -> google::protobuf::RepeatedPtrField

def clear_negated(unknown):

clear_negated(self: ortools.sat.python.cp_model_helper.TableConstraintProto) -> None

class RoutesConstraintProto(pybind11_builtins.pybind11_object):
RoutesConstraintProto()

__init__(self: ortools.sat.python.cp_model_helper.RoutesConstraintProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.RoutesConstraintProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.RoutesConstraintProto, arg0: str) -> bool

tails

(arg0: ortools.sat.python.cp_model_helper.RoutesConstraintProto) -> google::protobuf::RepeatedField

heads

(arg0: ortools.sat.python.cp_model_helper.RoutesConstraintProto) -> google::protobuf::RepeatedField

literals

(arg0: ortools.sat.python.cp_model_helper.RoutesConstraintProto) -> google::protobuf::RepeatedField

demands

(arg0: ortools.sat.python.cp_model_helper.RoutesConstraintProto) -> google::protobuf::RepeatedField

def clear_capacity(unknown):

clear_capacity(self: ortools.sat.python.cp_model_helper.RoutesConstraintProto) -> None

dimensions

(arg0: ortools.sat.python.cp_model_helper.RoutesConstraintProto) -> google::protobuf::RepeatedPtrField

class RoutesConstraintProto.NodeExpressions(pybind11_builtins.pybind11_object):
RoutesConstraintProto.NodeExpressions()

__init__(self: ortools.sat.python.cp_model_helper.RoutesConstraintProto.NodeExpressions) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.RoutesConstraintProto.NodeExpressions, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.RoutesConstraintProto.NodeExpressions, arg0: str) -> bool

exprs

(arg0: ortools.sat.python.cp_model_helper.RoutesConstraintProto.NodeExpressions) -> google::protobuf::RepeatedPtrField

class CircuitConstraintProto(pybind11_builtins.pybind11_object):
CircuitConstraintProto()

__init__(self: ortools.sat.python.cp_model_helper.CircuitConstraintProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.CircuitConstraintProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.CircuitConstraintProto, arg0: str) -> bool

tails

(arg0: ortools.sat.python.cp_model_helper.CircuitConstraintProto) -> google::protobuf::RepeatedField

heads

(arg0: ortools.sat.python.cp_model_helper.CircuitConstraintProto) -> google::protobuf::RepeatedField

literals

(arg0: ortools.sat.python.cp_model_helper.CircuitConstraintProto) -> google::protobuf::RepeatedField

class ElementConstraintProto(pybind11_builtins.pybind11_object):
ElementConstraintProto()

__init__(self: ortools.sat.python.cp_model_helper.ElementConstraintProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.ElementConstraintProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.ElementConstraintProto, arg0: str) -> bool

def clear_index(unknown):

clear_index(self: ortools.sat.python.cp_model_helper.ElementConstraintProto) -> None

def clear_target(unknown):

clear_target(self: ortools.sat.python.cp_model_helper.ElementConstraintProto) -> None

vars

(arg0: ortools.sat.python.cp_model_helper.ElementConstraintProto) -> google::protobuf::RepeatedField

def clear_linear_index(unknown):

clear_linear_index(self: ortools.sat.python.cp_model_helper.ElementConstraintProto) -> None

def has_linear_index(unknown):

has_linear_index(self: ortools.sat.python.cp_model_helper.ElementConstraintProto) -> bool

def clear_linear_target(unknown):

clear_linear_target(self: ortools.sat.python.cp_model_helper.ElementConstraintProto) -> None

def has_linear_target(unknown):

has_linear_target(self: ortools.sat.python.cp_model_helper.ElementConstraintProto) -> bool

exprs

(arg0: ortools.sat.python.cp_model_helper.ElementConstraintProto) -> google::protobuf::RepeatedPtrField

class AllDifferentConstraintProto(pybind11_builtins.pybind11_object):
AllDifferentConstraintProto()

__init__(self: ortools.sat.python.cp_model_helper.AllDifferentConstraintProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.AllDifferentConstraintProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.AllDifferentConstraintProto, arg0: str) -> bool

exprs

(arg0: ortools.sat.python.cp_model_helper.AllDifferentConstraintProto) -> google::protobuf::RepeatedPtrField

class LinearConstraintProto(pybind11_builtins.pybind11_object):
LinearConstraintProto()

__init__(self: ortools.sat.python.cp_model_helper.LinearConstraintProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.LinearConstraintProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.LinearConstraintProto, arg0: str) -> bool

vars

(arg0: ortools.sat.python.cp_model_helper.LinearConstraintProto) -> google::protobuf::RepeatedField

coeffs

(arg0: ortools.sat.python.cp_model_helper.LinearConstraintProto) -> google::protobuf::RepeatedField

domain

(arg0: ortools.sat.python.cp_model_helper.LinearConstraintProto) -> google::protobuf::RepeatedField

class LinearArgumentProto(pybind11_builtins.pybind11_object):
LinearArgumentProto()

__init__(self: ortools.sat.python.cp_model_helper.LinearArgumentProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.LinearArgumentProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.LinearArgumentProto, arg0: str) -> bool

def clear_target(unknown):

clear_target(self: ortools.sat.python.cp_model_helper.LinearArgumentProto) -> None

def has_target(unknown):

has_target(self: ortools.sat.python.cp_model_helper.LinearArgumentProto) -> bool

exprs

(arg0: ortools.sat.python.cp_model_helper.LinearArgumentProto) -> google::protobuf::RepeatedPtrField

class BoolArgumentProto(pybind11_builtins.pybind11_object):
BoolArgumentProto()

__init__(self: ortools.sat.python.cp_model_helper.BoolArgumentProto) -> None

def merge_text_format(unknown):

merge_text_format(self: ortools.sat.python.cp_model_helper.BoolArgumentProto, arg0: str) -> bool

def parse_text_format(unknown):

parse_text_format(self: ortools.sat.python.cp_model_helper.BoolArgumentProto, arg0: str) -> bool

literals

(arg0: ortools.sat.python.cp_model_helper.BoolArgumentProto) -> google::protobuf::RepeatedField

class CpSolverStatus(pybind11_builtins.pybind11_object):

Members:

UNKNOWN

MODEL_INVALID

FEASIBLE

INFEASIBLE

OPTIMAL

CpSolverStatus()

__init__(self: ortools.sat.python.cp_model_helper.CpSolverStatus, value: int) -> None

name

name(self: object) -> str

UNKNOWN = <CpSolverStatus.UNKNOWN: 0>
MODEL_INVALID = <CpSolverStatus.MODEL_INVALID: 1>
FEASIBLE = <CpSolverStatus.FEASIBLE: 2>
INFEASIBLE = <CpSolverStatus.INFEASIBLE: 3>
OPTIMAL = <CpSolverStatus.OPTIMAL: 4>
UNKNOWN = <CpSolverStatus.UNKNOWN: 0>
MODEL_INVALID = <CpSolverStatus.MODEL_INVALID: 1>
FEASIBLE = <CpSolverStatus.FEASIBLE: 2>
INFEASIBLE = <CpSolverStatus.INFEASIBLE: 3>
OPTIMAL = <CpSolverStatus.OPTIMAL: 4>
class repeated_LinearExpressionProto(pybind11_builtins.pybind11_object):
repeated_LinearExpressionProto(*args, **kwargs)
class repeated_DecisionStrategyProto(pybind11_builtins.pybind11_object):
repeated_DecisionStrategyProto(*args, **kwargs)
class repeated_CpSolverSolution(pybind11_builtins.pybind11_object):
repeated_CpSolverSolution(*args, **kwargs)
def clear(unknown):

clear(self: ortools.sat.python.cp_model_helper.repeated_CpSolverSolution) -> None

class repeated_SatParameters(pybind11_builtins.pybind11_object):
repeated_SatParameters(*args, **kwargs)
def clear(unknown):

clear(self: ortools.sat.python.cp_model_helper.repeated_SatParameters) -> None

class repeated_IntegerVariableProto(pybind11_builtins.pybind11_object):
repeated_IntegerVariableProto(*args, **kwargs)
def clear(unknown):

clear(self: ortools.sat.python.cp_model_helper.repeated_IntegerVariableProto) -> None

class repeated_SparsePermutationProto(pybind11_builtins.pybind11_object):
repeated_SparsePermutationProto(*args, **kwargs)
class repeated_DenseMatrixProto(pybind11_builtins.pybind11_object):
repeated_DenseMatrixProto(*args, **kwargs)
def clear(unknown):

clear(self: ortools.sat.python.cp_model_helper.repeated_DenseMatrixProto) -> None

class repeated_ConstraintProto(pybind11_builtins.pybind11_object):
repeated_ConstraintProto(*args, **kwargs)
def clear(unknown):

clear(self: ortools.sat.python.cp_model_helper.repeated_ConstraintProto) -> None

class repeated_NodeExpressions(pybind11_builtins.pybind11_object):
repeated_NodeExpressions(*args, **kwargs)
def clear(unknown):

clear(self: ortools.sat.python.cp_model_helper.repeated_NodeExpressions) -> None

class repeated_scalar_std_string(pybind11_builtins.pybind11_object):
repeated_scalar_std_string(*args, **kwargs)
def append(unknown):

append(self: ortools.sat.python.cp_model_helper.repeated_scalar_std_string, arg0: str) -> None

def extend(unknown):

extend(self: ortools.sat.python.cp_model_helper.repeated_scalar_std_string, arg0: list[str]) -> None

def clear(unknown):

clear(self: ortools.sat.python.cp_model_helper.repeated_scalar_std_string) -> None

class repeated_scalar_operations_research_sat_SatParameters_RestartAlgorithm(pybind11_builtins.pybind11_object):
repeated_scalar_operations_research_sat_SatParameters_RestartAlgorithm(*args, **kwargs)
def append(unknown):

append(self: ortools.sat.python.cp_model_helper.repeated_scalar_operations_research_sat_SatParameters_RestartAlgorithm, arg0: operations_research::sat::SatParameters_RestartAlgorithm) -> None

def extend(unknown):

extend(self: ortools.sat.python.cp_model_helper.repeated_scalar_operations_research_sat_SatParameters_RestartAlgorithm, arg0: list[operations_research::sat::SatParameters_RestartAlgorithm]) -> None

class repeated_scalar_int64_t(pybind11_builtins.pybind11_object):
repeated_scalar_int64_t(*args, **kwargs)
def append(unknown):

append(self: ortools.sat.python.cp_model_helper.repeated_scalar_int64_t, arg0: int) -> None

def extend(unknown):

extend(self: ortools.sat.python.cp_model_helper.repeated_scalar_int64_t, arg0: list[int]) -> None

def clear(unknown):

clear(self: ortools.sat.python.cp_model_helper.repeated_scalar_int64_t) -> None

class repeated_scalar_double(pybind11_builtins.pybind11_object):
repeated_scalar_double(*args, **kwargs)
def append(unknown):

append(self: ortools.sat.python.cp_model_helper.repeated_scalar_double, arg0: float) -> None

def extend(unknown):

extend(self: ortools.sat.python.cp_model_helper.repeated_scalar_double, arg0: list[float]) -> None

def clear(unknown):

clear(self: ortools.sat.python.cp_model_helper.repeated_scalar_double) -> None

class repeated_scalar_int32_t(pybind11_builtins.pybind11_object):
repeated_scalar_int32_t(*args, **kwargs)
def append(unknown):

append(self: ortools.sat.python.cp_model_helper.repeated_scalar_int32_t, arg0: int) -> None

def extend(unknown):

extend(self: ortools.sat.python.cp_model_helper.repeated_scalar_int32_t, arg0: list[int]) -> None

def clear(unknown):

clear(self: ortools.sat.python.cp_model_helper.repeated_scalar_int32_t) -> None