Struct Solution 

pub struct Solution {
    pub status: SolveStatus,
    pub x: Vec<f64>,
    pub dual: DualVariables,
    pub objective: f64,
    pub residuals: KktResiduals,
    pub iterations: usize,
    pub solve_time: Duration,
    pub final_rho: f64,
    pub rho_updates: usize,
    pub polished: bool,
    pub diagnostics: Option<ConvergenceDiagnostics>,
    pub certificate: Option<Certificate>,
}

Solver result and diagnostics.

Fields

status: SolveStatus

Termination status.

x: Vec<f64>

Primal decision vector.

dual: DualVariables

Constraint multipliers.

objective: f64

Objective value at the returned iterate.

residuals: KktResiduals

KKT residuals at the returned iterate.

iterations: usize

Number of completed ADMM iterations.

solve_time: Duration

Wall-clock time this solve was charged with: setup plus iteration for Solver::solve, iteration only for Workspace::solve (setup was paid at workspace construction).

final_rho: f64

Penalty used for the final iteration.

rho_updates: usize

Number of adaptive penalty changes. Each change needs the matching reduced factorization: one-shot solves rebuild it, workspace solves reuse a cached one when the penalty was already visited.

polished: bool

Whether the returned iterate is the polished one: true only when the status is SolveStatus::Solved, SolverSettings::polish is enabled, and the direct active-set solve improved the worst KKT residual (otherwise the ADMM iterate is kept and this stays false).

diagnostics: Option<ConvergenceDiagnostics>

Heuristic hints; present only when the status is not Solved.

certificate: Option<Certificate>

Infeasibility proof; present only when the status is SolveStatus::PrimalInfeasible or SolveStatus::DualInfeasible.

Certificates are normalized to unit infinity norm, reported in the original data space, and independently auditable with crate::check_primal_certificate / crate::check_dual_certificate.

Implementations

impl Solution

pub fn warm_start(&self) -> WarmStart

Converts this solution into a full warm start for a related solve.

Examples found in repository

examples/rebalance.rs (line 44)

fn main() -> Result<(), Box<dyn Error>> {
    let first = portfolio(vec![0.09, 0.08, 0.07, 0.06, 0.05, 0.04])?.solve(None)?;
    require_solved(&first)?;

    let warm_start = first.warm_start();
    let second = portfolio(vec![0.07, 0.08, 0.10, 0.05, 0.06, 0.04])?
        .with_quadratic_turnover(first.x.clone(), 0.4)?
        .solve(Some(&warm_start))?;
    require_solved(&second)?;

    let budget: f64 = second.x.iter().sum();
    let one_way_turnover: f64 = first
        .x
        .iter()
        .zip(&second.x)
        .map(|(old, new)| (new - old).abs())
        .sum::<f64>()
        / 2.0;
    println!("first weights:  {:.6?}", first.x);
    println!("second weights: {:.6?}", second.x);
    println!("budget: {budget:.10}");
    println!("one-way turnover: {one_way_turnover:.6}");
    println!(
        "status: {}, iterations: {}, primal residual: {:.3e}, dual residual: {:.3e}",
        second.status, second.iterations, second.residuals.primal, second.residuals.dual
    );
    Ok(())
}

Trait Implementations

impl Clone for Solution

fn clone(&self) -> Solution

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Solution

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for Solution

fn eq(&self, other: &Solution) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Solution