interiors 0.1.1

Primal-Dual Interior Point Method for Nonlinear Programming
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

use anyhow::Result;
use sparsetools::csr::CSR;
use spsolve::Solver;

use crate::common::{Lambda, Options};
use crate::ipm::nlp;
use crate::math::dot;
use crate::traits::{ObjectiveFunction, ProgressMonitor};

struct LinearObjectiveFunction {
    nx: usize,
    c: Vec<f64>,
}

impl ObjectiveFunction for LinearObjectiveFunction {
    fn f(&self, x: &[f64], hessian: bool) -> (f64, Vec<f64>, Option<CSR<usize, f64>>) {
        let f = dot(&self.c, &x);
        let df = self.c.to_owned();

        if !hessian {
            (f, df, None)
        } else {
            (f, df, Some(CSR::with_size(self.nx, self.nx)))
        }
    }
}

/// Linear Program solver based on an interior point method.
///
/// Solve the following LP (linear programming) problem:
///
/// ```txt
///       min c'*x
///        x
/// ```
///
/// subject to
///
/// ```txt
///       l <= A*x <= u       (linear constraints)
///       xmin <= x <= xmax   (variable bounds)
/// ```
pub fn lp<S>(
    c: Option<&Vec<f64>>,
    a_mat: &CSR<usize, f64>,
    l: &[f64],
    u: &[f64],
    xmin: &[f64],
    xmax: &[f64],
    x0: &[f64],
    solver: &S,
    progress: Option<&dyn ProgressMonitor>,
    opt: &Options,
) -> Result<(Vec<f64>, f64, bool, usize, Lambda)>
where
    S: Solver<usize, f64>,
{
    // Define nx, set default values for c and x0.
    let nx = a_mat.cols();
    // let nx = if a_mat.is_some() && a_mat.unwrap().nnz() != 0 {
    //     a_mat.unwrap().cols()
    // } else if let Some(xmin) = xmin.as_ref() {
    //     xmin.len()
    // } else if let Some(xmax) = xmax.as_ref() {
    //     xmax.len()
    // } else {
    //     return Err(format_err!(
    //         "LP problem must include constraints or variable bounds"
    //     ));
    // };

    let lp = LinearObjectiveFunction {
        nx,
        c: match c {
            Some(c) => c.to_owned(),
            None => vec![0.0; nx],
        },
    };

    nlp(
        &lp, &x0, a_mat, l, u, xmin, xmax, None, solver, opt, progress,
    )
}