ExpressionsBasedModel (ojAlgo 47.2.0 API)

java.lang.Object
- org.ojalgo.optimisation.ExpressionsBasedModel

All Implemented Interfaces:

Optimisation, Optimisation.Model
```
public final class ExpressionsBasedModel
extends Object
```
Lets you construct optimisation problems by combining (mathematical) expressions in terms of variables. Each expression or variable can be a constraint and/or contribute to the objective function. An expression or variable is turned into a constraint by setting a lower and/or upper limit. Use ModelEntity.lower(Number), ModelEntity.upper(Number) or ModelEntity.level(Number). An expression or variable is made part of (contributing to) the objective function by setting a contribution weight. Use ModelEntity.weight(Number).

You may think of variables as simple (the simplest possible) expressions, and of expressions as weighted combinations of variables. They are both model entities and it is as such they can be turned into constraints and set to contribute to the objective function. Alternatively you may choose to disregard the fact that variables are model entities and simply treat them as index values. In this case everything (constraints and objective) needs to be defined using expressions.

Basic instructions:
1. Define (create) a set of variables. Set contribution weights and lower/upper limits as needed.
2. Create a model using that set of variables.
3. Add expressions to the model. The model is the expression factory. Set contribution weights and lower/upper limits as needed.
4. Solve your problem using either minimise() or maximise()
When using this class you do not need to worry about which solver will actually be used. The docs of the various solvers describe requirements on input formats and similar. This is handled for you and should absolutely NOT be considered here! Compared to using the various solvers directly this class actually does something for you:
1. You can model your problems without worrying about specific solver requirements.
2. It knows which solver to use.
3. It knows how to use that solver.
4. It has a presolver that tries to simplify the problem before invoking a solver (sometimes it turns out there is no need to invoke a solver at all).
5. When/if needed it scales problem parameters, before creating solver specific data structures, to minimize numerical problems in the solvers.
6. It's the only way to access the integer solver.
Different solvers can be used, and ojAlgo comes with collection built in. The default built-in solvers can handle anythimng you can model with a couple of restrictions:
- No quadratic constraints (The plan is that future versions should not have this limitation.)
- If you use quadratic expressions make sure they're convex. This is most likely a requirement even with 3:d party solvers.
Author:

apete

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ExpressionsBasedModel.Integration<S extends Optimisation.Solver>`
`static class`	`ExpressionsBasedModel.Intermediate`
`static class`	`ExpressionsBasedModel.Presolver`

Nested classes/interfaces inherited from interface org.ojalgo.optimisation.Optimisation
Optimisation.Constraint, Optimisation.Model, Optimisation.Objective, Optimisation.Options, Optimisation.Result, Optimisation.Solver, Optimisation.State

Field Summary

Fields
Modifier and Type Field and Description

Optimisation.Options options

Fields
Modifier and Type	Field and Description
`Optimisation.Options`	`options`

Constructor Summary

Constructors
Constructor and Description
`ExpressionsBasedModel()`
`ExpressionsBasedModel(Collection<? extends Variable> variables)`
`ExpressionsBasedModel(Optimisation.Options someOptions)`
`ExpressionsBasedModel(Variable... variables)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`Expression`	`addExpression()`
`Expression`	`addExpression(String name)`
`static boolean`	`addFallbackSolver(ExpressionsBasedModel.Integration<?> integration)`
`static boolean`	`addIntegration(ExpressionsBasedModel.Integration<?> integration)` Deprecated. v48 Use either `addPreferredSolver(Integration)` or `addFallbackSolver(Integration)` instead
`static boolean`	`addPreferredSolver(ExpressionsBasedModel.Integration<?> integration)`
`static boolean`	`addPresolver(ExpressionsBasedModel.Presolver presolver)`
`void`	`addSpecialOrderedSet(Collection<Variable> orderedSet, int type, Expression linkedTo)` Creates a special ordered set (SOS) presolver instance and links that to the supplied expression.
`void`	`addSpecialOrderedSet(Collection<Variable> orderedSet, int min, int max)` Calling this method will create 2 things: A simple expression meassuring the sum of the (binary) variable values (the number of binary variables that are "ON").
`Variable`	`addVariable()`
`Variable`	`addVariable(String name)`
`void`	`addVariable(Variable variable)`
`void`	`addVariables(Collection<? extends Variable> variables)`
`void`	`addVariables(Variable[] variables)`
`Stream<Variable>`	`bounds()`
`static void`	`clearIntegrations()`
`static void`	`clearPresolvers()`
`Stream<Expression>`	`constraints()`
`ExpressionsBasedModel`	`copy()`
`int`	`countExpressions()`
`int`	`countVariables()`
`void`	`dispose()` Cleanup when a model instance is no longer needed.
`Expression`	`generateCut(Expression constraint, Optimisation.Result solution)`
`Expression`	`getExpression(String name)`
`Collection<Expression>`	`getExpressions()`
`Set<Structure1D.IntIndex>`	`getFixedVariables()`
`List<Variable>`	`getFreeVariables()`
`List<Variable>`	`getIntegerVariables()`
`List<Variable>`	`getNegativeVariables()`
`List<Variable>`	`getPositiveVariables()`
`Variable`	`getVariable(int index)`
`Variable`	`getVariable(Structure1D.IntIndex index)`
`List<Variable>`	`getVariables()`
`Optimisation.Result`	`getVariableValues()`
`Optimisation.Result`	`getVariableValues(NumberContext validationContext)` Null variable values are replaced with 0.0.
`int`	`indexOf(Variable variable)`
`int`	`indexOfFreeVariable(int globalIndex)`
`int`	`indexOfFreeVariable(Structure1D.IntIndex variableIndex)`
`int`	`indexOfFreeVariable(Variable variable)`
`int`	`indexOfIntegerVariable(int globalIndex)`
`int`	`indexOfIntegerVariable(Structure1D.IntIndex variableIndex)`
`int`	`indexOfIntegerVariable(Variable variable)`
`int`	`indexOfNegativeVariable(int globalIndex)`
`int`	`indexOfNegativeVariable(Structure1D.IntIndex variableIndex)`
`int`	`indexOfNegativeVariable(Variable variable)`
`int`	`indexOfPositiveVariable(int globalIndex)`
`int`	`indexOfPositiveVariable(Structure1D.IntIndex variableIndex)`
`int`	`indexOfPositiveVariable(Variable variable)`
`boolean`	`isAnyConstraintQuadratic()`
`boolean`	`isAnyExpressionQuadratic()` Deprecated. v45 Use `isAnyConstraintQuadratic()` or `isAnyObjectiveQuadratic()` instead
`boolean`	`isAnyObjectiveQuadratic()`
`boolean`	`isAnyVariableFixed()`
`boolean`	`isAnyVariableInteger()`
`boolean`	`isMaximisation()`
`boolean`	`isMinimisation()`
`boolean`	`isWorkCopy()`
`void`	`limitObjective(BigDecimal lower, BigDecimal upper)`
`Optimisation.Result`	`maximise()`
`Optimisation.Result`	`minimise()`
`Expression`	`objective()` This is generated on demend – you should not cache this.
`ExpressionsBasedModel.Intermediate`	`prepare()` The general recommendation is to NOT call this method directly.
`ExpressionsBasedModel`	`relax(boolean inPlace)`
`static boolean`	`removeIntegration(ExpressionsBasedModel.Integration<?> integration)`
`static boolean`	`removePresolver(ExpressionsBasedModel.Presolver presolver)`
`void`	`setMaximisation()`
`protected void`	`setMaximisation(boolean maximisation)`
`void`	`setMinimisation()`
`protected void`	`setMinimisation(boolean minimisation)`
`ExpressionsBasedModel`	`simplify()`
`ExpressionsBasedModel`	`snapshot()`
`String`	`toString()`
`boolean`	`validate()` This methods validtes model construction only.
`boolean`	`validate(Access1D<BigDecimal> solution)`
`boolean`	`validate(Access1D<BigDecimal> solution, BasicLogger.Printer appender)`
`boolean`	`validate(Access1D<BigDecimal> solution, NumberContext context)`
`boolean`	`validate(Access1D<BigDecimal> solution, NumberContext context, BasicLogger.Printer appender)`
`boolean`	`validate(BasicLogger.Printer appender)`
`boolean`	`validate(NumberContext context)`
`boolean`	`validate(NumberContext context, BasicLogger.Printer appender)`
`Stream<Variable>`	`variables()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - options
```
public final Optimisation.Options options
```
- Constructor Detail
  - ExpressionsBasedModel
```
public ExpressionsBasedModel()
```
  - ExpressionsBasedModel
```
public ExpressionsBasedModel(Collection<? extends Variable> variables)
```
  - ExpressionsBasedModel
```
public ExpressionsBasedModel(Optimisation.Options someOptions)
```
  - ExpressionsBasedModel
```
public ExpressionsBasedModel(Variable... variables)
```
- Method Detail
  - addFallbackSolver
```
public static boolean addFallbackSolver(ExpressionsBasedModel.Integration<?> integration)
```
  - addIntegration
```
@Deprecated
public static boolean addIntegration(ExpressionsBasedModel.Integration<?> integration)
```
    Deprecated. v48 Use either addPreferredSolver(Integration) or addFallbackSolver(Integration) instead
  - addPreferredSolver
```
public static boolean addPreferredSolver(ExpressionsBasedModel.Integration<?> integration)
```
  - addPresolver
```
public static boolean addPresolver(ExpressionsBasedModel.Presolver presolver)
```
  - clearIntegrations
```
public static void clearIntegrations()
```
  - clearPresolvers
```
public static void clearPresolvers()
```
  - removeIntegration
```
public static boolean removeIntegration(ExpressionsBasedModel.Integration<?> integration)
```
  - removePresolver
```
public static boolean removePresolver(ExpressionsBasedModel.Presolver presolver)
```
  - addExpression
```
public Expression addExpression()
```
  - addExpression
```
public Expression addExpression(String name)
```
  - addSpecialOrderedSet
```
public void addSpecialOrderedSet(Collection<Variable> orderedSet,
                                 int type,
                                 Expression linkedTo)
