differential-equations 0.6.1

A Rust library for solving differential equations.
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

//! Default Solout Implementation, e.g. outputting solutions at calculated steps.
//!
//! This module provides the default output strategy, which returns solution points
//! at each step taken by the solver without any interpolation.

use super::*;

/// The default output handler that returns solution values at each solver step.
///
/// # Overview
///
/// `DefaultSolout` is the simplest output handler that captures the solution
/// at each internal step calculated by the solver. It doesn't perform any
/// interpolation or filtering - it simply records the exact points that the
/// solver naturally computes during integration.
///
/// # Features
///
/// - Captures all solver steps in the output
/// - No interpolation overhead
/// - Gives the raw, unmodified solver trajectory
///
/// # Example
///
/// ```rust
/// use differential_equations::prelude::*;
/// use differential_equations::solout::DefaultSolout;
///
/// // Simple exponential growth
/// struct ExponentialGrowth;
///
/// impl ODE for ExponentialGrowth {
///     fn diff(&self, _t: f64, y: &f64, dydt: &mut f64) {
///         *dydt = *y; // dy/dt = y
///     }
/// }
///
/// // Create the system and solver
/// let system = ExponentialGrowth;
/// let t0 = 0.0;
/// let tf = 2.0;
/// let y0 = 1.0;
/// let solver = ExplicitRungeKutta::dop853().rtol(1e-6).atol(1e-8);
///
/// // Use the default output handler explicitly
/// let default_output = DefaultSolout::new();
///
/// // Solve with default output
/// let solution = IVP::ode(&system, t0, tf, y0)
///     .solout(default_output)
///     .method(solver)
///     .solve()
///     .unwrap();
///
/// // Note: This is equivalent to the default behavior
/// let solution2 = IVP::ode(&system, t0, tf, y0)
///     .method(ExplicitRungeKutta::dop853().rtol(1e-6).atol(1e-8))
///     .solve()
///     .unwrap();
/// ```
///
/// # Output Characteristics
///
/// The output will contain only the actual steps computed by the solver,
/// which may not be evenly spaced in time. The spacing depends on the solver's
/// adaptive step size control.
///
/// For evenly spaced output points, consider using `EvenSolout` instead.
///
#[derive(Clone, Debug)]
pub struct DefaultSolout {}

impl<T, Y> Solout<T, Y> for DefaultSolout
where
    T: Real,
    Y: State<T>,
{
    fn solout<I>(
        &mut self,
        t_curr: T,
        _t_prev: T,
        y_curr: &Y,
        _y_prev: &Y,
        _interpolator: &mut I,
        solution: &mut Solution<T, Y>,
    ) -> ControlFlag<T, Y>
    where
        I: Interpolation<T, Y> + ?Sized,
    {
        // Output the current time and state to the vectors
        solution.push(t_curr, y_curr.clone());

        // Continue the integration
        ControlFlag::Continue
    }
}

impl Default for DefaultSolout {
    fn default() -> Self {
        Self::new()
    }
}

impl DefaultSolout {
    /// Creates a new DefaultSolout instance.
    ///
    /// This is the simplest output handler that captures solution values
    /// at each step naturally taken by the solver.
    ///
    /// # Returns
    /// * A new `DefaultSolout` instance
    ///
    pub fn new() -> Self {
        DefaultSolout {}
    }
}