conspire/math/integrate/dae/explicit/variable_step/bogacki_shampine/
mod.rs

1use crate::math::{
2    Scalar, Tensor, TensorVec, Vector,
3    integrate::{
4        BogackiShampine, ExplicitDaeVariableStepExplicit, ExplicitDaeVariableStepFirstSameAsLast,
5    },
6};
7use std::ops::{Mul, Sub};
8
9impl<Y, Z, U, V> ExplicitDaeVariableStepExplicit<Y, Z, U, V> for BogackiShampine
10where
11    Self: ExplicitDaeVariableStepFirstSameAsLast<Y, Z, U, V>,
12    Y: Tensor,
13    Z: Tensor,
14    U: TensorVec<Item = Y>,
15    V: TensorVec<Item = Z>,
16    for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,
17{
18    fn slopes_solve(
19        mut evolution: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>,
20        mut solution: impl FnMut(Scalar, &Y, &Z) -> Result<Z, String>,
21        y: &Y,
22        z: &Z,
23        t: Scalar,
24        dt: Scalar,
25        k: &mut [Y],
26        y_trial: &mut Y,
27        z_trial: &mut Z,
28    ) -> Result<(), String> {
29        *y_trial = &k[0] * (0.5 * dt) + y;
30        *z_trial = solution(t + 0.5 * dt, y_trial, z)?;
31        k[1] = evolution(t + 0.5 * dt, y_trial, z_trial)?;
32        *y_trial = &k[1] * (0.75 * dt) + y;
33        *z_trial = solution(t + 0.75 * dt, y_trial, z_trial)?;
34        k[2] = evolution(t + 0.75 * dt, y_trial, z_trial)?;
35        *y_trial = (&k[0] * 2.0 + &k[1] * 3.0 + &k[2] * 4.0) * (dt / 9.0) + y;
36        *z_trial = solution(t + dt, y_trial, z_trial)?;
37        Ok(())
38    }
39    fn slopes_solve_and_error(
40        &self,
41        evolution: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>,
42        solution: impl FnMut(Scalar, &Y, &Z) -> Result<Z, String>,
43        y: &Y,
44        z: &Z,
45        t: Scalar,
46        dt: Scalar,
47        k: &mut [Y],
48        y_trial: &mut Y,
49        z_trial: &mut Z,
50    ) -> Result<Scalar, String> {
51        Self::slopes_solve_and_error_fsal(evolution, solution, y, z, t, dt, k, y_trial, z_trial)
52    }
53    fn step_solve(
54        &self,
55        _: impl FnMut(Scalar, &Y, &Z) -> Result<Y, String>,
56        y: &mut Y,
57        z: &mut Z,
58        t: &mut Scalar,
59        y_sol: &mut U,
60        z_sol: &mut V,
61        t_sol: &mut Vector,
62        dydt_sol: &mut U,
63        dt: &mut Scalar,
64        k: &mut [Y],
65        y_trial: &Y,
66        z_trial: &Z,
67        e: Scalar,
68    ) -> Result<(), String> {
69        self.step_solve_fsal(
70            y, z, t, y_sol, z_sol, t_sol, dydt_sol, dt, k, y_trial, z_trial, e,
71        )
72    }
73}
74
75impl<Y, Z, U, V> ExplicitDaeVariableStepFirstSameAsLast<Y, Z, U, V> for BogackiShampine
76where
77    Y: Tensor,
78    Z: Tensor,
79    U: TensorVec<Item = Y>,
80    V: TensorVec<Item = Z>,
81    for<'a> &'a Y: Mul<Scalar, Output = Y> + Sub<&'a Y, Output = Y>,
82{
83}