ida 0.1.1

A pure Rust port of the Implicit Differential-Algebraic solver from the Sundials suite.
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
115
116
117
118
119
120
121
122
123
124
125
126

use failure::Fail;

#[derive(Debug)]
pub enum Recoverable {
    /// IDA_RES_RECVR
    Residual,
    /// IDA_LSETUP_RECVR
    LSetup,
    /// IDA_LSOLVE_RECVR
    LSolve,
    /// IDA_CONSTR_RECVR
    Constraint,
    /// IDA_NLS_SETUP_RECVR
    NLSSetup,
}

#[derive(Debug, Fail)]
pub enum IdaError {
    // ERROR_TEST_FAIL
    #[fail(display = "Error Test Failed")]
    TestFail,

    // LSETUP_ERROR_NONRECVR
    // IDA_ERR_FAIL
    /// IDA_REP_RES_ERR:
    #[fail(
        display = "The user's residual function repeatedly returned a recoverable error flag, \
                   but the solver was unable to recover"
    )]
    RepeatedResidualError {},

    /// IDA_ILL_INPUT
    #[fail(display = "One of the input arguments was illegal. See printed message")]
    IllegalInput { msg: String },

    /// IDA_LINIT_FAIL
    #[fail(display = "The linear solver's init routine failed")]
    LinearInitFail {},

    /// IDA_BAD_EWT
    #[fail(
        display = "Some component of the error weight vector is zero (illegal), either for the \
                   input value of y0 or a corrected value"
    )]
    BadErrorWeightVector {},

    /// IDA_RES_FAIL
    #[fail(display = "The user's residual routine returned a non-recoverable error flag")]
    ResidualFail {},

    /// IDA_FIRST_RES_FAIL
    #[fail(
        display = "The user's residual routine returned a recoverable error flag on the first \
                   call, but IDACalcIC was unable to recover"
    )]
    FirstResidualFail {},

    /// IDA_LSETUP_FAIL
    #[fail(display = "The linear solver's setup routine had a non-recoverable error")]
    LinearSetupFail {},

    /// IDA_LSOLVE_FAIL
    #[fail(display = "The linear solver's solve routine had a non-recoverable error")]
    LinearSolveFail {},

    /// IDA_NO_RECOVERY
    #[fail(
        display = "The user's residual routine, or the linear solver's setup or solve routine \
                   had a recoverable error, but IDACalcIC was unable to recover"
    )]
    NoRecovery {},

    #[fail(display = "Recoverable failure")]
    RecoverableFail { rec_type: Recoverable },

    /// IDA_CONSTR_FAIL
    /// The inequality constraints were violated, and the solver was unable to recover.
    #[fail(
        display = "IDACalcIC was unable to find a solution satisfying the inequality constraints"
    )]
    ConstraintFail {},

    /// IDA_LINESEARCH_FAIL
    #[fail(
        display = "The Linesearch algorithm failed to find a solution with a step larger than \
                   steptol in weighted RMS norm"
    )]
    LinesearchFail {},

    /// IDA_CONV_FAIL
    #[fail(display = "IDACalcIC failed to get convergence of the Newton iterations")]
    ConvergenceFail {},

    ///MSG_BAD_K
    #[fail(display = "Illegal value for k.")]
    BadK {},

    //MSG_NULL_DKY       "dky = NULL illegal."
    ///MSG_BAD_T
    #[fail(
        display = "Illegal value for t: t = {} is not between tcur - hu = {} and tcur = {}.",
        t, tdiff, tcurr
    )]
    BadTimeValue { t: f64, tdiff: f64, tcurr: f64 },

    #[fail(
        display = "At t = {}, the rootfinding routine failed in an unrecoverable manner.",
        t
    )]
    RootFunctionFail { t: f64 },

    ///MSG_BAD_TSTOP
    #[fail(
        display = "The value tstop = {} is behind current t = {} in the direction of integration.",
        tstop, t
    )]
    BadStopTime { tstop: f64, t: f64 },

    ///MSG_TOO_MUCH_ACC
    #[fail(display = "At t = {} too much accuracy requested.", t)]
    TooMuchAccuracy { t: f64 },

    ///MSG_CLOSE_ROOTS
    #[fail(display = "Root found at and very near {}.", t)]
    CloseRoots { t: f64 },
}