Struct Shells 

pub(super) struct Shells<const N: usize> {
    pub(super) sum: Jet<N>,
    error: Jet<N>,
    cancelling: bool,
    pub(super) bound: Rounding<N>,
    count: i32,
    floor: i32,
    last: [f64; 2],
    net: [f64; 2],
    pub(super) settled: bool,
}

One Ewald part summed over cube shells of integer points (Shells::sum), which Shells::extend continues. Below every automatic split (below_automatic), where the parts cancel, a part that stops at SHELL_TOLERANCE of its own sum leaves that much in the complete sum, so both parts continue to SHELL_TOLERANCE of the complete sum, and each part keeps the rounding errors of its additions (add_exactly): next to a lattice point at a zero Bloch vector millions of real-space terms add in phase far below an ulp of it.

Calibrated: continuing the parts this way at every split costs the other splits 5% and gains them 1e-14 of max(|S|, 1).

Fields

sum: Jet<N>

The sum, or with error its leading part.

error: Jet<N>

The rounding errors of the additions to sum since the last shell, where they are kept (cancelling); each shell adds them to sum.

cancelling: bool

Whether the part may cancel against the other, below every automatic split: it then keeps the rounding errors of its additions and counts bound.

bound: Rounding<N>

The rounding bounds of the value and each derivative that its terms predict, in units of epsilon: TERM_ULPS ulps of the moduli of each term, plus the bounds the terms add beyond their relative accuracy.

count: i32

Shells summed so far.

floor: i32

Shells to sum before the convergence test may stop the sum (peak_shells).

last: [f64; 2]

The largest moduli of the value and derivatives that the last two shells added.

net: [f64; 2]

The same of what each of the last two shells added in all, where their terms cancel.

settled: bool

Whether the sum stopped at its shell limit on net instead of last (see Shells::sum).

Implementations

impl<const N: usize> Shells<N>

pub(super) fn sum( dim: usize, [maximum, floor]: [i32; 2], term: &mut impl FnMut([i64; 3], &mut Rounding<N>) -> Result<Jet<N>>, settle: bool, cancelling: bool, ) -> Result<Self>

Sum term over cube shells until two consecutive shells add less than SHELL_TOLERANCE times max(|sum|, 1), but not before floor shells (peak_shells), failing after maximum shells; where cancelling, keep the rounding errors of the additions and count their bounds (Self::bound). With settle a sum at the limit whose last two shells add less than that in all (Self::settled) is returned for the caller to verify: at |k eta| far below the automatic split the real-space terms reach beyond the limit while their Bloch phases cancel them within each shell.

pub(super) fn tail(&self) -> f64

The moduli of the last two shells, or for a sum that settled what they added in all: a bound on what the shells beyond would add.

fn add_compensated(&mut self, value: &Jet<N>)

Adds value to a cancelling sum with the rounding error of that addition, and counts TERM_ULPS of its moduli in Self::bound. Kept out of line, like small_split_kambe, for the sums at other splits.

pub(super) fn extend( &mut self, dim: usize, maximum: i32, term: &mut impl FnMut([i64; 3], &mut Rounding<N>) -> Result<Jet<N>>, scale: Option<f64>, ) -> Result<bool>

Add shells until the last two add less than SHELL_TOLERANCE times scale, or without one each less than that of max(|sum|, 1) as it was then, from Self::floor shells on, and whether they did within maximum shells.

Trait Implementations

impl<const N: usize> Clone for Shells<N>

fn clone(&self) -> Shells<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for Shells<N>

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

Formats the value using the given formatter.

impl<const N: usize> Copy for Shells<N>