diffsol-c 0.4.1

A diffsol wrapper featuring runtime scalar/matrix/solver types and a C API
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
106
107
108
109
110
111
112
113
114

// Validation used by py_solve to determine that solver type and matrix type
// combinations are valid.

use diffsol::error::DiffsolError;
use diffsol::{FaerScalar, NalgebraScalar};

use crate::{
    error::DiffsolRtError, linear_solver_type::LinearSolverType, matrix_type::MatrixKind,
    matrix_type::MatrixType,
};

pub(crate) fn validate_linear_solver<
    M: diffsol::Matrix + LuValidator<M> + KluValidator<M> + MatrixKind,
>(
    linear_solver: LinearSolverType,
) -> Result<(), DiffsolRtError> {
    match linear_solver {
        LinearSolverType::Default => Ok(()),
        LinearSolverType::Lu => {
            if !<M as LuValidator<M>>::valid() {
                return Err(DiffsolError::Other(format!(
                    "Lu solver not supported for {}",
                    MatrixType::from_diffsol::<M>().get_name()
                ))
                .into());
            }
            Ok(())
        }
        LinearSolverType::Klu => {
            if !<M as KluValidator<M>>::valid() {
                return Err(DiffsolError::Other(format!(
                    "Klu solver not supported for {}",
                    MatrixType::from_diffsol::<M>().get_name()
                ))
                .into());
            }
            Ok(())
        }
    }
}

pub(crate) trait KluValidator<M: diffsol::Matrix> {
    type LS: diffsol::LinearSolver<M>;
    fn valid() -> bool {
        false
    }
}

// Known issue: FaerSparseMat currently only supports KLU for f64
#[cfg(feature = "suitesparse")]
impl KluValidator<diffsol::FaerSparseMat<f64>> for diffsol::FaerSparseMat<f64> {
    type LS = diffsol::KLU<diffsol::FaerSparseMat<f64>>;
    fn valid() -> bool {
        true
    }
}

#[cfg(feature = "suitesparse")]
impl KluValidator<diffsol::FaerSparseMat<f32>> for diffsol::FaerSparseMat<f32> {
    type LS = diffsol::FaerSparseLU<f32>;
    fn valid() -> bool {
        false
    }
}

#[cfg(not(feature = "suitesparse"))]
impl<T: FaerScalar> KluValidator<diffsol::FaerSparseMat<T>> for diffsol::FaerSparseMat<T> {
    type LS = diffsol::FaerSparseLU<T>;
    fn valid() -> bool {
        false
    }
}

impl<T: NalgebraScalar> KluValidator<diffsol::NalgebraMat<T>> for diffsol::NalgebraMat<T> {
    type LS = diffsol::NalgebraLU<T>;
    fn valid() -> bool {
        false
    }
}

impl<T: FaerScalar> KluValidator<diffsol::FaerMat<T>> for diffsol::FaerMat<T> {
    type LS = diffsol::FaerLU<T>;
    fn valid() -> bool {
        false
    }
}

pub(crate) trait LuValidator<M: diffsol::Matrix> {
    type LS: diffsol::LinearSolver<M>;
    fn valid() -> bool {
        false
    }
}

impl<T: NalgebraScalar> LuValidator<diffsol::NalgebraMat<T>> for diffsol::NalgebraMat<T> {
    type LS = diffsol::NalgebraLU<T>;
    fn valid() -> bool {
        true
    }
}

impl<T: FaerScalar> LuValidator<diffsol::FaerMat<T>> for diffsol::FaerMat<T> {
    type LS = diffsol::FaerLU<T>;
    fn valid() -> bool {
        true
    }
}

impl<T: FaerScalar> LuValidator<diffsol::FaerSparseMat<T>> for diffsol::FaerSparseMat<T> {
    type LS = diffsol::FaerSparseLU<T>;
    fn valid() -> bool {
        true
    }
}