LSModel Class¶
 class localsolver.LSModel¶
Mathematical optimization model. A model is composed of expressions (some of which are decisions), organized as a Directed Acyclic Graph (DAG). Then, some expressions of the model can be constrained or optimized. Once your optimization model is created and closed, the solver can be launched to solve it. Note that you cannot modify a model which has been closed: you must reopen it (with
open()
) or instantiate another LocalSolver environment to optimize another model.
Summary¶
Number of expressions in this model. 

Number of operands in this model. 

Number of objectives in this model. 

Number of constraints in this model. 

Number of decisions in this model. 

List of the expressions of the model. 

List of the decisions of the model. 

List of the objectives of the model. 

List of the objective directions of the model. 

List of the constraints of the model. 
Creates a constant expression representing the given value. 

Creates a new expression of the given type with the given operands. 

Creates a lambda function with arguments. 

Shortcut for create_lambda_function(). 

Creates an integer external function. 

Shortcut for create_int_external_function(). 

Creates a double external function. 

Shortcut for create_double_external_function(). 

Creates an integer array external function. 

Shortcut for create_int_array_external_function(). 

Creates a double array external function. 

Shortcut for create_double_array_external_function(). 

Returns the number of expressions added to this model. 

Gets the expression with the given index or the given name in this model. 

Gets the number of decisions in the model. 

Gets the decision with the given index. 

Adds the given expression to the list of constraints. 

Shortcut for add_constraint(). 

Removes the given expression from the list of constraints. 

Gets the number of constraints added to this model. 

Gets the constraint with the given index. 

Adds the given expression to the list of objectives to optimize. 

Shortcut for add_objective(expr, LSObjectiveDirection.MINIMIZE). 

Shortcut for add_objective(expr, LSObjectiveDirection.MAXIMIZE). 

Removes the objective at the given position in the list of objectives. 

Gets the number of objectives added to this model. 

Gets the objective with the given index. 

Gets the direction of the objective with the given index. 

Gets the number of operands in the model. 

Closes the model. 

Reopens the model. 

Returns true if the model is closed, false otherwise. 

Creates a boolean decision. 

Creates a float decision. 

Creates an integer decision. 

Creates an interval decision included in [minStart, maxEnd). 

Creates a sum expression. 

Creates a substraction expression. 

Creates a product expression. 

Creates a max expression. 

Creates a min expression. 

Creates a boolean or expression. 

Creates a boolean and expression. 

Creates a boolean xor expression. 

Creates a boolean not expression. 

Creates an equality expression. 

Creates a disequality expression. 

Creates an inequality ‘greater than or equal to’. 

Creates an inequality ‘lower than or equal to’. 

Creates an inequality ‘strictly greater than’. 

Creates an inequality ‘strictly lower than’. 

Creates a ternary conditional operator. 

Creates an absolute value expression. 

Creates a distance expression. 

Creates a division expression. 

Creates a modulo expression. 

Creates a new array. 

Creates a “at” expression. 

Creates a scalar product between two arrays. 

Creates a ceil expression. 

Creates a floor expression. 

Creates a round expression. 

Creates a square root expression. 

Creates a natural log expression. 

Creates an exponential expression. 

Creates a power expression. 

Creates a cosine expression. 

Creates a sine expression. 

Creates a tangent expression. 

Creates a piecewise linear expression. 

Creates a list decision with the given length. 

Creates a set decision with the given length. 

Creates a start expression. 

Creates an end expression. 

Creates a length expression. 

Creates a count expression. 

Creates an indexOf expression. 

Creates a distinct expression. 

Creates an intersection expression. 

Creates a contains expression. 

Creates a partition expression. 

Creates a disjoint expression. 

Creates a cover expression. 

Creates a find expression. 

Creates a sort expression. 

Creates a call expression. 

Creates a range expression. 
Returns a string representation of this model. 
Instance methods¶
 LSModel.create_constant(value)¶
Creates a constant expression representing the given value. The given value can be a boolean, an integer or a double. Only allowed in state
LSState.MODELING
. Note that if a constant has been already created with the same value, this method can return the same expression, but it is not guaranteed. The exact behavior is implementation defined. Parameters
value – Value of the constant (can be a boolean, integer or double).
 Returns
Created constant expression
 Return type
 LSModel.create_expression(operator)¶
 localsolver.create_expression(operator, operands)¶
 localsolver.create_expression(operator, *operands)
Creates a new expression of the given type with the given operands. Only allowed in state
LSState.MODELING
. This method cannot be used to create constants: useLSModel.create_constant()
instead.The operands parameter accept any object that implements the
__iter__
method. Thus, lists, tuples, sets and their comprehensions counterpart are accepted. It is also possible to use this method with a variadic number of arguments.Each operand can be an LSExpression, a boolean, an integer or a double.
 Since
5.5
 Parameters
operator (LSOperator) – Type of the expression to create.
operands – Operands to add. An iterable or any number of arguments.
 Returns
Created expression
 Return type
 LSModel.create_lambda_function(function)¶
