7.2 Accessing the solution¶
This section contains important information about the status of the solver and the status of the solution, which must be checked in order to properly interpret the results of the optimization.
7.2.1 Solver termination¶
The optimizer provides two status codes relevant for error handling:
Response code of type
Rescode
. It indicates if any unexpected error (such as an out of memory error, licensing error etc.) has occurred. The expected value for a successful optimization isRescode::OK
.Termination code: It provides information about why the optimizer terminated, for instance if a predefined time limit has been reached. These are not errors, but ordinary events that can be expected (depending on parameter settings and the type of optimizer used).
If the optimization was successful then the method Task.optimize
returns normally and its output is the termination code. If an error occurs then the method throws an exception, which contains the response code. See Sec. 7.3 (Errors and exceptions) for how to access it.
If a runtime error causes the program to crash during optimization, the first debugging step is to enable logging and check the log output. See Sec. 7.4 (Input/Output).
If the optimization completes successfully, the next step is to check the solution status, as explained below.
7.2.2 Available solutions¶
MOSEK uses three kinds of optimizers and provides three types of solutions:
basic solution from the simplex optimizer,
interiorpoint solution from the interiorpoint optimizer,
integer solution from the mixedinteger optimizer.
Under standard parameters settings the following solutions will be available for various problem types:
Simplex optimizer 
Interiorpoint optimizer 
Mixedinteger optimizer 

Linear problem 

Nonlinear continuous problem 

Problem with integer variables 
For linear problems the user can force a specific optimizer choice making only one of the two solutions available. For example, if the user disables basis identification, then only the interior point solution will be available for a linear problem. Numerical issues may cause one of the solutions to be unknown even if another one is feasible.
Not all components of a solution are always available. For example, there is no dual solution for integer problems and no dual conic variables from the simplex optimizer.
The user will always need to specify which solution should be accessed.
7.2.3 Problem and solution status¶
Assuming that the optimization terminated without errors, the next important step is to check the problem and solution status. There is one for every type of solution, as explained above.
Problem status
Problem status (Prosta
) determines whether the problem is certified as feasible. Its values can roughly be divided into the following broad categories:
feasible — the problem is feasible. For continuous problems and when the solver is run with default parameters, the feasibility status should ideally be
Prosta::PRIM_AND_DUAL_FEAS
.primal/dual infeasible — the problem is infeasible or unbounded or a combination of those. The exact problem status will indicate the type of infeasibility.
unknown — the solver was unable to reach a conclusion, most likely due to numerical issues.
Solution status
Solution status (Solsta
) provides the information about what the solution values actually contain. The most important broad categories of values are:
optimal (
Solsta::OPTIMAL
) — the solution values are feasible and optimal.certificate — the solution is in fact a certificate of infeasibility (primal or dual, depending on the solution).
unknown/undefined — the solver could not solve the problem or this type of solution is not available for a given problem.
Problem and solution status for each solution can be retrieved with Task.get_pro_sta
and Task.get_sol_sta
, respectively.
The solution status determines the action to be taken. For example, in some cases a suboptimal solution may still be valuable and deserve attention. It is the user’s responsibility to check the status and quality of the solution.
Typical status reports
Here are the most typical optimization outcomes described in terms of the problem and solution statuses. Note that these do not cover all possible situations that can occur.
Outcome 
Problem status 
Solution status 

Optimal 

Primal infeasible 

Dual infeasible (unbounded) 

Uncertain (stall, numerical issues, etc.) 
Outcome 
Problem status 
Solution status 

Integer optimal 

Infeasible 

Integer feasible point 

No conclusion 
7.2.4 Retrieving solution values¶
After the meaning and quality of the solution (or certificate) have been established, we can query for the actual numerical values. They can be accessed using:
Task.get_primal_obj
,Task.get_dual_obj
— the primal and dual objective value.Task.get_xx
— solution values for the variables.Task.get_solution
— a full solution with primal and dual values
and many more specialized methods, see the API reference.
7.2.5 Source code example¶
Below is a source code example with a simple framework for assessing and retrieving the solution to a conic optimization problem.
extern crate mosek;
use mosek::{Task,Streamtype,Solsta,Soltype};
use std::env;
const CQO1_PTF : &str = "Task 'CQO1 EXAMPLE'
Objective obj
Minimize + x4 + x5 + x6
Constraints
c1 [1] + x1 + x2 + 2 x3
Variables
k1 [QUAD(3)]
x4
x1 [0;+inf]
x2 [0;+inf]
k2 [RQUAD(3)]
x5
x6
x3 [0;+inf]
";
fn main() > Result<(),String> {
let args: Vec<String> = env::args().collect();
let mut task = Task::new().unwrap().with_callbacks();
if args.len() < 2 {
task.read_ptf_string(CQO1_PTF)?;
}
else {
task.read_data(args[1].as_str())?;
}
// Perform optimization.
let trm = task.optimize()?;
task.solution_summary(Streamtype::LOG)?;
// Handle solution status. We expect Optimal
let solsta = task.get_sol_sta(Soltype::ITR)?;
match solsta {
Solsta::OPTIMAL => {
// Fetch and print the solution
println!("An optimal interior point solution is located.");
let numvar = task.get_num_var()?;
let mut xx = vec![0.0; numvar as usize];
task.get_xx(Soltype::ITR, xx.as_mut_slice())?;
println!("xx = {:?}",xx)
},
Solsta::DUAL_INFEAS_CER =>
println!("Dual infeasibility certificate found."),
Solsta::PRIM_INFEAS_CER =>
println!("Primal infeasibility certificate found."),
Solsta::UNKNOWN => {
// The solutions status is unknown. The termination code
// indicates why the optimizer terminated prematurely.
println!("The solution status is unknown.");
let (symname,desc) = mosek::get_code_desc(trm)?;
println!(" Termination code: {} {}\n", symname, desc)
},
_ =>
println!("Unexpected solution status {}\n",solsta)
}
Ok(())
}