clarabel 0.3.0

Clarabel Conic Interior Point Solver for Rust / Python
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use super::*;
use crate::solver::core::{
    cones::{CompositeCone, SupportedConeT},
    traits::ProblemData,
    Solver,
};

use crate::algebra::*;
use crate::timers::*;

/// Solver for problems in standard conic program form

pub type DefaultSolver<T = f64> = Solver<
    DefaultProblemData<T>,
    DefaultVariables<T>,
    DefaultResiduals<T>,
    DefaultKKTSystem<T>,
    CompositeCone<T>,
    DefaultInfo<T>,
    DefaultSolution<T>,
    DefaultSettings<T>,
>;

impl<T> DefaultSolver<T>
where
    T: FloatT,
{
    pub fn new(
        P: &CscMatrix<T>,
        q: &[T],
        A: &CscMatrix<T>,
        b: &[T],
        cone_types: &[SupportedConeT<T>],
        settings: DefaultSettings<T>,
    ) -> Self {
        //sanity check problem dimensions
        _check_dimensions(P, q, A, b, cone_types);

        let mut timers = Timers::default();
        let mut output;

        timeit! {timers => "setup"; {

        let info = DefaultInfo::<T>::new();
        let cones = CompositeCone::<T>::new(cone_types);
        let mut data = DefaultProblemData::<T>::new(P,q,A,b);
        let variables = DefaultVariables::<T>::new(data.n,data.m);
        let residuals = DefaultResiduals::<T>::new(data.n,data.m);

        // equilibrate problem data immediately on setup.
        // this prevents multiple equlibrations if solve!
        // is called more than once.
        timeit!{timers => "equilibration"; {
            data.equilibrate(&cones,&settings);
        }}

        let kktsystem;
        timeit!{timers => "kktinit"; {
            kktsystem = DefaultKKTSystem::<T>::new(&data,&cones,&settings);
        }}

        // work variables for assembling step direction LHS/RHS
        let step_rhs  = DefaultVariables::<T>::new(data.n,data.m);
        let step_lhs  = DefaultVariables::<T>::new(data.n,data.m);
        let prev_vars = DefaultVariables::<T>::new(data.n,data.m);

        // user facing results go here.
        let solution = DefaultSolution::<T>::new(data.m,data.n);

        output = Self{data,variables,residuals,kktsystem,step_lhs,
             step_rhs,prev_vars,info,solution,cones,settings,timers: None};

        }} //end "setup" timer.

        //now that the timer is finished we can swap our
        //timer object into the solver structure
        output.timers.replace(timers);

        output
    }
}

fn _check_dimensions<T: FloatT>(
    P: &CscMatrix<T>,
    q: &[T],
    A: &CscMatrix<T>,
    b: &[T],
    cone_types: &[SupportedConeT<T>],
) {
    let m = b.len();
    let n = q.len();
    let p = cone_types.iter().fold(0, |acc, cone| acc + cone.nvars());

    assert!(m == A.nrows(), "A and b incompatible dimensions.");
    assert!(
        p == m,
        "Constraint dimensions inconsistent with size of cones."
    );
    assert!(n == A.ncols(), "A and q incompatible dimensions.");
    assert!(n == P.ncols(), "P and q incompatible dimensions.");
    assert!(P.is_square(), "P not square.");
}