Creates a lambda function with arguments. A lambda function is a particular expression composed of two parts:
The arguments of the function (which are also LSExpressions of type
LSOperator.ARGUMENT
).The body of the function. The body is an LSExpression that will be used to evaluate the result of the function. The body can be any LSExpression composed of any operands and operators supported by LocalSolver. Thus, the body expression can use the arguments of the function but can also capture and refer to expressions declared outside of the function.
The function you provide will not be used directly during the solving process, but will be evaluated once by the API, with a number of LSExpression of type
LSOperator.ARGUMENT
that corresponds to the number of arguments you want and your function expects. At the end of the evaluation of your function, the returned LSExpression will be used as the body of the LocalSolver function. Since
9.5
 Parameters
function – A python function that accepts
LSExpression
as arguments and returns anLSExpression
that will be used as the body of the new LocalSolver function you want to create. Returns
Expression of type
LSOperator.LAMBDA_FUNCTION
 Return type
 LSModel.lambda_function(function)¶
Shortcut for
create_lambda_function()
. Since
9.5
 Parameters
function – A python function that accepts
LSExpression
as arguments and returns anLSExpression
that will be used as the body of the new LocalSolver function you want to create. Returns
Expression of type
LSOperator.LAMBDA_FUNCTION
 Return type
 LSModel.create_int_external_function(function)¶
