Struct ReflectedHeatChernoff 

pub struct ReflectedHeatChernoff<C, R, F = f64>
where
    C: ChernoffFunction<F, S = GridFn1D<F>>,
    R: ReflectingRegion<F>,
    F: SemiflowFloat,
{
    pub region: R,
    /* private fields */
}

Chernoff wrapper for Neumann (reflecting) BCs via the image method.

F_refl(τ) f = C(τ)f + C(τ)(f ∘ σ_R) (Walsh 1986 §3.4, math.md §25.3).

order() returns inner.order(): reflection preserves order for symmetric (Neumann) BCs (Proposition 25.1 — commutator vanishes).

v2.8 scope

Concrete ChernoffFunction<f64> impl for: ReflectedHeatChernoff<DiffusionChernoff<f64>, HalfSpaceRegion<f64, 1>>. Generic-C impls deferred to v2.9 (requires CoordinateState<F, D> supertrait).

Fields

region: R

The reflecting region. Stored for future multi-D GridFn2D/GridFn3D impls (deferred to v2.9) and for public inspection by callers.

Implementations

impl<C, R, F> ReflectedHeatChernoff<C, R, F>

where C: ChernoffFunction<F, S = GridFn1D<F>>, R: ReflectingRegion<F>, F: SemiflowFloat,

pub fn new(inner: C, region: R) -> Result<Self, SemiflowError>

Wrap inner Chernoff function with reflecting region region.

Errors

Returns Err if the inner or region is invalid; always Ok for pre-validated inputs.

Trait Implementations

impl ChernoffFunction for ReflectedHeatChernoff<DiffusionChernoff<f64>, HalfSpaceRegion<f64, 1>, f64>

Image-method apply_into for the D=1 half-space on a one-sided grid.

Implementation note (half-line [0, L] grid)

math.md §25.3 specifies a 4-step full-line algorithm where the ghost h = f ∘ σ_R has support at the OUTSIDE (negative-x) nodes of a full-line grid. For the common case of a one-sided grid [0, L] (all nodes inside R), there are no outside nodes, so ghost = 0 and the 4-step algorithm reduces to a plain inner Chernoff step — NOT the correct Neumann semigroup.

The correct Neumann semigroup on a [0, L] half-line grid is obtained by replacing src.grid.boundary with BoundaryPolicy::Reflect before the inner Chernoff step. This gives the DiffusionChernoff stencil access to the even extension of src at the left boundary (x = 0), which is exactly what the full-line image method computes when restricted to x ∈ [0, L].

Equivalence proof sketch (single node x = 0, pure-heat stencil):

Full-line image method at x = 0:
  step1 = W0*f(0) + W1*f(h)  + W2*f(h')         (src = 0 for x < 0)
  step3 = W1*f(h) + W2*f(h')                     (ghost = f(|x|) for x < 0)
  sum   = W0*f(0) + 2*W1*f(h) + 2*W2*f(h')

Half-line Reflect step at x = 0:
  C_reflect*f(0) = W0*f(0) + W1*(f(h) + f(h)) + W2*(f(h') + f(h'))
                 = W0*f(0) + 2*W1*f(h)          + 2*W2*f(h')  == sum

The equivalence holds at every grid node (interior nodes are unaffected by boundary policy for small tau).

fn order(&self) -> u32

Order matches inner (Proposition 25.1 — no cap for Neumann BCs).

fn growth(&self) -> Growth<f64>

Growth: (inner_M, inner_ω) — no doubling on a one-sided grid because the Reflect-boundary step is a single contraction of the inner Chernoff.

type S = GridFn1D

The state space type on which S(tau) acts.

fn apply_into( &self, tau: f64, src: &Self::S, dst: &mut Self::S, scratch: &mut ScratchPool<f64>, ) -> Result<(), SemiflowError>

Zero-alloc apply: dst := S(tau) src. Caller provides pre-allocated dst and a scratch pool for hot-path temporaries (ADR-0041 Wave 1).

fn apply_adjoint_into( &self, tau: F, src: &Self::S, dst: &mut Self::S, scratch: &mut ScratchPool<F>, ) -> Result<(), SemiflowError>

Apply the TRANSPOSE (adjoint) semigroup exp(τ Aᵀ) src into dst.

fn plan_len(&self, tau: F, proto: &Self::S) -> Option<(usize, usize)>

Sizes (data, work) of a τ-keyed step plan for states shaped like proto (ADR-0215), or None (default) when the engine has no plan.

fn fill_plan( &self, tau: F, proto: &Self::S, data: &mut [F], ) -> Result<(), SemiflowError>

Fill data (length plan_len(..).0) for (τ, proto).

fn apply_planned_into( &self, tau: F, data: &[F], work: &mut [F], src: &Self::S, dst: &mut Self::S, scratch: &mut ScratchPool<F>, ) -> Result<(), SemiflowError>

dst := S(τ) src with a plan data filled by THIS engine for τ, and a work area of length plan_len(..).1. A plan that does not match — another τ, sampling grid, length or engine state, or a truncated buffer — falls back to apply_into. Default: apply_into.

impl<C, R, F> Clone for ReflectedHeatChernoff<C, R, F>

where C: ChernoffFunction<F, S = GridFn1D<F>> + Clone, R: ReflectingRegion<F> + Clone, F: SemiflowFloat + Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C, R, F> Debug for ReflectedHeatChernoff<C, R, F>

where C: ChernoffFunction<F, S = GridFn1D<F>> + Debug, R: ReflectingRegion<F> + Debug, F: SemiflowFloat + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.