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¶
nb_expressions 
Number of expressions in this model. 
nb_operands 
Number of operands in this model. 
nb_objectives 
Number of objectives in this model. 
nb_constraints 
Number of constraints in this model. 
nb_decisions 
Number of decisions in this model. 
expressions 
List of the expressions of the model. 
decisions 
List of the decisions of the model. 
objectives 
List of the objectives of the model. 
objective_directions 
List of the objective directions of the model. 
constraints 
List of the constraints of the model. 
create_constant 
Creates a constant expression representing the given value. 
create_expression 
Creates a new expression of the given type with the given operands. 
create_lambda_function 
Creates a lambda function with arguments. 
lambda_function 
Shortcut for create_lambda_function(). 
create_int_external_function 
Creates an integer external function. 
int_external_function 
Shortcut for create_int_external_function(). 
create_double_external_function 
Creates a double external function. 
double_external_function 
Shortcut for create_double_external_function(). 
create_double_blackbox_function 
Creates a double blackbox function. 
double_blackbox_function 
Shortcut for create_double_blackbox_function(). 
get_nb_expressions 
Returns the number of expressions added to this model. 
get_expression 
Gets the expression with the given index or the given name in this model. 
get_nb_decisions 
Gets the number of decisions in the model. 
get_decision 
Gets the decision with the given index. 
add_constraint 
Adds the given expression to the list of constraints. 
constraint 
Shortcut for add_constraint(). 
remove_constraint 
Removes the given expression from the list of constraints. 
get_nb_constraints 
Gets the number of constraints added to this model. 
get_constraint 
Gets the constraint with the given index. 
add_objective 
Adds the given expression to the list of objectives to optimize. 
minimize 
Shortcut for add_objective(expr, LSObjectiveDirection.MINIMIZE). 
maximize 
Shortcut for add_objective(expr, LSObjectiveDirection.MAXIMIZE). 
remove_objective 
Removes the objective at the given position in the list of objectives. 
get_nb_objectives 
Gets the number of objectives added to this model. 
get_objective 
Gets the objective with the given index. 
get_objective_direction 
Gets the direction of the objective with the given index. 
get_nb_operands 
Gets the number of operands in the model. 
close 
Closes the model. 
open 
Reopens the model. 
is_closed 
Returns true if the model is closed, false otherwise. 
bool 
Creates a boolean decision. 
float 
Creates a float decision. 
int 
Creates an integer decision. 
sum 
Creates a sum expression. 
sub 
Creates a substraction expression. 
prod 
Creates a product expression. 
max 
Creates a max expression. 
min 
Creates a min expression. 
or_ 
Creates a boolean or expression. 
and_ 
Creates a boolean and expression. 
xor 
Creates a boolean xor expression. 
not_ 
Creates a boolean not expression. 
eq 
Creates an equality expression. 
neq 
Creates a disequality expression. 
geq 
Creates an inequality ‘greater than or equal to’. 
leq 
Creates an inequality ‘lower than or equal to’. 
gt 
Creates an inequality ‘strictly greater than’. 
lt 
Creates an inequality ‘strictly lower than’. 
iif 
Creates a ternary conditional operator. 
abs 
Creates an absolute value expression. 
dist 
Creates a distance expression. 
div 
Creates a division expression. 
mod 
Creates a modulo expression. 
array 
Creates a new array. 
at 
Creates a “at” expression. 
scalar 
Creates a scalar product between two arrays. 
ceil 
Creates a ceil expression. 
floor 
Creates a floor expression. 
round 
Creates a round expression. 
sqrt 
Creates a square root expression. 
log 
Creates a natural log expression. 
exp 
Creates an exponential expression. 
pow 
Creates a power expression. 
cos 
Creates a cosine expression. 
sin 
Creates a sine expression. 
tan 
Creates a tangent expression. 
piecewise 
Creates a piecewise linear expression. 
list 
Creates a list decision with the given length. 
set 
Creates a set decision with the given length. 
count 
Creates a count expression. 
index 
Creates an indexOf expression. 
contains 
Creates a contains expression. 
partition 
Creates a partition expression. 
disjoint 
Creates a disjoint expression. 
call 
Creates a call expression. 
range 
Creates a range expression. 
__str__ 
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: LSExpression

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: LSExpression  The arguments of the function (which are also LSExpressions of 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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

LSModel.
create_double_blackbox_function
(function)¶ Creates a double blackbox function. The provided function must take a (
LSBlackBoxArgumentValues
) as single argument and must return a double value. When the blackbox function is called, the argument values will be made accessible to your function through theLSBlackBoxArgumentValues
.Once you have instantiated it, you have to use
call()
to call it in your model.Note: You can provide additional data and parameters for your function (such as bounds or the maximum number of evaluations) with the help of the
LSBlackBoxContext
associated with your function (seeLSExpression.get_blackbox_context()
).Since: 9.5 Parameters: function – A python function that accepts a LSBlackBoxArgumentValues
as first argument and returns a double value.Returns: Expression of type LSOperator.BLACKBOX_FUNCTION
.Return type: LSExpression

LSModel.
double_blackbox_function
(function)¶ Shortcut for
create_double_blackbox_function()
.Since: 9.5 Parameters: function – A python function that accepts a LSBlackBoxArgumentValues
as first argument and returns a double valueReturns: Expression of type LSOperator.BLACKBOX_FUNCTION
.Return type: LSExpression

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 expression  expr_name (
str
) – Name of the expression.
Returns: Expression with the given index
Return type:  expr_index (

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 decisionReturns: Decision with the given index Return type: LSExpression

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.Try to avoid hard constraints as much as possible, because LocalSolver (and more generally local search) is not suited for solving hardly constrained problems. In particular, banish constraints that are not surely satisfied in practice. Ideally, only combinatorial constraints (which induce the combinatorial structure of your problem) have to be set. All the other constraints can be relaxed as primary objectives in order to be “softly” satisfied (goal programming). For instance, constraint a <= b can be transformed into minimize max(ba, 0).
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 constraintReturns: Constraint with the given index. Return type: LSExpression

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 objectiveReturns: Objective with the given index Return type: LSExpression

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 objectiveReturns: Objective direction Return type: LSObjectiveDirection

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: LSExpression

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:  min (

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:  min (

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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: LSExpression

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:  op1 – Operand. Accepted types: LSExpression of 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 – Collection size. Accepted types: bool
orint
.

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 – Collection size. Accepted types: bool
orint
.

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 collection value.
Since: 5.5 Parameters: op – Operand. Accepted type: LSExpression
with collection value.Returns: Expression of type LSOperator.COUNT
Return type: LSExpression

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:  op1 – Operand. Accepted 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 value. The second operand must be an LSExpression with integer value, an integer or a boolean.
Since: 7.5
Parameters:  op1 – Operand. Accepted type:
LSExpression
with collection value.  op2 – Operand. Accepted type:
LSExpression
or integer.
Returns: Expression of type
LSOperator.CONTAINS
Return type:  op1 – Operand. Accepted 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: LSExpression

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: LSExpression

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.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: LSExpression

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