clarabel 0.11.1

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
103
104
105

#![allow(non_snake_case)]

use num_traits::Num;
use std::iter::zip;

/// Sparse vector type (internal use only at present)

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct SparseVector<T = f64> {
    /// vector dimension
    pub n: usize,
    /// vector of entry indices
    pub nzind: Vec<usize>,
    /// vector of non-zero vector elements
    pub nzval: Vec<T>,
}

/// Creates a `SparseVector` from a dense slice.
impl<T> SparseVector<T>
where
    T: Num + Copy,
{
    pub fn new(values: &[T]) -> Self {
        let mut nzind = Vec::new();
        let mut nzval = Vec::new();

        let mut n = 0;
        for (i, &v) in values.iter().enumerate() {
            if v != T::zero() {
                nzind.push(i);
                nzval.push(v);
            }
            n += 1;
        }
        SparseVector { n, nzind, nzval }
    }

    #[allow(dead_code)]
    pub fn nnz(&self) -> usize {
        self.nzval.len()
    }

    #[allow(dead_code)]
    pub fn dropzeros(&mut self) {
        let mut writeidx: usize = 0;

        for readidx in 0..self.nzval.len() {
            let val = self.nzval[readidx];
            let idx = self.nzind[readidx];

            // If nonzero and a shift so far, move the value
            if val != T::zero() {
                if writeidx != readidx {
                    self.nzval[writeidx] = val;
                    self.nzind[writeidx] = idx;
                }
                writeidx += 1;
            }
        }

        self.nzind.resize(writeidx, 0);
        self.nzval.resize(writeidx, T::zero());
    }
}

impl<T> From<SparseVector<T>> for Vec<T>
where
    T: Num + Copy,
{
    fn from(sv: SparseVector<T>) -> Vec<T> {
        let mut v = vec![T::zero(); sv.n];
        for (i, nz) in zip(sv.nzind, sv.nzval) {
            v[i] = nz;
        }
        v
    }
}

#[test]
fn test_sparsevector_new() {
    let v = vec![0.1, 0.3, 0.0, 0.0, 0.4, 0.0];

    let vs = SparseVector::new(&v);

    assert_eq!(vs.n, v.len());
    assert_eq!(vs.nzind, vec![0, 1, 4]);
    assert_eq!(vs.nzval, vec![0.1, 0.3, 0.4]);

    let vback: Vec<f64> = vs.into();
    assert_eq!(v, vback);
}

#[test]
fn test_sparsevector_dropzeros() {
    let x = vec![0.1, 0.3, 0.2, 0.0, 0.4, 0.0];
    let y = vec![0.1, 0.3, 0.0, 0.0, 0.4, 0.0];

    let mut xs = SparseVector::new(&x);
    xs.nzval[2] = 0.0;
    xs.dropzeros();

    let ys = SparseVector::new(&y);

    assert_eq!(xs, ys);
}