```
    Creates a special ordered set (SOS) presolver instance and links that to the supplied expression. When/if the presolver concludes that the SOS "constraints" are not possible the linked expression is marked as infeasible.
  - addSpecialOrderedSet
```
public void addSpecialOrderedSet(Collection<Variable> orderedSet,
                                 int min,
                                 int max)
```
    Calling this method will create 2 things:
    1. A simple expression meassuring the sum of the (binary) variable values (the number of binary variables that are "ON"). The upper, and optionally lower, limits are set as defined by the max and min parameter values.
    2. A custom presolver (specific to this SOS) to be used by the MIP solver. This presolver help to keep track of which combinations of variable values or feasible, and is the only thing that enforces the order.
    Parameters:
    
    orderedSet - The set members in correct order. Each of these variables must be binary.
    
    min - The minimum number of binary varibales in the set that must be "ON" (Set this to 0 if there is no minimum.)
    
    max - The SOS type or maximum number of binary varibales in the set that may be "ON"
  - addVariable
```
public Variable addVariable()
```
  - addVariable
```
public Variable addVariable(String name)
```
  - addVariable
```
public void addVariable(Variable variable)
```
  - addVariables
```
public void addVariables(Collection<? extends Variable> variables)
```
  - addVariables
```
public void addVariables(Variable[] variables)
```
  - bounds
```
public Stream<Variable> bounds()
```
    Returns:
    
    A stream of variables that are constraints and not fixed
  - constraints
```
public Stream<Expression> constraints()
```
    Returns:
    
    A prefiltered stream of expressions that are constraints and have not been markes as redundant
  - copy
```
public ExpressionsBasedModel copy()
```
  - countExpressions
```
public int countExpressions()
```
  - countVariables
```
public int countVariables()
```
  - dispose
```
public void dispose()
```
    Description copied from interface: Optimisation.Model
    
    Cleanup when a model instance is no longer needed. The default implementation does nothing,
  - generateCut
```
public Expression generateCut(Expression constraint,
                              Optimisation.Result solution)
