LSModel Class¶

class localsolver::LSModel¶

Mathematical optimization model.

A model is composed of expressions (some of which are decisions), organized as a tree. 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 resolve 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.

See:	LSExpression LSOperator

Summary¶

Functions¶
`createConstant`	Creates a constant expression representing the given value.
`createExpression`	Creates an expression of the given type, with the given ordered operands.
`createNativeFunction`	Creates a native function.
`createFunction`	Creates a function.
`boolVar`	Creates a boolean decision.
`floatVar`	Creates a float decision.
`intVar`	Creates an integer decision.
`sum`	Creates a sum expression.
`sub`	Creates a substraction expression.
`call`	Creates a call expression.
`prod`	Creates a product expression.
`max`	Creates a maximum expression.
`min`	Creates a minimum expression.
`or_`	Creates a OR expression.
`and_`	Creates an AND expression.
`xor_`	Creates a XOR expression.
`not_`	Creates a NOT expression.
`eq`	Creates an equality expression.
`neq`	Creates a disequality expression.
`geq`	Creates an inequality expression greater than or equal to.
`leq`	Creates an inequality expression less than or equal to.
`gt`	Creates an inequality expression greater than.
`lt`	Creates an inequality expression less than.
`iif`	Creates a ternary conditional expression.
`abs`	Creates an absolute value expression.
`dist`	Creates a distance expression.
`div`	Creates a division expression.
`mod`	Creates a modulo expression.
`array`	Creates an array expression.
`at`	Creates a “at” expression for N-dimensional array.
`scalar`	Creates an expression for the scalar product between two arrays.
`ceil`	Creates a ceil expression.
`floor`	Creates a floor expression.
`round`	Creates a rounding expression.
`sqrt`	Creates a square root expression.
`log`	Creates a 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.
`listVar`	Creates a list decision with the given length.
`count`	Creates a count expression.
`indexOf`	Creates an indexOf expression.
`partition`	Creates a partition expression.
`disjoint`	Creates a disjoint expression.
`nativeFunction`	Creates a native function expression.
`function`	Creates a function expression.
`range`	Creates a range expression.
`getNbExpressions`	Gets the number of expressions added to this model.
`getExpression`	Gets the expression with the given index in this model.
`getNbDecisions`	Gets the number of decisions in the model.
`getDecision`	Gets the decision with the given index.
`addConstraint`	Adds the given expression to the list of constraints.
`constraint`	Shortcut for addConstraint(expr).
`removeConstraint`	Removes the given expression from the list of constraints.
`getNbConstraints`	Gets the number of constraints added to this model.
`getConstraint`	Gets the constraint with the given index.
`addObjective`	Adds the given expression to the list of objectives to optimize.
`minimize`	Shortcut for addObjective(expr, OD_Minimize).
`maximize`	Shortcut for addObjective(expr, OD_Maximize).
`removeObjective`	Removes the objective at the given position in the list of objectives.
`getNbObjectives`	Gets the number of objectives added to this model.
`getObjective`	Gets the objective with the given index.
`getObjectiveDirection`	Gets the direction of the objective with the given index.
`getNbOperands`	Gets the number of operands in the model.
`close`	Closes the model.
`open`	Opens or reopens the model.
`isClosed`	Returns true if the model is closed, false otherwise.
`toString`	Returns a string representation of this model.

Functions¶

LSExpression createConstant(lsint value)¶

Creates a constant expression representing the given value.

Only allowed in state S_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.

Return:	Created constant expression.
Parameters:	value - Value of the constant.

LSExpression createConstant(lsdouble value)¶

Creates a constant expression representing the given value.

Only allowed in state S_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.

Return:	Created constant expression.
Parameters:	value - Value of the constant

template <typename... TN>

LSExpression createExpression(LSOperator op, TN... operands)¶

Creates an expression of the given type, with the given ordered operands.

Only allowed in state S_Modeling. The operands can be doubles, integers or previously declared LSExpressions. It is also possible to use this method with iterators. In that case, you have to call this method with 2 operands exactly that must be iterators of the same type, pointing respectively to the initial and final positions of the operands.

Return:	Created expression.
Templates:	TN - types of the operands to add. Types allowed: constant types, LSExpression or iterators.
Parameters:	op - Type of expression to create. operands - Operands.

LSExpression createNativeFunction(LSNativeFunction *func)¶

Creates a native function.

Once you instanciated it, you have to pass arguments to your function and call it. For that, you have to create expressions of type O_Call. The first operand must be your native function. The other operands must be LSExpressions. Their value will be made accessible to your native function through the native context.

Note 1: Most of the time your native function will be called when the solver is in state S_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 is LocalSolver#stop().

Note 2: Your functions must be thread-safe. According to the “nbThreads” parameter, LocalSolver can be multi-threaded. In that case, your native functions must be thread safe. If you cannot guarantee the thread-safety of your code, we strongly recommend you to limit the search of LocalSolver to one thread with LSParam#setNbThreads.

Note 3: LocalSolver do not manage memory of objects created outside of its environment. Thus, you have to explicitely delete your LSNativeFunction at the end of the search.

Return:	The expression associated to the function.
See:	O_NativeFunction
Since:	6.0
Parameters:	func - Native function to call.

template <typename A>

LSExpression createFunction(const A &functor)¶

Creates a function.

A function is a particular expression composed of two parts:

The arguments of the function (which are also LSExpressions of type O_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.

You have to provide the body of the function as a std::function (C++ function or lambda). Please note that the provided std::function will not be used directly during the solving process, but will be evaluated once by the API with a number of LSExpression of type O_Argument that corresponds to the number of arguments your std::function expects. The returned LSExpression resulting of this evaluation will be used as the body of the LocalSolver function O_Function.

LSExpression boolVar()¶

Creates a boolean decision.

Binary decision variable with domain { 0, 1 }. This method is a shortcut for createExpression(O_Bool).

See: