14.2.22 Class Model

mosek::fusion::Model

The object containing all data related to a single optimization model.

Implements:

BaseModel

Members:

Model.acceptedSolutionStatus – Set the accepted solution status.

Model.breakSolver – Request that the solver terminates as soon as possible.

Model.clone – Return a copy of the model.

Model.constraint – Create a new constraint in the model.

Model.dataReport – Print out a report about problem data.

Model.disjunction – Create a new disjunctive constraint in the model.

Model.dispose – Destroy the Model object

Model.dualObjValue – Get the dual objective value in the current solution.

Model.flushParameters – Flush all parameters to the underlying task.

Model.flushSolutions – If any solution values have been provided, flush those values to the underlying task.

Model.getAcceptedSolutionStatus – Get the accepted solution status.

Model.getConstraint – Get the constraint matching the given name or linear index.

Model.getDualSolutionStatus – Return the status of the dual solution.

Model.getName – Return the model name, or an empty string if it has not been set.

Model.getParameter – Get the parameter matching the given name.

Model.getPrimalSolutionStatus – Return the status of the primal solution.

Model.getProblemStatus – Return the status of the problem.

Model.getSolverDoubleInfo – Fetch a solution information item from the solver

Model.getSolverIntInfo – Fetch a solution information item from the solver

Model.getSolverLIntInfo – Fetch a solution information item from the solver

Model.getTask – Return the underlying MOSEK task object.

Model.getVariable – Get the variable matching the given name or linear index.

Model.hasConstraint – Check whether the model contains a constraint with a given name.

Model.hasParameter – Check whether the model contains a parameter with a given name.

Model.hasVariable – Check whether the model contains a variable with a given name.

Model.objective – Replace the objective expression.

Model.optserverHost – Specify an OptServer for remote calls.

Model.parameter – Create a new parameter in the model.

Model.primalObjValue – Get the primal objective value in the current solution.

Model.selectedSolution – Chooses a solution.

Model.setCallbackHandler – Attach a progress callback handler.

Model.setDataCallbackHandler – Attach a data callback handler.

Model.setLogHandler – Attach a log handler.

Model.setSolverParam – Set a solver parameter

Model.solve – Attempt to optimize the model.

Model.updateObjective – Update part of the objective.

Model.variable – Create a new variable in the model.

Model.writeTask – Dump the current solver task to a file.

Model.writeTaskStream – Write the current solver task to a stream.

Static members:

Model.getVersion – Return MOSEK version.

Model.putlicensecode – Set the license code in the global environment.

Model.putlicensepath – Set the license path in the global environment.

Model.putlicensewait – Set the license wait flag in the global environment.

Model.solveBatch – Attempt to optimize a collection of models in parallel.

Model.acceptedSolutionStatus
void acceptedSolutionStatus(AccSolutionStatus what)

Set the accepted solution status. This defines which solution status values are considered as acceptable when fetching a solution. Requesting a solution value for a variable or constraint when the status does not match at least the accepted value will cause an error.

By default the accepted solution status is AccSolutionStatus.Optimal. It is necessary to change the accepted status to access sub-optimal solutions and infeasibility certificates.

The methods Model.getPrimalSolutionStatus and Model.getDualSolutionStatus can be used to get the actual status of the solutions.

Parameters:

what (AccSolutionStatus) – The new accepted solution status.

Model.breakSolver
void breakSolver()

Request that the solver terminates as soon as possible. This must be called from another thread than the one in which solve() was called, or from a callback function.

The method does not stop the solver directly, rather it sets a flag that the solver checks occasionally, indicating it should terminate.

Model.clone
Model::t clone()

Return a copy of the model.

Return:

(Model)

Model.constraint
Constraint::t constraint(string name, Expression::t expr, PSDDomain::t psddom)
Constraint::t constraint(Expression::t expr, PSDDomain::t psddom)
Constraint::t constraint(string name, Expression::t expr, LinearDomain::t ldom)
Constraint::t constraint(Expression::t expr, LinearDomain::t ldom)
Constraint::t constraint(string name, Expression::t expr, ConeDomain::t qdom)
Constraint::t constraint(Expression::t expr, ConeDomain::t qdom)
RangedConstraint::t constraint(string name, Expression::t expr, RangeDomain::t rdom)
RangedConstraint::t constraint(Expression::t expr, RangeDomain::t rdom)

Adds a new constraint to the model. A constraint is always a statement that an expression or variable belongs to a domain. Constraints can have optional names.

Typical domains used for defining constraints include:

See Domain for a full list of domains.

Parameters:

  • name (string) – Name of the constraint. This must be unique among all constraints in the model. The value nullptr is allowed instead of a unique name.

  • expr (Expression) – An expression.

  • psddom (PSDDomain) – A positive semidefinte domain.

  • ldom (LinearDomain) – A linear domain.

  • qdom (ConeDomain) – A domain in a cone.

  • rdom (RangeDomain) – A ranged domain.

Return:
Model.dataReport
void dataReport(int detail)
void dataReport()

Prints out a text report about the dimensions and numerical properties of the problem data. The report is printed to the currently attached log stream. The report is generated for the internal low-level optimizer task as a rough guidance for the user; some care may be needed to relate it correctly to the Fusion model.

Parameters:

detail (int) – The amount of detail to include, where 0 means nothing and 10 is full. If not provided then a full report is printed.

Model.disjunction
Disjunction::t disjunction(string name, Term::t t1)
Disjunction::t disjunction(string name, Term::t t1, Term::t t2)
Disjunction::t disjunction(string name, Term::t t1, Term::t t2, Term::t t3)
Disjunction::t disjunction(Term::t t1)
Disjunction::t disjunction(Term::t t1, Term::t t2)
Disjunction::t disjunction(Term::t t1, Term::t t2, Term::t t3)
Disjunction::t disjunction(shared_ptr<ndarray<Term::t,1>> terms)
Disjunction::t disjunction(string name, shared_ptr<ndarray<Term::t,1>> terms)

Adds a new disjunctive constraint to the model. A disjunctive constraint with terms \(T_1,\ldots,T_n\) is:

\[T_1 \ \mathrm{OR}\ \cdots\ \mathrm{OR}\ T_n.\]

Each term \(T_i\) of a disjunctive constraint is a Term, which can be created with DJC.term or with DJC.AND.

Parameters:

  • name (string) – The name of this disjunctive constraint.

  • t1 (Term) – A term in the disjunction.

  • t2 (Term) – A term in the disjunction.

  • t3 (Term) – A term in the disjunction.

  • terms (Term[]) – A list of terms forming the disjunctive constraint.

Return:

(Disjunction)

Model.dispose
void dispose()

Destroy the Model object. This removes all references to other objects from the Model.

This helps garbage collection by removing cyclic references, and in some cases it is necessary to ensure that the garbage collector can collect the Model object and assosiated objects.

Model.dualObjValue
double dualObjValue()

Get the dual objective value in the current solution.

Return:

(double)

Model.flushParameters
void flushParameters()

Flush all parameters to the underlying task.

Model.flushSolutions
void flushSolutions()

If any solution values have been provided, flush those values to the underlying task.

Model.getAcceptedSolutionStatus
AccSolutionStatus getAcceptedSolutionStatus()

Get the accepted solution status.

Return:

(AccSolutionStatus)

Model.getConstraint
Constraint::t getConstraint(string name)
Constraint::t getConstraint(int index)

Get the constraint matching the given name or linear index. Constraints are assigned indices in the order they are added to the model.

Parameters:

  • name (string) – The constraint’s name.

  • index (int) – The constraint’s linear index.

Return:

(Constraint)

Model.getDualSolutionStatus
SolutionStatus getDualSolutionStatus(SolutionType which)
SolutionStatus getDualSolutionStatus()

Return the status of the dual solution. If no solution type is given the solution set with Model.selectedSolution is checked. It is recommended to check the problem and solution status before accessing the solution values.

Parameters:

which (SolutionType) – The type of the solution for which status is requested.

Return:

(SolutionStatus)

Model.getName
string getName()

Return the model name, or an empty string if it has not been set.

Return:

(string)

Model.getParameter
Parameter::t getParameter(string name)

Get the parameter matching the given name.

Parameters:

name (string) – The parameter’s name.

Return:

(Parameter)

Model.getPrimalSolutionStatus
SolutionStatus getPrimalSolutionStatus(SolutionType which)
SolutionStatus getPrimalSolutionStatus()

Return the status of the primal solution. If no solution type is given the solution set with Model.selectedSolution is checked. It is recommended to check the problem and solution status before accessing the solution values.

Parameters:

which (SolutionType) – The type of the solution for which status is requested.

Return:

(SolutionStatus)

Model.getProblemStatus
ProblemStatus getProblemStatus(SolutionType which)
ProblemStatus getProblemStatus()

Return the status of the problem. If no solution type is given the solution set with Model.selectedSolution is checked. It is recommended to check the problem and solution status before accessing the solution values.

Parameters:

which (SolutionType) – The type of the solution.

Return:

(ProblemStatus)

Model.getSolverDoubleInfo
double getSolverDoubleInfo(string name)

This method returns the value for the specified double solver information item. The information items become available during and after the solver execution. A runtime exception is thrown if a non-existing information item is requested. The double information items are listed in Section Double information items.

Parameters:

name (string) – A string name of the information item.

Return:

(double)

Model.getSolverIntInfo
int getSolverIntInfo(string name)

This method returns the value for the specified integer solver information item. The information items become available during and after the solver execution. A runtime exception is thrown if a non-existing information item is requested. The integer information items are listed in Section Integer information items..

Parameters:

name (string) – A string name of the information item.

Return:

(int)

Model.getSolverLIntInfo
long long getSolverLIntInfo(string name)

This method returns the value for the specified long solver information item. The information items become available during and after the solver execution. A runtime exception is thrown if a non-existing information item is requested. The long integer information items are listed in Section Long integer information items..

Parameters:

name (string) – A string name of the information item.

Return:

(long long)

Model.getTask
mosek.Task getTask()

Returns the underlying MOSEK Task object. Note that the returned object is the actual underlying object, not a copy. This means if the returned object is modified by the user, the Model object may become invalid. Accessing the task object should never be necessary, except maybe for advanced debugging. For details on the Task object see the Optimizer API documentation.

Return:

(Task)

Model.getVariable
Variable::t getVariable(string name)
Variable::t getVariable(int index)

Get the variable matching the given name or linear index. Variables are assigned indices in the order they are added to the model.

Parameters:

  • name (string) – The variable’s name.

  • index (int) – The variable’s linear index.

Return:

(Variable)

Model.getVersion
string Model::getVersion()

Returns the MOSEK version as a string, for example “11.0.2”.

Return:

(string)

Model.hasConstraint
bool hasConstraint(string name)

Check whether the model contains a constraint with a given name.

Parameters:

name (string) – The constraint name.

Return:

(bool)

Model.hasParameter
bool hasParameter(string name)

Check whether the model contains a parameter with a given name.

Parameters:

name (string) – The parameter’s name.

Return:

(bool)

Model.hasVariable
bool hasVariable(string name)

Check whether the model contains a variable with a given name.

Parameters:

name (string) – The variable name.

Return:

(bool)

Model.objective
void objective(string name, ObjectiveSense sense, Expression::t expr)
void objective(string name, ObjectiveSense sense, double c)
void objective(string name, double c)
void objective(ObjectiveSense sense, Expression::t expr)
void objective(ObjectiveSense sense, double c)
void objective(double c)

Replace the objective expression. This method must be called at least once before the first Model.solve.

Parameters:

  • name (string) – Name of the objective. This may be any string, and it has no function except when writing the problem to an external file format.

  • sense (ObjectiveSense) – The objective sense. Defines whether the objective must be minimized or maximized.

  • expr (Expression) – The objective expression. This must be an affine expression that evaluates to a scalar.

  • c (double) – A constant scalar.

Model.optserverHost
void optserverHost(string addr)

Specify an OptServer URL for remote calls. The URL should contain protocol, host and port in the form http://server:port or https://server:port. If the URL is set using this function, all subsequent calls to Model.solve will be sent to the specified OptServer instead of being executed locally. Passing NULL deactivates this redirection.

Parameters:

addr (string) – Address of the OptServer. It should be a valid URL, for example http://server:port or https://server:port.

Model.parameter
Parameter::t parameter(shared_ptr<ndarray<int,1>> shape, shared_ptr<ndarray<int,2>> sparsity)
Parameter::t parameter(shared_ptr<ndarray<int,1>> shape, shared_ptr<ndarray<long long,1>> sp)
Parameter::t parameter(shared_ptr<ndarray<int,1>> shape)
Parameter::t parameter(int d1)
Parameter::t parameter(int d1, int d2)
Parameter::t parameter(int d1, int d2, int d3)
Parameter::t parameter()
Parameter::t parameter(string name, shared_ptr<ndarray<int,1>> shape, shared_ptr<ndarray<int,2>> sparsity)
Parameter::t parameter(string name, shared_ptr<ndarray<int,1>> shape, shared_ptr<ndarray<long long,1>> sp)
Parameter::t parameter(string name, shared_ptr<ndarray<int,1>> shape)
Parameter::t parameter(string name, int d1)
Parameter::t parameter(string name, int d1, int d2)
Parameter::t parameter(string name, int d1, int d2, int d3)
Parameter::t parameter(string name)

Create a new parameter in the model. A parameter is a placeholder for a constant (scalar or array) value that can be assigned and reset after the model is built and between optimizations.

If the shape is not provided, the parameter is a scalar parameter. The default value of a newly created parameter is 0. To set the value use Parameter.setValue.

Parameters:

  • shape (int[]) – Shape of the parameter.

  • sparsity (int[][]) – Non-zero sparsity pattern, if the parameter is sparse.

  • sp (long long[]) – Non-zero sparsity pattern as a list of linear indexes, if the parameter is sparse.

  • d1 (int) – First dimension of a parameter.

  • d2 (int) – Second dimension of a parameter.

  • d3 (int) – Third dimension of a parameter.

  • name (string) – Name of the parameter.

Return:

(Parameter)

Model.primalObjValue
double primalObjValue()

Get the primal objective value in the current solution.

Return:

(double)

Model.putlicensecode
void Model::putlicensecode(shared_ptr<ndarray<int,1>> code)

Set the license code in the global environment. This function has an effect only before the first optimization in the current process.

Parameters:

code (int[])

Model.putlicensepath
void Model::putlicensepath(string licfile)

Set the license path in the global environment. This function has an effect only before the first optimization in the current process.

Parameters:

licfile (string)

Model.putlicensewait
void Model::putlicensewait(bool wait)

Set the license wait flag in the global environment. If set, MOSEK will wait until a license becomes available.

Parameters:

wait (bool)

Model.selectedSolution
void selectedSolution(SolutionType soltype)

Chooses a solution. The values of variables and constraints will be read from the chosen solution. The default is to consider all solution types in the order of SolutionType.Default.

Parameters:

soltype (SolutionType) – The solution type to select as default.

Model.setCallbackHandler
void setCallbackHandler(System.CallbackHandler h)

Attach a progress callback handler. During optimization this handler will be called, providing a code with the current state of the solver. Passing nullptr detaches the current handler. See Section Progress and data callback for details and examples and the Optimizer API for information about callback codes.

The progress callback handler is a function of type std::function<int(MSKcallbackcodee)>.

Parameters:

h (CallbackHandler) – The callback handler or nullptr.

Model.setDataCallbackHandler
void setDataCallbackHandler(System.DataCallbackHandler h)

Attach a data callback handler. During optimization this handler will be called, providing various information about the current state of the solution and solver. Passing nullptr detaches the current handler. See Section Progress and data callback for details and examples and the Optimizer API for information about callback codes.

The data callback handler is a function of type std::function<bool(MSKcallbackcodee, const double *, const int32_t *, const int64_t *)>.

Parameters:

h (DataCallbackHandler) – The callback handler or nullptr.

Model.setLogHandler
void setLogHandler(System.StreamWriter h)

Attach a log handler. The solver log information will be sent to the stream handler. Passing nullptr detaches the current handler.

The log handler is a function of type std::function<void(const std::string &)>, for example

M->setLogHandler([](const std::string & msg) { std::cout << msg << std::flush; } );
Parameters:

h (StreamWriter) – The log handler object or nullptr.

Model.setSolverParam
void setSolverParam(string name, string strval)
void setSolverParam(string name, int intval)
void setSolverParam(string name, double floatval)

Set a solver parameter. Solver parameter values can be either symbolic values, integers or doubles, depending on the parameter. The value is automatically converted to a suitable type whenever possible. If this fails, an exception will be thrown. For example, if the parameter accepts a double value and is given a string, the string will be parsed to produce a double.

See Section Parameters (alphabetical list sorted by type) for a listing of all parameter settings.

Parameters:

  • name (string) – Name of the parameter to set

  • strval (string) – A string value to assign to the parameter.

  • intval (int) – An integer value to assign to the parameter.

  • floatval (double) – A floating point value to assign to the parameter.

Model.solve
void solve()
void solve(string addr, string accesstoken)

This calls the MOSEK solver to solve the problem defined in the model.

If no error occurs, on exit a solution status will be defined for the primal and the dual solutions. These can be obtained with Model.getPrimalSolutionStatus and Model.getDualSolutionStatus. Depending on the solution status, various values may be defined:

  • If the model is primal-dual feasible, or nearly so, and the solver found a solution, the solution values can be accessed through the Variable and Constraint objects in the model. For integer problems only the primal solution is defined, while for continuous problems both primal and dual solutions are available.

  • If the model is primal or dual infeasible, only the primal or the dual solution is defined, depending on the solution status. The available solution contains a certificate of infeasibility.

  • If the status is unknown the solver ran into problems and did not find anything useful. In this case the solution values may be garbage.

The solution can be obtained with Model.primalObjValue and Variable.level and their dual analogues.

By default, trying to fetch a non-optimal solution using Variable.level or Variable.dual will cause an exception. To fetch infeasibility certificates or other less optimal solutions it is necessary to change the accepted solution flag with Model.acceptedSolutionStatus.

Parameters:

  • addr (string) – Address of the OptServer if optimizing remotely. It should be a valid URL, for example http://server:port or https://server:port.

  • accesstoken (string) – Access token if optimizing remotely with authentication.

Model.solveBatch
shared_ptr<ndarray<SolverStatus,1>> Model::solveBatch(bool israce, double maxtime, int numthreads, shared_ptr<ndarray<Model::t,1>> models)

Calls the MOSEK solver to solve all the provided models in parallel. All callbacks and log output streams are disabled.

Assuming that each model takes about same time and there many more models than threads then a linear speedup can be achieved, also known as strong scaling. A typical application of this method is to solve many small models of similar type; in this case it is recommended that each of them is allocated a single thread by setting numThreads to \(1\).

If the parameters israce or maxtime are used, then the result may not be deterministic, in the sense that the models which complete first may vary between runs.

The remaining behavior is the same as if each model was solved separately with Model.solve. The return array describes if each model solved, failed or wasn’t attempted because another one finished first (if israce is used). Debugging a failed model can be done by solving it individually.

This method parallelizes the call to the numerical solver; additional operations such as postprocessing the optimizer solution into the solution of the Fusion model are still performed sequentially.

Parameters:

  • israce (bool) – If true, then the function is terminated after the first model completed.

  • maxtime (double) – Time limit: if nonnegative, then the function is terminated after this time (seconds).

  • numthreads (int) – The number of threads for the whole pool available to all models. If set to 0 the number of threads used will be equal to the number of cores detected on the machine.

  • models (Model[]) – An array of models to be solved.

Return:

(SolverStatus[])

Model.updateObjective
void updateObjective(Expression::t expr, Variable::t x)

Update the columns in the objective expression defined by x.

Parameters:

  • expr (Expression) – The expression to update with. This must have size 1.

  • x (Variable) – The columns to replace.

Model.variable
Variable::t variable(string name)
Variable::t variable(string name, int size)
Variable::t variable(string name, int size, LinearDomain::t ldom)
RangedVariable::t variable(string name, int size, RangeDomain::t rdom)
Variable::t variable(string name, int size, ConeDomain::t qdom)
Variable::t variable(string name, shared_ptr<ndarray<int,1>> shp)
Variable::t variable(string name, shared_ptr<ndarray<int,1>> shp, LinearDomain::t ldom)
RangedVariable::t variable(string name, shared_ptr<ndarray<int,1>> shp, RangeDomain::t rdom)
Variable::t variable(string name, shared_ptr<ndarray<int,1>> shp, ConeDomain::t qdom)
Variable::t variable(string name, LinearDomain::t ldom)
RangedVariable::t variable(string name, RangeDomain::t rdom)
Variable::t variable(string name, ConeDomain::t qdom)
Variable::t variable()
Variable::t variable(int size)
Variable::t variable(int size, LinearDomain::t ldom)
RangedVariable::t variable(int size, RangeDomain::t rdom)
Variable::t variable(int size, ConeDomain::t qdom)
Variable::t variable(shared_ptr<ndarray<int,1>> shp)
Variable::t variable(shared_ptr<ndarray<int,1>> shp, LinearDomain::t ldom)
RangedVariable::t variable(shared_ptr<ndarray<int,1>> shp, RangeDomain::t rdom)
Variable::t variable(shared_ptr<ndarray<int,1>> shp, ConeDomain::t qdom)
Variable::t variable(LinearDomain::t ldom)
RangedVariable::t variable(RangeDomain::t rdom)
Variable::t variable(ConeDomain::t qdom)
Variable::t variable(string name, shared_ptr<ndarray<int,1>> shp, PSDDomain::t psddom)
Variable::t variable(string name, int n, PSDDomain::t psddom)
Variable::t variable(string name, int n, int m, PSDDomain::t psddom)
Variable::t variable(string name, PSDDomain::t psddom)
Variable::t variable(int n, PSDDomain::t psddom)
Variable::t variable(int n, int m, PSDDomain::t psddom)
Variable::t variable(PSDDomain::t psddom)

Create a new variable in the model. All variables must be created using this method. The many versions of the method accept a name (optional), the shape of the variable and its domain. The domain must be suitable for the given variable shape. If the domain is not provided, it is assumed that the variable is unbounded. If the dimension is not provided the variable is a single scalar variable.

Typical domains used for creating variables include:

Parameters:

  • name (string) – Name of the variable. This must be unique among all variables in the model. The value nullptr is allowed instead of a unique name.

  • size (int) – Size of the variable. The variable becomes a one-dimensional vector of the given size.

  • ldom (LinearDomain) – A linear domain for the variable.

  • rdom (RangeDomain) – A ranged domain for the variable.

  • qdom (ConeDomain) – A conic domain for the variable.

  • shp (int[]) – Defines the shape of the variable.

  • psddom (PSDDomain) – A semidefinte domain for the variable.

  • n (int) – Dimension of the semidefinite variable.

  • m (int) – Number of semidefinite variables.

Return:
Model.writeTask
void writeTask(string filename)

Dump the current solver task to a file. The file extension determines the file format, see Section Supported File Formats for details. The file can be read with the command line MOSEK or with the Optimizer API for debugging purposes.

Parameters:

filename (string) – Name of the output file.

Model.writeTaskStream
void writeTaskStream(string ext, System.DataStream stream)

Write the current solver task to a stream object. The extension determines the file format, see Section Supported File Formats, and it should be a string such as "ptf", "task.gz", etc. that would be used for file extension in Model.writeTask.

stream is an object of type std::ostream, for example

    M->writeTaskStream("jtask", std::cout);

    std::ofstream outfile("dump.ptf", std::ofstream::binary);
    M->writeTaskStream("ptf", outfile);
    outfile.close();
Parameters:

  • ext (string) – Extension, which determines the file format.

  • stream (DataStream) – The output stream.