pardiso_wrapper/
enums.rs

1#[repr(i32)]
2#[derive(Debug, Clone, Copy, Default)]
3pub enum MatrixType {
4    RealStructurallySymmetric = 1,
5    RealSymmetricPositiveDefinite = 2,
6    #[default]
7    RealSymmetricIndefinite = -2,
8    ComplexStructurallySymmetric = 3,
9    ComplexHermitianPositiveDefinite = 4,
10    ComplexHermitianIndefinite = -4,
11    ComplexSymmetric = 6,
12    RealNonsymmetric = 11,
13    ComplexNonsymmetric = 13,
14}
15
16impl MatrixType {
17    pub fn is_real(&self) -> bool {
18        matches!(
19            self,
20            MatrixType::RealStructurallySymmetric
21                | MatrixType::RealSymmetricPositiveDefinite
22                | MatrixType::RealSymmetricIndefinite
23                | MatrixType::RealNonsymmetric
24        )
25    }
26    pub fn is_complex(&self) -> bool {
27        !self.is_real()
28    }
29    pub fn is_symmetric(&self) -> bool {
30        matches!(
31            self,
32            MatrixType::RealSymmetricPositiveDefinite
33                | MatrixType::RealSymmetricIndefinite
34                | MatrixType::ComplexSymmetric
35        )
36    }
37    pub fn is_hermitian(&self) -> bool {
38        (self.is_symmetric() && self.is_real())
39            || matches!(
40                self,
41                MatrixType::ComplexHermitianPositiveDefinite
42                    | MatrixType::ComplexHermitianIndefinite
43            )
44    }
45}
46
47impl std::fmt::Display for MatrixType {
48    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
49        let name = match self {
50            MatrixType::RealStructurallySymmetric => "Real Structurally Symmetric",
51            MatrixType::RealSymmetricPositiveDefinite => "Real Symmetric Positive Definite",
52            MatrixType::RealSymmetricIndefinite => "Real Symmetric Indefinite",
53            MatrixType::ComplexStructurallySymmetric => "Complex Structurally Symmetric",
54            MatrixType::ComplexHermitianPositiveDefinite => "Complex Hermitian Positive Definite",
55            MatrixType::ComplexHermitianIndefinite => "Complex Hermitian Indefinite",
56            MatrixType::ComplexSymmetric => "Complex Symmetric",
57            MatrixType::RealNonsymmetric => "Real Nonsymmetric",
58            MatrixType::ComplexNonsymmetric => "Complex Nonsymmetric",
59        };
60        write!(f, "{name}")
61    }
62}
63
64#[repr(i32)]
65#[derive(Debug, Clone, Copy, Default)]
66pub enum Phase {
67    #[default]
68    Analysis = 11,
69    AnalysisNumFact = 12,
70    AnalysisNumFactSolveRefine = 13,
71    NumFact = 22,
72    SelectedInversion = -22,
73    NumFactSolveRefine = 23,
74    SolveIterativeRefine = 33,
75    SolveIterativeRefineOnlyForward = 331,
76    SolveIterativeRefineOnlyDiag = 332,
77    SolveIterativeRefineOnlyBackward = 333,
78    ReleaseLUandMNUM = 0,
79    ReleaseAll = -1,
80}
81
82impl std::fmt::Display for Phase {
83    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
84        let name = match self {
85            Phase::Analysis => "Analysis",
86            Phase::AnalysisNumFact => "Analysis, Numerical Factorization",
87            Phase::AnalysisNumFactSolveRefine => {
88                "Analysis, Numerical Factorization, and Solve with Refine"
89            }
90            Phase::NumFact => "Numerical Factorization",
91            Phase::SelectedInversion => "Selected Inversion",
92            Phase::NumFactSolveRefine => "Numerical Factorization and Solve with Refine",
93            Phase::SolveIterativeRefine => "Solve with Iterative Refinement",
94            Phase::SolveIterativeRefineOnlyForward => "Solve with Iterative Refinement (Forward)",
95            Phase::SolveIterativeRefineOnlyDiag => "Solve with Iterative Refinement (Diagonal)",
96            Phase::SolveIterativeRefineOnlyBackward => "Solve with Iterative Refinement (Backward)",
97            Phase::ReleaseLUandMNUM => "Release LU and MNUM",
98            Phase::ReleaseAll => "Release All",
99        };
100        write!(f, "{name}")
101    }
102}
103
104#[repr(i32)]
105#[derive(Debug, Clone, Copy, Default)]
106pub enum MessageLevel {
107    #[default]
108    Off = 0,
109    On = 1,
110}
111
112#[repr(i32)]
113#[derive(Debug, Clone, Copy, Default)]
114pub enum SolverType {
115    #[default]
116    Direct = 0,
117    Iterative = 1,
118}