```
  - getExpression
```
public Expression getExpression(String name)
```
  - getExpressions
```
public Collection<Expression> getExpressions()
```
  - getFixedVariables
```
public Set<Structure1D.IntIndex> getFixedVariables()
```
  - getFreeVariables
```
public List<Variable> getFreeVariables()
```
    Returns:
    
    A list of the variables that are not fixed at a specific value
  - getIntegerVariables
```
public List<Variable> getIntegerVariables()
```
    Returns:
    
    A list of the variables that are not fixed at a specific value and are marked as integer variables
  - getNegativeVariables
```
public List<Variable> getNegativeVariables()
```
    Returns:
    
    A list of the variables that are not fixed at a specific value and whos range include negative values
  - getPositiveVariables
```
public List<Variable> getPositiveVariables()
```
    Returns:
    
    A list of the variables that are not fixed at a specific value and whos range include positive values and/or zero
  - getVariable
```
public Variable getVariable(int index)
```
  - getVariable
```
public Variable getVariable(Structure1D.IntIndex index)
```
  - getVariables
```
public List<Variable> getVariables()
```
  - getVariableValues
```
public Optimisation.Result getVariableValues()
```
  - getVariableValues
```
public Optimisation.Result getVariableValues(NumberContext validationContext)
```
    Null variable values are replaced with 0.0. If any variable value is null the state is set to INFEASIBLE even if zero would actually be a feasible value. The objective function value is not calculated for infeasible variable values.
  - indexOf
```
public int indexOf(Variable variable)
```
  - indexOfFreeVariable
```
public int indexOfFreeVariable(int globalIndex)
```
    Parameters:
    
    globalIndex - General, global, variable index
    
    Returns:
    
    Local index among the free variables. -1 indicates the variable is not a positive variable.
  - indexOfFreeVariable
```
public int indexOfFreeVariable(Structure1D.IntIndex variableIndex)
```
  - indexOfFreeVariable
```
public int indexOfFreeVariable(Variable variable)
```
  - indexOfIntegerVariable
```
public int indexOfIntegerVariable(int globalIndex)
```
    Parameters:
    
    globalIndex - General, global, variable index
    
    Returns:
    
    Local index among the integer variables. -1 indicates the variable is not an integer variable.
  - indexOfIntegerVariable
```
public int indexOfIntegerVariable(Structure1D.IntIndex variableIndex)
```
  - indexOfIntegerVariable
```
public int indexOfIntegerVariable(Variable variable)
```
  - indexOfNegativeVariable
```
public int indexOfNegativeVariable(int globalIndex)
```
    Parameters:
    
    globalIndex - General, global, variable index
    
    Returns:
    
    Local index among the negative variables. -1 indicates the variable is not a negative variable.
  - indexOfNegativeVariable
```
public int indexOfNegativeVariable(Structure1D.IntIndex variableIndex)
```
  - indexOfNegativeVariable
```
public int indexOfNegativeVariable(Variable variable)
```
  - indexOfPositiveVariable
```
public int indexOfPositiveVariable(int globalIndex)
```
    Parameters:
    
    globalIndex - General, global, variable index
    
    Returns:
    
    Local index among the positive variables. -1 indicates the variable is not a positive variable.
  - indexOfPositiveVariable
```
public int indexOfPositiveVariable(Structure1D.IntIndex variableIndex)
```
  - indexOfPositiveVariable
```
public int indexOfPositiveVariable(Variable variable)
```
  - isAnyConstraintQuadratic
```
public boolean isAnyConstraintQuadratic()
```
  - isAnyExpressionQuadratic
```
@Deprecated
public boolean isAnyExpressionQuadratic()
```
    Deprecated. v45 Use isAnyConstraintQuadratic() or isAnyObjectiveQuadratic() instead
    
    Objective or any constraint has quadratic part.
  - isAnyObjectiveQuadratic
```
public boolean isAnyObjectiveQuadratic()
```
  - isAnyVariableFixed
```
public boolean isAnyVariableFixed()
```
  - isAnyVariableInteger
```
public boolean isAnyVariableInteger()
```
  - isWorkCopy
```
public boolean isWorkCopy()
```
  - limitObjective
```
public void limitObjective(BigDecimal lower,
                           BigDecimal upper)
