rustpower-sol-klu 0.1.3

A very basic KLU-based sparse linear solver unsafe wrapper.
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

#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]

use rustpower_klu_sys::*;
pub struct KLUSolver {
    pub common: *mut klu_l_common,
    pub symbolic: *mut klu_l_symbolic,
    pub numeric: *mut klu_l_numeric,
}

impl Default for KLUSolver {
    fn default() -> Self {
        unsafe {
            let common_ptr = Box::into_raw(Box::new(klu_l_common::default()));
            klu_l_defaults(common_ptr);
            
            KLUSolver {
                common: common_ptr,
                symbolic: std::ptr::null_mut(),
                numeric: std::ptr::null_mut(),
            }
        }
    }
}
impl Drop for KLUSolver {
    fn drop(&mut self) {
        unsafe {
            klu_l_free_symbolic(&mut self.symbolic as *mut *mut klu_l_symbolic, self.common);
            klu_l_free_numeric(&mut self.numeric as *mut *mut klu_l_numeric, self.common);
            
            if !self.common.is_null() {
                let _ = Box::from_raw(self.common);
            }
        };
    }
}
impl KLUSolver {
    pub unsafe fn solve_sym(&mut self, Ap: *mut i64, Ai: *mut i64, n: i64) -> i64 {
        if !self.symbolic.is_null() {
            klu_l_free_symbolic(&mut self.symbolic as *mut *mut klu_l_symbolic, self.common);
        }
        self.symbolic = klu_l_analyze(n, Ap, Ai, self.common);
        (*self.common).status.into()
    }
    pub unsafe fn factor(&mut self, Ap: *mut i64, Ai: *mut i64, Ax: *mut f64) -> i64 {
        if !self.numeric.is_null() {
            klu_l_free_numeric(&mut self.numeric as *mut *mut klu_l_numeric, self.common);
        }
        self.numeric = klu_l_factor(Ap, Ai, Ax, self.symbolic, self.common);
        (*self.common).status.into()
    }

    pub unsafe fn refactor(&mut self, Ap: *mut i64, Ai: *mut i64, Ax: *mut f64, _n: i64) -> i64 {
        klu_l_refactor(Ap, Ai, Ax, self.symbolic, self.numeric, self.common);
        (*self.common).status.into()
    }

    pub unsafe fn solve(&mut self, b: *mut f64, n: i64, bn: i64) -> i64 {
        klu_l_solve(self.symbolic, self.numeric, n, bn, b, self.common);
        (*self.common).status.into()
    }
    pub fn reset(&mut self) {
        unsafe {
            klu_l_free_symbolic(&mut self.symbolic as *mut *mut klu_l_symbolic, self.common);

            klu_l_free_numeric(&mut self.numeric as *mut *mut klu_l_numeric, self.common);

            *self.common = klu_l_common::default();
            self.symbolic = std::ptr::null_mut();
            self.numeric = std::ptr::null_mut();

            klu_l_defaults(self.common);
        }
    }
}
#[test]
fn drop_test() {
    let klu = KLUSolver::default();
    drop(klu);
}
#[test]
fn reset_test() {
    let mut klu = KLUSolver::default();
    klu.reset();
}
unsafe impl Send for KLUSolver {}
unsafe impl Sync for KLUSolver {}