Creates an integer external function. The provided function must take the external argument values (
LSExternalArgumentValues
) associated with the function as single argument and must return an integer value. When the external function is called, the argument values will be made accessible to your function through theLSExternalArgumentValues
.Once you have instantiated it, you have to use
call()
to call it in your model.Note 1: Most of the time your external function will be called when the solver is in state
LSState.RUNNING
. Do not attempt to call any method of the solver (to retrieve statistics, values of LSExpressions or whatever) in that state or an exception will be thrown. The only accessible function isLocalSolver.stop()
.Note 2: Your functions must be threadsafe. According to the “nb_threads” parameter, LocalSolver can be multithreaded. In that case, your external functions must be thread safe. If you cannot guarantee the threadsafety of your code, we strongly recommend you to limit the search of LocalSolver to one thread with
LSParam.nb_threads
.Note 3: You can provide additional data concerning your function (such as lower and upper bounds) with the help of the
LSExternalContext
associated with your function (seeLSExpression.get_external_context()
. Since
9.5
 Parameters
function – A python function that accepts a
LSExternalArgumentValues
as first argument and returns an integer value. Returns
Expression of type
LSOperator.EXTERNAL_FUNCTION
. Return type
 LSModel.int_external_function(function)¶
Shortcut for
create_int_external_function()
. Since
9.5
 Parameters
function – A python function that accepts a
LSExternalArgumentValues
as first argument and returns an integer value. Returns
Expression of type
LSOperator.EXTERNAL_FUNCTION
. Return type
 LSModel.create_double_external_function(function)¶
Creates a double external function. The provided function must take the external argument values (
LSExternalArgumentValues
) associated with the function as single argument and must return a double value. When the external function is called, the argument values will be made accessible to your function through theLSExternalArgumentValues
.Once you have instantiated it, you have to use
call()
to call it in your model.Note 1: Most of the time your external function will be called when the solver is in state
LSState.RUNNING
. Do not attempt to call any method of the solver (to retrieve statistics, values of LSExpressions or whatever) in that state or an exception will be thrown. The only accessible function isLocalSolver.stop()
.Note 2: Your functions must be threadsafe. According to the “nb_threads” parameter, LocalSolver can be multithreaded. In that case, your external functions must be thread safe. If you cannot guarantee the threadsafety of your code, we strongly recommend you to limit the search of LocalSolver to one thread with
LSParam.nb_threads
.Note 3: You can provide additional data concerning your function (such as lower and upper bounds) with the help of the
LSExternalContext
associated with your function (seeLSExpression.get_external_context()
. Since
9.5
 Parameters
function – A python function that accepts a
LSExternalArgumentValues
as first argument and returns a double value. Returns
Expression of type
LSOperator.EXTERNAL_FUNCTION
. Return type
 LSModel.double_external_function(function)¶
Shortcut for
create_double_external_function()
. Since
9.5
 Parameters
function – A python function that accepts a
LSExternalArgumentValues
as first argument and returns a double value. Returns
Expression of type
LSOperator.EXTERNAL_FUNCTION
. Return type
 LSModel.create_int_array_external_function(function)¶
Creates an integer array external function. The provided function must take a (
LSExternalArgumentValues
) as single argument and must return an iterable of integer values (such as list, set or tuple ofint
). When the external function is called, the argument values will be made accessible to your function through theLSExternalArgumentValues
.Once you have instantiated it, you have to use
call()
to call it in your model. Since
11.0
 Parameters
function – A python function that accepts a
LSExternalArgumentValues
as first argument and returns an integer array value. Returns
Expression of type
LSOperator.EXTERNAL_FUNCTION
. Return type
 LSModel.int_array_external_function(function)¶
Shortcut for
create_int_array_external_function()
. Since
11.0
 Parameters
function – A python function that accepts a
LSExternalArgumentValues
as first argument and returns an integer array value Returns
Expression of type
LSOperator.EXTERNAL_FUNCTION
. Return type
 LSModel.create_double_array_external_function(function)¶
Creates a double array external function. The provided function must take a (
LSExternalArgumentValues
) as single argument and must return an iterable of double values (such as list, set or tuple ofdouble
). When the external function is called, the argument values will be made accessible to your function through theLSExternalArgumentValues
.Once you have instantiated it, you have to use
call()
to call it in your model. Since
11.0
 Parameters
function – A python function that accepts a
LSExternalArgumentValues
as first argument and returns a double array value. Returns
Expression of type
LSOperator.EXTERNAL_FUNCTION
. Return type
 LSModel.double_array_external_function(function)¶
Shortcut for
create_double_array_external_function()
. Since
11.0
 Parameters
function – A python function that accepts a
LSExternalArgumentValues
as first argument and returns a double array value Returns
Expression of type
LSOperator.EXTERNAL_FUNCTION
. Return type
 LSModel.get_nb_expressions()¶
Returns the number of expressions added to this model.
You can also use the shortcut member
nb_expressions
 Returns
Number of expressions.
 Return type
int
 LSModel.get_expression(expr_index)¶
 localsolver.get_expression(expr_name)¶
Gets the expression with the given index or the given name in this model. Throws an exception if no expression with the given name or the given index exists.
You can also use the shortcut member
expressions
 Parameters
expr_index (
int
) – Index of the expressionexpr_name (
str
) – Name of the expression.
 Returns
Expression with the given index
 Return type
 LSModel.get_nb_decisions()¶
Gets the number of decisions in the model. This corresponds to the number of decision variables declared in the model.
You can also use the shortcut member
nb_decisions
 Returns
Number of decisions in the model.
 Return type
int
 LSModel.get_decision(decision_index)¶
Gets the decision with the given index.
You can also use the shortcut member
decisions
 Parameters
decision_index (
int
) – Index of the decision Returns
Decision with the given index
 Return type
 LSModel.add_constraint(expr)¶
Adds the given expression to the list of constraints. It means that the value of this expression must be constrained to be equal to 1 in any solution found by the solver. Hence, only boolean expressions (that is, expressions whose value is boolean) can be constrained. Only allowed in state
LSState.MODELING
. If the expression is already a constraint, this method does nothing and returns immediately. Parameters
expr (LSExpression) – Expression
 LSModel.constraint(expr)¶
Shortcut for
add_constraint()
.You can also use the shortcut member
constraints
 Parameters
expr (LSExpression) – Expression
 Since
5.5
 LSModel.remove_constraint(expr)¶
 LSModel.remove_constraint(constraint_index)
Removes the given expression from the list of constraints. If the expression was not constrained, this method does nothing and returns immediately. Only allowed in state
LSState.MODELING
. Parameters
expr (LSExpression) – Expression.
constraint_index (
int
) – Index of the constraint to remove.
 Since
5.0
 LSModel.get_nb_constraints()¶
Gets the number of constraints added to this model.
You can also use the shortcut member
nb_constraints
 Returns
Number of constraints
 Return type
int
 LSModel.get_constraint(index)¶
Gets the constraint with the given index.
 Parameters
index (
int
) – Index of the constraint Returns
Constraint with the given index.
 Return type
 LSModel.add_objective(expr, direction)¶
Adds the given expression to the list of objectives to optimize. A same expression can be added more than once. Only allowed in state
LSState.MODELING
. Note that the objectives will be optimized in the order in which they have been added to the model. It is useful for lexicographic multiobjective optimization, and more particularly for goal programming. Parameters
expr (LSExpression) – Expression
direction (LSObjectiveDirection) – Optimization direction of this objective
 LSModel.minimize(expr)¶
Shortcut for
add_objective(expr, LSObjectiveDirection.MINIMIZE)
. Parameters
expr (LSExpression) – Expression
 LSModel.maximize(expr)¶
Shortcut for
add_objective(expr, LSObjectiveDirection.MAXIMIZE)
. Parameters
expr (LSExpression) – Expression
 LSModel.remove_objective(obj_index)¶
Removes the objective at the given position in the list of objectives. Note that the objectives created after the removed one have their index decreased by 1. Phases are not modified when an objective is removed. It is the user’s responsibility to change the objective index of each phase to keep it coherent (with
LSPhase.set_optimized_objective()
or to disable it (withLSPhase.enabled
). Only allowed in stateLSState.MODELING
. Parameters
obj_index (
int
) – Position of the objective to remove. Since
5.0
 LSModel.get_nb_objectives()¶
Gets the number of objectives added to this model.
You can also use the shortcut member
nb_objectives
 Returns
Number of objectives
 Return type
int
 LSModel.get_objective(obj_index)¶
Gets the objective with the given index.
You can also use the shortcut member
objectives
 Parameters
obj_index (
int
) – Index of the objective Returns
Objective with the given index
 Return type
 LSModel.get_objective_direction(obj_index)¶
Gets the direction of the objective with the given index.
You can also use the shortcut member
objective_directions
 Parameters
obj_index (
int
) – Index of the objective Returns
Objective direction
 Return type
 LSModel.get_nb_operands()¶
Gets the number of operands in the model. This corresponds to the number of operands for all expressions declared in the model. It is an analog of the number of non zeros in matrix model encountered in mathematical programming: it gives an hint about the size and the density of your model.
You can also use the shortcut member
nb_operands
 Returns
Number of operands.
 Return type
int
 LSModel.close()¶
Closes the model. Only allowed in state
LSState.MODELING
. When this method is called, the solver is placed in stateLSState.STOPPED
.Once the model is closed, no expressions, constraints or objectives can be added or removed unless the model is reopened. The model must be closed before starting its resolution.
 LSModel.open()¶
Reopens the model. Only allowed in state
LSState.STOPPED
. When this method is called, the solver is placed in stateLSState.MODELING
.In this state, the model can be modified: it is possible to add new expressions, constraints or objectives, modify expression operands, and remove existing constraints and objectives. However, existing expressions cannot be deleted.
 LSModel.is_closed()¶
Returns true if the model is closed, false otherwise.
 Returns
True if the model is closed.
 Return type
bool
 LSModel.bool()¶
Creates a boolean decision. Binary decision variable with domain [0.1]. This method is a shortcut for
create_expression(LSOperator.BOOL)
. Since
5.5
 Returns
Expression of type
LSOperator.BOOL
 Return type
 LSModel.float(min, max)¶
Creates a float decision. Decision variable with domain
[min,max]
. This method is a shortcut forcreate_expression(LSOperator.FLOAT, min, max)
. Since
5.5
 Parameters
min (
int
orfloat
) – Lower bound of the decision variable.max (
int
orfloat
) – Upper bound of the decision variable.
 Returns
Expression of type
LSOperator.FLOAT
 Return type
 LSModel.int(min, max)¶
Creates an integer decision. Decision variable with domain
[min,max]
. This method is a shortcut forcreate_expression(LSOperator.INT, min, max)
. Since
5.5
 Parameters
min (
int
) – Lower bound of the decision variable.max (
int
) – Upper bound of the decision variable.
 Returns
Expression of type
LSOperator.INT
 Return type
 LSModel.interval(minStart, maxEnd)¶
Creates an interval decision included in
[minStart, maxEnd)
. Start is inclusive and end is exclusive. This method is a shortcut forcreate_expression(LSOperator.INTERVAL, minStart, maxEnd)
. Since
12.0
 Parameters
minStart (
int
) – Min start of the decision variable.maxEnd (
int
) – Max end of the decision variable.
 Returns
Expression of type
LSOperator.INTERVAL
 Return type
 LSModel.sum(operands)¶
 LSModel.sum(*operands)
Creates a sum expression. This method is a shortcut for
create_expression(LSOperator.SUM, operands)
.Any object that implements the
__iter__
method is accepted. Thus, lists, tuples, sets and their comprehensions counterpart are accepted. It is also possible to use this method with a variadic number of arguments. Each operand can be an LSExpression, a boolean, an integer or a double. Since
5.5
 Parameters
operands – Operands to add. An iterable or any number of arguments.
 Returns
Expression of type
LSOperator.SUM
 Return type
 LSModel.sub(op1, op2)¶
Creates a substraction expression. This method is a shortcut for
create_expression(LSOperator.SUB, op1, op2)
.Each operand can be an LSExpression, a boolean, an integer or a double.
 Since
5.5
 Parameters
op1 – Operand. Accepted types: LSExpression, boolean, integer or double.
op2 – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.SUB
 Return type
 LSModel.prod(operands)¶
 LSModel.prod(*operands)
Creates a product expression. This method is a shortcut for
create_expression(LSOperator.PROD, operands)
.Any object that implements the
__iter__
method is accepted. Thus, lists, tuples, sets and their comprehensions counterpart are accepted. It is also possible to use this method with a variadic number of arguments. Each operand can be an LSExpression, a boolean, an integer or a double. Since
5.5
 Parameters
operands – Operands to add. An iterable or any number of arguments.
 Returns
Expression of type
LSOperator.PROD
 Return type
 LSModel.max(operands)¶
 LSModel.max(*operands)
Creates a max expression. This method is a shortcut for
create_expression(LSOperator.MAX, operands)
.Any object that implements the
__iter__
method is accepted. Thus, lists, tuples, sets and their comprehensions counterpart are accepted. It is also possible to use this method with a variadic number of arguments. Each operand can be an LSExpression, a boolean, an integer or a double. Since
5.5
 Parameters
operands – Operands to add. An iterable or any number of arguments.
 Returns
Expression of type
LSOperator.MAX
 Return type
 LSModel.min(operands)¶
 LSModel.min(*operands)
Creates a min expression. This method is a shortcut for
create_expression(LSOperator.MIN, operands)
.Any object that implements the
__iter__
method is accepted. Thus, lists, tuples, sets and their comprehensions counterpart are accepted. It is also possible to use this method with a variadic number of arguments. Each operand can be an LSExpression, a boolean, an integer or a double. Since
5.5
 Parameters
operands – Operands to add. An iterable or any number of arguments.
 Returns
Expression of type
LSOperator.MIN
 Return type
 LSModel.or_(operands)¶
 LSModel.or_(*operands)
Creates a boolean or expression. This method is a shortcut for
create_expression(LSOperator.OR, operands)
.Any object that implements the
__iter__
method is accepted. Thus, lists, tuples, sets and their comprehensions counterpart are accepted. It is also possible to use this method with a variadic number of arguments. Each operand can be an LSExpression or a boolean. Since
5.5
 Parameters
operands – Operands to add. An iterable or any number of arguments.
 Returns
Expression of type
LSOperator.OR
 Return type
 LSModel.and_(operands)¶
 LSModel.and_(*operands)
Creates a boolean and expression. This method is a shortcut for
create_expression(LSOperator.AND, operands)
.Any object that implements the
__iter__
method is accepted. Thus, lists, tuples, sets and their comprehensions counterpart are accepted. It is also possible to use this method with a variadic number of arguments. Each operand can be an LSExpression or a boolean. Since
5.5
 Parameters
operands – Operands to add. An iterable or any number of arguments.
 Returns
Expression of type
LSOperator.AND
 Return type
 LSModel.xor(operands)¶
 LSModel.xor(*operands)
Creates a boolean xor expression. This method is a shortcut for
create_expression(LSOperator.XOR, operands)
.Any object that implements the
__iter__
method is accepted. Thus, lists, tuples, sets and their comprehensions counterpart are accepted. It is also possible to use this method with a variadic number of arguments. Each operand can be an LSExpression or a boolean. Since
5.5
 Parameters
operands – Operands to add. An iterable or any number of arguments.
 Returns
Expression of type
LSOperator.XOR
 Return type
 LSModel.not_(op)¶
Creates a boolean not expression. This method is a shortcut for
create_expression(LSOperator.NOT, operands)
.The operand can be an LSExpression or a boolean.
 Since
5.5
 Parameters
op – Operand. Accepted types: LSExpression or boolean.
 Returns
Expression of type
LSOperator.NOT
 Return type
 LSModel.eq(op1, op2)¶
Creates an equality expression. This method is a shortcut for
create_expression(LSOperator.EQ, op1, op2)
.Accepted operands are: LSExpressions, booleans, integers or doubles.
 Since
5.5
 Parameters
op1 – Operand. Accepted types: LSExpression, boolean, integer or double.
op2 – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.EQ
 Return type
 LSModel.neq(op1, op2)¶
Creates a disequality expression. This method is a shortcut for
create_expression(LSOperator.NEQ, op1, op2)
.Accepted operands are: LSExpressions, booleans, integers or doubles.
 Since
5.5
 Parameters
op1 – Operand. Accepted types: LSExpression, boolean, integer or double.
op2 – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.NEQ
 Return type
 LSModel.geq(op1, op2)¶
Creates an inequality ‘greater than or equal to’. This method is a shortcut for
create_expression(LSOperator.GEQ, op1, op2)
.Accepted operands are: LSExpressions, booleans, integers or doubles.
 Since
5.5
 Parameters
op1 – Operand. Accepted types: LSExpression, boolean, integer or double.
op2 – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.GEQ
 Return type
 LSModel.leq(op1, op2)¶
Creates an inequality ‘lower than or equal to’. This method is a shortcut for
create_expression(LSOperator.LEQ, op1, op2)
.Accepted operands are: LSExpressions, booleans, integers or doubles.
 Since
5.5
 Parameters
op1 – Operand. Accepted types: LSExpression, boolean, integer or double.
op2 – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.LEQ
 Return type
 LSModel.gt(op1, op2)¶
Creates an inequality ‘strictly greater than’. This method is a shortcut for
create_expression(LSOperator.GT, op1, op2)
.Accepted operands are: LSExpressions, booleans, integers or doubles.
 Since
5.5
 Parameters
op1 – Operand. Accepted types: LSExpression, boolean, integer or double.
op2 – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.GT
 Return type
 LSModel.lt(op1, op2)¶
Creates an inequality ‘strictly lower than’. This method is a shortcut for
create_expression(LSOperator.LT, op1, op2)
.Accepted operands are: LSExpressions, booleans, integers or doubles.
 Since
5.5
 Parameters
op1 – Operand. Accepted types: LSExpression, boolean, integer or double.
op2 – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.LT
 Return type
 LSModel.iif(op1, op2, op3)¶
Creates a ternary conditional operator. This method is a shortcut for
create_expression(LSOperator.IF, op1, op2, op3)
.The first operand must be an LSExpression with a boolean value or a boolean. The other operands can be LSExpressions, booleans, integers or doubles.
 Since
5.5
 Parameters
op1 – Operand. Accepted types: LSExpression with boolean value or boolean.
op2 – Operand. Accepted types: LSExpression, boolean, integer or double.
op3 – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.IF
 Return type
 LSModel.abs(op)¶
Creates an absolute value expression. This method is a shortcut for
create_expression(LSOperator.ABS, op)
.The operand can be an LSExpression, a boolean, an integer or a double.
 Since
5.5
 Parameters
op – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.ABS
 Return type
 LSModel.dist(op1, op2)¶
Creates a distance expression. This method is a shortcut for
create_expression(LSOperator.DIST, op1, op2)
.Accepted operands are: LSExpressions, booleans, integers or doubles.
 Since
5.5
 Parameters
op1 – Operand. Accepted types: LSExpression, boolean, integer or double.
op2 – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.DIST
 Return type
 LSModel.div(op1, op2)¶
Creates a division expression. This method is a shortcut for
create_expression(LSOperator.DIV, op1, op2)
.Accepted operands are: LSExpressions, booleans, integers or doubles.
 Since
5.5
 Parameters
op1 – Operand. Accepted types: LSExpression, boolean, integer or double.
op2 – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.DIV
 Return type
 LSModel.mod(op1, op2)¶
Creates a modulo expression. This method is a shortcut for
create_expression(LSOperator.MOD, op1, op2)
.Accepted operands are: LSExpressions with integer values, booleans, integers.
 Since
5.5
 Parameters
op1 – Operand. Accepted types: LSExpression with integer value, boolean or integer.
op2 – Operand. Accepted types: LSExpression with integer value, boolean or integer.
 Returns
Expression of type
LSOperator.MOD
 Return type
 LSModel.array(operands)¶
 LSModel.array(*operands)
Creates a new array. This method behaves as a shortcut for
create_expression(LSOperator.ARRAY, operands)
, but attempts to create an Ndimensional array in a recursive way: if an operand is iterable, it will be turned into an array too, and so on.Any object that implements the
__iter__
method is accepted. Thus, lists, tuples, sets and their comprehensions counterpart are accepted. It is also possible to use this method with a variadic number of arguments. Each operand can be an LSExpression, a boolean, an integer or a double. Since
5.5
 Parameters
operands – Operands to add. An iterable or any number of arguments.
 Returns
Expression of type
LSOperator.ARRAY
 Return type
 LSModel.at(array_expr, indices_expr)¶
 LSModel.at(array_expr, *indices_expr)
Creates a “at” expression. This method is a shortcut for
create_expression(LSOperator.AT, array_expr, indices_expr)
.The first operand must be an LSExpression with array or collection value. The second operand accepts any object that implements the
__iter__
method. Thus, lists, tuples, sets and their comprehensions counterpart are accepted. It is also possible to use this method with a variadic number of arguments. These operands must be LSExpressions with integer value, booleans or integers. Since
5.5
 Parameters
array_expr – Operand. Accepted types: LSExpression with array or collection value.
indices_expr – Operands for the indices. An iterable or any number of arguments.
 Returns
Expression of type
LSOperator.AT
 Return type
 LSModel.scalar(op1, op2)¶
Creates a scalar product between two arrays. This method is a shortcut for
create_expression(LSOperator.SCALAR, op1, op2)
.The operands must be LSExpressions of type
LSOperator.ARRAY
. Since
5.5
 Parameters
op1 – Operand. Accepted types: LSExpression with array value.
op2 – Operand. Accepted types: LSExpression with array value.
 Returns
Expression of type
LSOperator.SCALAR
 Return type
 LSModel.ceil(op)¶
Creates a ceil expression. This method is a shortcut for
create_expression(LSOperator.CEIL, op)
.The operand can be an LSExpression, a boolean, an integer or a double.
 Since
5.5
 Parameters
op – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.CEIL
 Return type
 LSModel.floor(op)¶
Creates a floor expression. This method is a shortcut for
create_expression(LSOperator.FLOOR, op)
.The operand can be an LSExpression, a boolean, an integer or a double.
 Since
5.5
 Parameters
op – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.FLOOR
 Return type
 LSModel.round(op)¶
Creates a round expression. This method is a shortcut for
create_expression(LSOperator.ROUND, op)
.The operand can be an LSExpression, a boolean, an integer or a double.
 Since
5.5
 Parameters
op – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.ROUND
 Return type
 LSModel.sqrt(op)¶
Creates a square root expression. This method is a shortcut for
create_expression(LSOperator.SQRT, op)
.The operand can be an LSExpression, a boolean, an integer or a double.
 Since
5.5
 Parameters
op – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.SQRT
 Return type
 LSModel.log(op)¶
Creates a natural log expression. This method is a shortcut for
create_expression(LSOperator.LOG, op)
.The operand can be an LSExpression, a boolean, an integer or a double.
 Since
5.5
 Parameters
op – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.LOG
 Return type
 LSModel.exp(op)¶
Creates an exponential expression. This method is a shortcut for
create_expression(LSOperator.EXP, op)
.The operand can be an LSExpression, a boolean, an integer or a double.
 Since
5.5
 Parameters
op – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.EXP
 Return type
 LSModel.pow(op1, op2)¶
Creates a power expression. This method is a shortcut for
create_expression(LSOperator.POW, op1, op2)
.Accepted operands are: LSExpressions, booleans, integers or doubles.
 Since
5.5
 Parameters
op1 – Operand. Accepted types: LSExpression, boolean, integer or double.
op2 – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.POW
 Return type
 LSModel.cos(op)¶
Creates a cosine expression. This method is a shortcut for
create_expression(LSOperator.COS, op)
.The operand can be an LSExpression, a boolean, an integer or a double.
 Since
5.5
 Parameters
op – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.COS
 Return type
 LSModel.sin(op)¶
Creates a sine expression. This method is a shortcut for
create_expression(LSOperator.SIN, op)
.The operand can be an LSExpression, a boolean, an integer or a double.
 Since
5.5
 Parameters
op – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.SIN
 Return type
 LSModel.tan(op)¶
Creates a tangent expression. This method is a shortcut for
create_expression(LSOperator.TAN, op)
.The operand can be an LSExpression, a boolean, an integer or a double.
 Since
5.5
 Parameters
op – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.TAN
 Return type
 LSModel.piecewise(op1, op2, op3)¶
Creates a piecewise linear expression. This method is a shortcut for
create_expression(LSOperator.PIECEWISE, op1, op2, op3)
.The first and the second operands must be LSExpressions of type
LSOperator.ARRAY
. The third argument must be an LSExpression, a boolean, an integer or a double. Since
5.5
 Parameters
op1 – Operand. Accepted types: LSExpression of type
LSOperator.ARRAY
op2 – Operand. Accepted types: LSExpression of type
LSOperator.ARRAY
op3 – Operand. Accepted types: LSExpression, boolean, integer or double.
 Returns
Expression of type
LSOperator.PIECEWISE
 Return type
 LSModel.list(n)¶
Creates a list decision with the given length. A list is an ordered collection of integers within a domain [0, n1]. This method is a shortcut for
create_expression(LSOperator.LIST, n)
. Since
5.5
 Parameters
n (
bool
orint
) – Collection size.
 LSModel.set(n)¶
Creates a set decision with the given length. A set is an unordered collection of integers within a domain [0, n1]. This method is a shortcut for
create_expression(LSOperator.SET, n)
. Since
8.0
 Parameters
n (
bool
orint
) – Collection size. Accepted types:bool
orint
.
 LSModel.start(op)¶
Creates a start expression. This method is a shortcut for
create_expression(LSOperator.START, op)
.The operand must be an LSExpression with interval value.
 Since
12.0
 Parameters
op – Operand. Accepted type:
LSExpression
with interval value. Returns
Expression of type
LSOperator.START
 Return type
 LSModel.end(op)¶
Creates an end expression. This method is a shortcut for
create_expression(LSOperator.END, op)
.The operand must be an LSExpression with interval value.
 Since
12.0
 Parameters
op – Operand. Accepted type:
LSExpression
with interval value. Returns
Expression of type
LSOperator.END
 Return type
 LSModel.length(op)¶
Creates a length expression. This method is a shortcut for
create_expression(LSOperator.LENGTH, op)
.The operand must be an LSExpression with interval value.
 Since
12.0
 Parameters
op – Operand. Accepted type:
LSExpression
with interval value. Returns
Expression of type
LSOperator.LENGTH
 Return type
 LSModel.count(op)¶
Creates a count expression. This method is a shortcut for
create_expression(LSOperator.COUNT, op)
.The operand must be an LSExpression with array, collection or interval value.
 Since
5.5
 Parameters
op – Operand. Accepted type:
LSExpression
with array, collection or interval value. Returns
Expression of type
LSOperator.COUNT
 Return type
 LSModel.index(op1, op2)¶
Creates an indexOf expression. This method is a shortcut for
create_expression(LSOperator.INDEXOF, op1, op2)
.The first operand must be an LSExpression with list value. The second operand must be an LSExpression with integer value, an integer or a boolean.
 Since
5.5
 Parameters
op1 – Operand. Accepted type:
LSExpression
with list value.op2 – Operand. Accepted type:
LSExpression
or integer.
 Returns
Expression of type
LSOperator.INDEXOF
 Return type
 LSModel.distinct(operands)¶
Creates a distinct expression. This method is a shortcut for
create_expression(LSOperator.DISTINCT, operands)
.This operator accepts one or two operands. If one operand is passed, the operand must be an LSExpression with onedimensional array value. If two operands are passed, the first one must be an LSExpression with collection (list or set), interval or range value, and the second must be an LSExpression with lambda function value.
 Since
12.5
 Parameters
operands – Operands (1 or 2). Accepted type:
LSExpression
. Returns
Expression of type
LSOperator.DISTINCT
 Return type
 LSModel.intersection(op1, op2)¶
Creates an intersection expression. This method is a shortcut for
create_expression(LSOperator.INTERSECTION, op1, op2)
.The first operand must be an LSExpression with collection or array value. The second operand must be an LSExpression with collection or array value.
 Since
12.5
 Parameters
op1 – Operand. Accepted type:
LSExpression
with collection or array value.op2 – Operand. Accepted type:
LSExpression
with collection or array value.
 Returns
Expression of type
LSOperator.INTERSECTION
 Return type
 LSModel.contains(op1, op2)¶
Creates a contains expression. This method is a shortcut for
create_expression(LSOperator.CONTAINS, op1, op2)
.The first operand must be an LSExpression with collection, interval or array value. The second operand must be an LSExpression with integer or double value, an integer, a boolean or a double.
 Since
7.5
 Parameters
op1 – Operand. Accepted type:
LSExpression
with collection, interval or array value.op2 – Operand. Accepted type:
LSExpression
or integer or double.
 Returns
Expression of type
LSOperator.CONTAINS
 Return type
 LSModel.partition(operands)¶
 LSModel.partition(*operands)
Creates a partition expression. This method is a shortcut for
create_expression(LSOperator.PARTITION, operands)
.Any object that implements the
__iter__
method is accepted. Thus, lists, tuples, sets and their comprehensions counterpart are accepted. It is also possible to use this method with a variadic number of arguments. Each operand must be an LSExpression with collection value. Since
5.5
 Parameters
operands – Operands to add. An iterable or any number of arguments.
 Returns
Expression of type
LSOperator.PARTITION
 Return type
 LSModel.disjoint(operands)¶
 LSModel.disjoint(*operands)
Creates a disjoint expression. This method is a shortcut for
create_expression(LSOperator.DISJOINT, operands)
.Any object that implements the
__iter__
method is accepted. Thus, lists, tuples, sets and their comprehensions counterpart are accepted. It is also possible to use this method with a variadic number of arguments. Each operand must be an LSExpression with collection value. Since
5.5
 Parameters
operands – Operands to add. An iterable or any number of arguments.
 Returns
Expression of type
LSOperator.DISJOINT
 Return type
 LSModel.cover(operands)¶
 LSModel.cover(*operands)
Creates a cover expression. This method is a shortcut for
create_expression(LSOperator.COVER, operands)
.Any object that implements the
__iter__
method is accepted. Thus, lists, tuples, sets and their comprehensions counterpart are accepted. It is also possible to use this method with a variadic number of arguments. Each operand must be an LSExpression with collection value. Since
10.5
 Parameters
operands – Operands to add. An iterable or any number of arguments.
 Returns
Expression of type
LSOperator.COVER
 Return type
 LSModel.find(op1, op2)¶
Creates a find expression. This method is a shortcut for
create_expression(LSOperator.FIND, op1, op2)
.The first operand must be an LSExpression with array value. The second operand must be an LSExpression with integer value, an integer or a boolean.
 Since
10.5
 Parameters
op1 – Operand. Accepted type:
LSExpression
with array value.op2 – Operand. Accepted type:
LSExpression
or integer.
 Returns
Expression of type
LSOperator.FIND
 Return type
 LSModel.sort(op1[, op2])¶
Creates a sort expression. This method is a shortcut for
create_expression(LSOperator.SORT, op1 [, op2])
.The first operand must be an LSExpression representing a onedimensional array containing integers or doubles. The second argument is optional and, if specified, must be an LSExpression with lambda function value.
 Since
11.0
 Parameters
op1 – Operand. Accepted type:
LSExpression
with array value.op2 – Operand. Accepted type:
LSExpression
with lambda function value.
 Returns
Expression of type
LSOperator.SORT
 Return type
 LSModel.call(operands)¶
 LSModel.call(*operands)
Creates a call expression. This method is a shortcut for
create_expression(LSOperator.CALL, operands)
.The first operand must be an LSExpression of type
LSOperator.LAMBDA_FUNCTION
orLSOperator.EXTERNAL_FUNCTION
. The second operand accepts any object that implements the__iter__
method. Thus, lists, tuples, sets and their comprehensions counterpart are accepted. It is also possible to use this method with a variadic number of arguments. These operands may be LSExpressions, booleans, integers, and doubles. They are passed to the function as arguments. Since
6.0
 Parameters
operands – Operands to add. An iterable or any number of arguments.
 Returns
Expression of type
LSOperator.CALL
 Return type
 LSModel.range([op1, ]op2)¶
Creates a range expression. op1 is the lower bound (inclusive) and op2 is the upper bound (exclusive). When only one operand is used, the lower bound is 0. This method is a shortcut for
create_expression(LSOperator.RANGE, op1, op2)
. Since
7.0
 Parameters
op1 – Operand. Accepted types: LSExpression with integer value, boolean or integer.
op2 – Operand. Accepted types: LSExpression with integer value, boolean or integer.
 Returns
Expression of type
LSOperator.RANGE
 Return type
Instance attributes¶
All get/set
methods have their attribute counterpart. You can use them as
shortcuts to improve the readability or your models and codes.
 LSModel.nb_expressions¶
Number of expressions in this model. This attribute is readonly. It is a shortcut for
get_nb_expressions()
.
 LSModel.nb_operands¶
Number of operands in this model. This attribute is readonly. It is a shortcut for
get_nb_operands()
.
 LSModel.nb_objectives¶
Number of objectives in this model. This attribute is readonly. It is a shortcut for
get_nb_objectives()
.
 LSModel.nb_constraints¶
Number of constraints in this model. This attribute is readonly. It is a shortcut for
get_nb_constraints()
.
 LSModel.nb_decisions¶
Number of decisions in this model. This attribute is readonly. It is a shortcut for
get_nb_decisions()
.
 LSModel.expressions¶
List of the expressions of the model. This attribute is readonly. The returned object is iterable, supports the
len
function and can be indexed with integers. It is a shortcut forget_expression()
andget_nb_expressions()
methods.
 LSModel.decisions¶
List of the decisions of the model. This attribute is readonly. The returned object is iterable, supports the
len
function and can be indexed with integers. It is a shortcut forget_decision()
andget_nb_decisions()
methods.
 LSModel.objectives¶
List of the objectives of the model. This attribute is readonly. The returned object is iterable, supports the
len
function and can be indexed with integers. It is a shortcut forget_objective()
andget_nb_objectives()
methods.
 LSModel.objective_directions¶
List of the objective directions of the model. This attribute is readonly. The returned object is iterable, supports the
len
function and can be indexed with integers. It is a shortcut forget_objective_direction()
andget_nb_objectives()
methods.
 LSModel.constraints¶
List of the constraints of the model. This attribute is readonly. The returned object is iterable, supports the
len
function and can be indexed with integers. It is a shortcut forget_constraint()
andget_nb_constraints()
methods.
Special operators and methods¶
 LSModel.__str__()¶
Returns a string representation of this model. This representation provides:
The number of expressions, decisions, constraints, and objectives.
The density of the model.
Useful for debugging or logging purposes.
 Returns
String representation of this model.
 Return type
str