semiflow 0.15.0-beta

no_std Rust PDE solver: evolution equations via Chernoff approximation of operator semigroups (heat, diffusion, Schrodinger)
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

//! R4 zero-alloc gate: `SchrodingerChernoff::apply_into` in steady state.
//!
//! Contract (wave-b-advanced-semigroups.md §3.4): the 12 f64 working buffers for
//! the Crank-Nicolson kinetic step are pre-allocated in `SchrodingerChernoff::new()`
//! and reused via `RefCell` on every `apply_into` call. Zero heap allocations per
//! step in steady state.
//!
//! Strategy: construct `SchrodingerChernoff` + `SchrodingerState` outside the
//! measured block, warm-up once (this ensures the `RefCell`'s internal Vecs have
//! sufficient capacity for size N), then measure allocations for a second identical
//! call.
//!
//! See ADR-0057 Amendment 1 and R4 zero-alloc invariant.

#![allow(clippy::cast_precision_loss)]
#![allow(clippy::cast_lossless)]

use allocation_counter::{self, AllocationInfo};
use semiflow::{
    diffusion4::Diffusion4thChernoff, ChernoffFunction, Grid1D, GridFn1D, SchrodingerChernoff,
    SchrodingerState, ScratchPool,
};

// ---------------------------------------------------------------------------
// Helper
// ---------------------------------------------------------------------------

fn make_schr_f64(n: usize) -> SchrodingerChernoff<f64> {
    let grid = Grid1D::new(-5.0_f64, 5.0, n).unwrap();
    let kinetic = Diffusion4thChernoff::new(|_| 0.5, |_| 0.0, |_| 0.0, 0.5, grid);
    SchrodingerChernoff::new(kinetic, |x: f64| 0.5 * x * x).unwrap()
}

fn make_state_f64(schr: &SchrodingerChernoff<f64>) -> SchrodingerState<f64> {
    let grid = schr.kinetic().grid;
    let n = grid.n;
    let psi_re = GridFn1D::from_fn(grid, |x: f64| (-x * x / 8.0).exp());
    let psi_im = GridFn1D {
        values: alloc::vec![0.0_f64; n],
        grid,
    };
    SchrodingerState { psi_re, psi_im }
}

extern crate alloc;

// ---------------------------------------------------------------------------
// 0 allocs after warm-up (f64)
// ---------------------------------------------------------------------------

#[test]
fn schrodinger_apply_into_zero_alloc_steady_f64() {
    let n = 64usize;
    let schr = make_schr_f64(n);
    let src = make_state_f64(&schr);
    let mut dst = src.clone();
    let mut pool = ScratchPool::<f64>::new();

    // Warm-up: the RefCell's pre-allocated Vecs gain capacity for N nodes.
    schr.apply_into(0.01_f64, &src, &mut dst, &mut pool)
        .expect("warm-up");

    // Steady-state measurement: no new allocations expected.
    let info: AllocationInfo = allocation_counter::measure(|| {
        schr.apply_into(0.01_f64, &src, &mut dst, &mut pool)
            .expect("steady-state");
    });

    assert_eq!(
        info.count_total, 0,
        "SchrodingerChernoff f64 steady-state allocated {} times (expected 0)",
        info.count_total
    );
}

// ---------------------------------------------------------------------------
// 0 allocs after warm-up (f32 public API, f64 internal)
// ---------------------------------------------------------------------------

#[test]
fn schrodinger_apply_into_zero_alloc_steady_f32() {
    let n = 64usize;
    let grid = Grid1D::<f32>::new_generic(-5.0_f32, 5.0_f32, n).unwrap();
    let kinetic = Diffusion4thChernoff::<f32>::new_generic(
        (|_: f32| 0.5_f32) as fn(f32) -> f32,
        (|_: f32| 0.0_f32) as fn(f32) -> f32,
        (|_: f32| 0.0_f32) as fn(f32) -> f32,
        0.5,
        grid,
    );
    let schr = SchrodingerChernoff::<f32>::new(kinetic, |x: f32| 0.5_f32 * x * x).unwrap();

    let psi_re = GridFn1D::<f32>::from_fn_generic(grid, |x: f32| (-x * x / 8.0_f32).exp());
    let psi_im = GridFn1D::<f32> {
        values: alloc::vec![0.0_f32; n],
        grid,
    };
    let src = SchrodingerState::<f32> { psi_re, psi_im };
    let mut dst = src.clone();
    let mut pool = ScratchPool::<f32>::new();

    // Warm-up: f64 internal Vecs gain capacity for N nodes.
    schr.apply_into(0.01_f32, &src, &mut dst, &mut pool)
        .expect("warm-up");

    // Steady-state measurement.
    let info: AllocationInfo = allocation_counter::measure(|| {
        schr.apply_into(0.01_f32, &src, &mut dst, &mut pool)
            .expect("steady-state");
    });

    assert_eq!(
        info.count_total, 0,
        "SchrodingerChernoff f32 steady-state allocated {} times (expected 0)",
        info.count_total
    );
}