```
  - maximise
```
public Optimisation.Result maximise()
```
  - minimise
```
public Optimisation.Result minimise()
```
  - objective
```
public Expression objective()
```
    This is generated on demend – you should not cache this. More specifically, modifications made to this expression will not be part of the optimisation model. You define the objective by setting the ModelEntity.weight(Number)/ModelEntity.weight(Number) on one or more variables and/or expressions.
    
    Returns:
    
    The generated/aggregated objective function
  - prepare
```
public ExpressionsBasedModel.Intermediate prepare()
```
    The general recommendation is to NOT call this method directly. Instead you should use/call maximise() or minimise().
    
    The primary use case for this method is as a callback method for solvers that iteratively modifies the model and solves at each iteration point.
    
    With direct usage of this method:
    - Maximisation/Minimisation is undefined (you don't know which it is)
    - The solution is not written back to the model
    - The solution is not validated by the model
  - relax
```
public ExpressionsBasedModel relax(boolean inPlace)
```
  - simplify
```
public ExpressionsBasedModel simplify()
```
  - snapshot
```
public ExpressionsBasedModel snapshot()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - validate
```
public boolean validate()
```
    This methods validtes model construction only. All the other validate(...) method validates the solution (one way or another).
    
    Returns:
    
    true If eveything is ok. false The model is structurally ok, but the "value" breaks constraints - the solution is infeasible.
    
    See Also:
    
    Optimisation.Model.validate()
  - validate
```
public boolean validate(Access1D<BigDecimal> solution)
```
  - validate
```
public boolean validate(Access1D<BigDecimal> solution,
                        NumberContext context)
```
  - validate
```
public boolean validate(Access1D<BigDecimal> solution,
                        NumberContext context,
                        BasicLogger.Printer appender)
```
  - validate
```
public boolean validate(Access1D<BigDecimal> solution,
                        BasicLogger.Printer appender)
```
  - validate
```
public boolean validate(NumberContext context)
```
  - validate
```
public boolean validate(NumberContext context,
                        BasicLogger.Printer appender)
```
  - validate
```
public boolean validate(BasicLogger.Printer appender)
```
  - variables
```
public Stream<Variable> variables()
```
    Returns:
    
    A stream of variables that are not fixed
  - isMaximisation
```
public final boolean isMaximisation()
```
  - isMinimisation
```
public final boolean isMinimisation()
```
  - setMaximisation
```
public final void setMaximisation()
```
  - setMinimisation
```
public final void setMinimisation()
```
  - setMaximisation
```
protected final void setMaximisation(boolean maximisation)
```
  - setMinimisation
```
protected final void setMinimisation(boolean minimisation)
```

Class ExpressionsBasedModel

Nested Class Summary

Nested classes/interfaces inherited from interface org.ojalgo.optimisation.Optimisation

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

options

Constructor Detail

ExpressionsBasedModel

ExpressionsBasedModel

ExpressionsBasedModel

ExpressionsBasedModel

Method Detail

addFallbackSolver

addIntegration

addPreferredSolver

addPresolver

clearIntegrations

clearPresolvers

removeIntegration

removePresolver

addExpression

addExpression

addSpecialOrderedSet

addSpecialOrderedSet

addVariable

addVariable

addVariable

addVariables

addVariables

bounds

constraints

copy

countExpressions

countVariables

dispose

generateCut

getExpression

getExpressions

getFixedVariables

getFreeVariables

getIntegerVariables

getNegativeVariables

getPositiveVariables

getVariable

getVariable

getVariables

getVariableValues

getVariableValues

indexOf

indexOfFreeVariable

indexOfFreeVariable

indexOfFreeVariable

indexOfIntegerVariable

indexOfIntegerVariable

indexOfIntegerVariable

indexOfNegativeVariable

indexOfNegativeVariable

indexOfNegativeVariable

indexOfPositiveVariable

indexOfPositiveVariable

indexOfPositiveVariable

isAnyConstraintQuadratic

isAnyExpressionQuadratic

isAnyObjectiveQuadratic

isAnyVariableFixed

isAnyVariableInteger

isWorkCopy

limitObjective

maximise

minimise

objective

prepare

relax

simplify

snapshot

toString

validate