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

use super::*;

#[test]
fn test1() {
    let ck = 1.091414141414142;
    let suppressalg = 0;
    let kk = 5;
    #[rustfmt::skip]
        let ida_phi = array![
            [ 3.634565317158998e-05, 1.453878335134203e-10, 0.9999636542014404, ],
            [ -6.530333550677049e-06, -2.612329458968465e-11, 6.530359673556191e-06, ],
            [ 1.946442728026142e-06, 7.786687275994346e-12, -1.946450515496441e-06, ],
            [ -8.097632208221231e-07, -3.239585549038764e-12, 8.097664556005615e-07, ],
            [ 3.718130977075839e-07, 1.487573462300438e-12, -3.71814615793545e-07, ],
            [ -3.24421895454213e-07, -1.297915245220823e-12, 3.244230624265827e-07, ],
        ];
    let ida_ee = array![
        2.65787533317467e-07,
        1.063275845801634e-12,
        -2.657884288386138e-07,
    ];
    let ida_ewt = array![73343005.56993243, 999999.985461217, 9901.346408259429];
    let ida_sigma = array![
        1.0,
        0.6666666666666666,
        0.6666666666666666,
        0.888888888888889,
        1.422222222222222,
        2.585858585858586,
    ];
    let knew = 4;
    let err_k = 29.10297975314245;
    let err_km1 = 3.531162835377502;

    let problem = Dummy {};
    let mut ida: Ida<_, linear::Dense<_>, nonlinear::Newton<_>, _> = Ida::new(
        problem,
        array![0., 0., 0.],
        array![0., 0., 0.],
        TolControlSS::new(1e-4, 1e-4),
    );

    // Set preconditions:
    ida.ida_kk = kk;
    ida.ida_suppressalg = suppressalg > 0;
    ida.ida_phi.assign(&ida_phi);
    ida.ida_ee.assign(&ida_ee);
    ida.nlp.ida_ewt.assign(&ida_ewt);
    ida.ida_sigma.assign(&ida_sigma);

    // Call the function under test
    let (err_k_new, err_km1_new, _) = ida.test_error(ck).expect_err("Should be TestFail");

    assert_eq!(ida.ida_knew, knew);
    assert_nearly_eq!(err_k_new, err_k);
    assert_nearly_eq!(err_km1_new, err_km1);
}

#[test]
fn test2() {
    //--- IDATestError Before:
    let ck = 0.2025812352167927;
    let suppressalg = 0;
    let kk = 4;
    #[rustfmt::skip]
        let ida_phi = array![
            [ 3.051237735052657e-05, 1.220531905117091e-10, 0.9999694875005963, ],
            [ -2.513114849098281e-06, -1.005308974226734e-11, 2.513124902721765e-06, ],
            [ 4.500284453718991e-07, 1.800291970640913e-12, -4.500302448499092e-07, ],
            [ -1.366709389821433e-07, -5.467603693902342e-13, 1.366714866794709e-07, ],
            [ 7.278821769100639e-08, 2.911981566628798e-13, -7.278850816613011e-08, ],
            [ -8.304741244343501e-09, -3.324587131187576e-14, 8.304772990651073e-09, ],
        ];
    let ida_ee = array![
        -2.981302228744271e-08,
        -1.192712676406388e-13,
        2.981313872620108e-08,
    ];
    let ida_ewt = array![76621085.31777237, 999999.9877946811, 9901.289220872719,];
    let ida_sigma = array![
        1.0,
        0.5,
        0.3214285714285715,
        0.2396514200444849,
        0.1941955227762807,
        2.585858585858586,
    ];
    //--- IDATestError After:
    let knew = 4;
    let err_k = 0.2561137489433976;
    let err_km1 = 0.455601916633899;
    let nflag = true;

    let problem = Dummy {};
    let mut ida: Ida<_, linear::Dense<_>, nonlinear::Newton<_>, _> = Ida::new(
        problem,
        array![0., 0., 0.],
        array![0., 0., 0.],
        TolControlSS::new(1e-4, 1e-4),
    );

    // Set preconditions:
    ida.ida_kk = kk;
    ida.ida_suppressalg = suppressalg > 0;
    ida.ida_phi.assign(&ida_phi);
    ida.ida_ee.assign(&ida_ee);
    ida.nlp.ida_ewt.assign(&ida_ewt);
    ida.ida_sigma.assign(&ida_sigma);

    // Call the function under test
    let (err_k_new, err_km1_new, nflag_new) = ida.test_error(ck).unwrap();

    assert_eq!(ida.ida_knew, knew);
    assert_nearly_eq!(err_k_new, err_k);
    assert_nearly_eq!(err_km1_new, err_km1);
    assert_eq!(nflag_new, nflag);
}