org.ojalgo.optimisation
Class VariablesBasedModel<M extends VariablesBasedModel<M>>

java.lang.Object
  org.ojalgo.optimisation.VariablesBasedModel<M>

All Implemented Interfaces:

OptimisationModel

Direct Known Subclasses:

LinearModel, QuadraticModel

public abstract class VariablesBasedModel<M extends VariablesBasedModel<M>>
extends Object

Lets you construct optimisation problems by collecting quadratic mathematical expressions (in terms of the variables). Each expression can be a constraint and/or contribute to the objective function.

Basic instructions:

1. Define (create) a set of variables. Each variable may have a lower as well as an upper limit and a cost associated with it.
2. Create a model using that set of variables.
3. Add expressions to the model. The model is the expression factory/builder. Each expression can act as both a constraint and as a part of the objective.
4. Instanciate a solver using the model.
5. Solve!

Author:

apete

Field Summary

static boolean

DEBUG

Method Summary

Expression	addConstraint(String aName, BigDecimal aLowerLimit, Array1D<BigDecimal> somefactors, BigDecimal anUpperLimit) Note that only the first constraint you add will be used by the solver.
Expression	addConstraint(String aName, BigDecimal aLowerLimit, BigDecimal anUpperLimit) Note that only the first constraint you add will be used by the solver.
Expression	addCorrelationExpression(String aName, BasicMatrix aCorrelationsMatrix)
Expression	addEmptyLinearExpression(String aName)
Expression	addEmptyQuadraticExpression(String aName)
Expression	addGeneralExpression(String aName)
Expression	addOffsetExpression(String aName, Array1D<BigDecimal> theOrigin) Generates a constraint that measures the distance from a specified point.
Expression	addSimpleWeightExpression(String aName)
Expression	addWeightExpression(String aName, BigDecimal[] someWeights)
Expression	addWeightExpression(String aName, List<BigDecimal> someWeights)
abstract M	copy()
int	countExpressions()
int	countVariables()
int	getComplexity() Deprecated. v28 Use countExpressions() instead
abstract OptimisationSolver	getDefaultSolver() No need to implement an OptimisationModel if there is not at least one matching OptimisationSolver.
int	getDim() Deprecated. v28 Use countVariables() instead
Expression	getExpression(int anIndex) Deprecated. v28 Use getExpression(String) instead.
Expression	getExpression(String aName)
Expression[]	getExpressions()
boolean[]	getIntegers()
Expression	getObjectiveExpression()
BigDecimal	getValue()
Variable	getVariable(int anIndex)
Variable[]	getVariables()
BigDecimal[]	getVariableValues()
int	indexOfVariable(String aName)
boolean	isAnyExpressionQuadratic()
boolean	isAnyVariableInteger()
boolean	isMaximisation()
boolean	isMinimisation()
BigDecimal	maximise()
BigDecimal	minimise()
M	relax()
void	resetObjectiveExpression()
Expression[]	selectEqualityConstraintExpressions()
Variable[]	selectEqualityConstraintVariables()
Expression[]	selectLowerConstraintExpressions()
Variable[]	selectLowerConstraintVariables()
Expression[]	selectNegativeEqualityConstraintExpressions()
Expression[]	selectNegativeLowerConstraintExpressions()
Expression[]	selectNegativeUpperConstraintExpressions()
Variable[]	selectNonZeroLowerConstraintVariables()
Expression[]	selectPositiveEqualityConstraintExpressions()
Expression[]	selectPositiveLowerConstraintExpressions()
Expression[]	selectPositiveUpperConstraintExpressions()
Expression[]	selectUpperConstraintExpressions()
Variable[]	selectUpperConstraintVariables()
void	setLowerLimitOnVariable(int aVariableIndex, BigDecimal aLimit)
void	setMaximisation(boolean aFlag)
void	setMinimisation(boolean aFlag)
void	setUpperLimitOnVariable(int aVariableIndex, BigDecimal aLimit)
String	toString()
boolean	validateComposition() OptimisationModel is meant to be implemented in parallel with OptimisationSolver.
boolean	validateSolution(BasicMatrix aSolution, NumberContext aContext)
boolean	validateSolution(NumberContext aContext)

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

DEBUG

public static boolean DEBUG

Method Detail

addConstraint

public Expression addConstraint(String aName,
                                BigDecimal aLowerLimit,
                                Array1D<BigDecimal> somefactors,
                                BigDecimal anUpperLimit)

Note that only the first constraint you add will be used by the solver.

addConstraint

public Expression addConstraint(String aName,
                                BigDecimal aLowerLimit,
                                BigDecimal anUpperLimit)

Note that only the first constraint you add will be used by the solver.

addCorrelationExpression

public Expression addCorrelationExpression(String aName,
                                           BasicMatrix aCorrelationsMatrix)

addEmptyLinearExpression

public Expression addEmptyLinearExpression(String aName)

addEmptyQuadraticExpression

public Expression addEmptyQuadraticExpression(String aName)

addGeneralExpression

public Expression addGeneralExpression(String aName)

addOffsetExpression

public Expression addOffsetExpression(String aName,
                                      Array1D<BigDecimal> theOrigin)

Generates a constraint that measures the distance from a specified point. Actually, the expression measures the square of the distance...

Parameters:

aName - An expression name

theOrigin - The "specified point"

Returns:

Expression of the square of the distance from the origin

addSimpleWeightExpression

public Expression addSimpleWeightExpression(String aName)

addWeightExpression

public Expression addWeightExpression(String aName,
                                      BigDecimal[] someWeights)

addWeightExpression

public Expression addWeightExpression(String aName,
                                      List<BigDecimal> someWeights)

copy

public abstract M copy()

countExpressions

public int countExpressions()

countVariables

public int countVariables()

getComplexity

@Deprecated
public int getComplexity()

Deprecated. v28 Use countExpressions() instead

getDefaultSolver

public abstract OptimisationSolver getDefaultSolver()

Description copied from interface: OptimisationModel

No need to implement an OptimisationModel if there is not at least one matching OptimisationSolver.

getDim

@Deprecated
public int getDim()

Deprecated. v28 Use countVariables() instead

getExpression

@Deprecated
public Expression getExpression(int anIndex)

Deprecated. v28 Use getExpression(String) instead.

getExpression

public Expression getExpression(String aName)

getExpressions

public Expression[] getExpressions()

getIntegers

public boolean[] getIntegers()

getObjectiveExpression

public final Expression getObjectiveExpression()

getValue

public final BigDecimal getValue()

getVariable

public Variable getVariable(int anIndex)

getVariables

public Variable[] getVariables()

getVariableValues

public final BigDecimal[] getVariableValues()

indexOfVariable

public int indexOfVariable(String aName)

isAnyExpressionQuadratic

public final boolean isAnyExpressionQuadratic()

isAnyVariableInteger

public final boolean isAnyVariableInteger()

maximise

public final BigDecimal maximise()

minimise

public final BigDecimal minimise()

relax

public final M relax()

resetObjectiveExpression

public final void resetObjectiveExpression()

selectEqualityConstraintExpressions

public final Expression[] selectEqualityConstraintExpressions()

selectEqualityConstraintVariables

public final Variable[] selectEqualityConstraintVariables()

selectLowerConstraintExpressions

public final Expression[] selectLowerConstraintExpressions()

selectLowerConstraintVariables

public final Variable[] selectLowerConstraintVariables()

selectNegativeEqualityConstraintExpressions

public final Expression[] selectNegativeEqualityConstraintExpressions()

selectNegativeLowerConstraintExpressions

public final Expression[] selectNegativeLowerConstraintExpressions()

selectNegativeUpperConstraintExpressions

public final Expression[] selectNegativeUpperConstraintExpressions()

selectNonZeroLowerConstraintVariables

public final Variable[] selectNonZeroLowerConstraintVariables()

selectPositiveEqualityConstraintExpressions

public final Expression[] selectPositiveEqualityConstraintExpressions()

selectPositiveLowerConstraintExpressions

public final Expression[] selectPositiveLowerConstraintExpressions()

selectPositiveUpperConstraintExpressions

public final Expression[] selectPositiveUpperConstraintExpressions()

selectUpperConstraintExpressions

public final Expression[] selectUpperConstraintExpressions()

selectUpperConstraintVariables

public final Variable[] selectUpperConstraintVariables()

setLowerLimitOnVariable

public void setLowerLimitOnVariable(int aVariableIndex,
                                    BigDecimal aLimit)

setUpperLimitOnVariable

public void setUpperLimitOnVariable(int aVariableIndex,
                                    BigDecimal aLimit)

toString

public final String toString()

Overrides:

toString in class Object

validateComposition

public boolean validateComposition()
                            throws ModelValidationException

Description copied from interface: OptimisationModel

OptimisationModel is meant to be implemented in parallel with OptimisationSolver. This method indicates if the model is built in a way the solver can handle or not.

Throws:

ModelValidationException

validateSolution

public boolean validateSolution(BasicMatrix aSolution,
                                NumberContext aContext)

validateSolution

public boolean validateSolution(NumberContext aContext)

isMaximisation

public final boolean isMaximisation()

isMinimisation

public final boolean isMinimisation()

setMaximisation

public final void setMaximisation(boolean aFlag)

setMinimisation

public final void setMinimisation(boolean aFlag)