Enum QuadratureRule 

pub enum QuadratureRule {
    Trapezoid {
        panels: usize,
    },
    Simpson {
        panels: usize,
    },
    GaussLegendre {
        order: GaussOrder,
        panels: usize,
    },
}

Which fixed rule quadrature_batch applies to every lane.

All three are composite rules over equal subintervals of each lane’s own interval, and all three cost a fixed, data-independent number of integrand evaluations per lane — which is what makes them branch-free, and the only part of this module that would map cleanly onto a GPU.

A panels count of 0 is treated as 1; there is no error path for it, because it is a compile-time-shaped parameter rather than data.

Variant	Evaluations per lane	Error order	Exact for
Trapezoid	panels + 1	O(h^2)	linear integrands
Simpson	2 * panels + 1	O(h^4)	cubics
GaussLegendre	panels * order	O(h^(2n))	degree 2n - 1

Relationship to the workspace’s other Simpson

outram-park-fork-dwsim-libs’s simpson_integrate is a faithful port of OPEM’s rule including its documented flaw: it applies the 1, 4, 2, ..., 4, 1 weights without requiring an odd sample count, which silently degrades the order to O(h) for an even one. Simpson here counts panels of two subintervals each, so the sample count is odd by construction and that failure cannot occur. The composite-over-equal- subintervals convention is shared; the sample-slice interface and the bug are not.

Units

Dimensionless — a mode selector plus a count.

Variants

Trapezoid

Composite trapezoid over panels equal subintervals.

The cheapest rule and the only one worth using when the integrand is sampled rather than smooth. Second-order accurate.

Fields

panels: usize

Number of equal subintervals, >= 1 (0 is treated as 1).

Simpson

Composite Simpson over panels panels, each spanning two equal subintervals, so 2 * panels subintervals in total.

Fourth-order accurate and exact for cubics. Counting panels rather than samples is what makes the even-sample-count error impossible.

Fields

panels: usize

Number of two-subinterval Simpson panels, >= 1 (0 is treated as 1).

GaussLegendre

Composite Gauss-Legendre: panels equal subintervals, each integrated by an order-point rule.

The best accuracy per evaluation for a smooth integrand, and the rule to reach for by default. Gauss rules never evaluate the interval endpoints, so an integrand that is unbounded but integrable at a or b is handled without special-casing — the same property raffles relies on for quantile-function moments.

Fields

order: GaussOrder

Nodes per subinterval.

panels: usize

Number of equal subintervals, >= 1 (0 is treated as 1).

Implementations

impl QuadratureRule

pub const fn evaluations(self) -> usize

Integrand evaluations this rule performs per lane, dimensionless.

Fixed and data-independent — that is the defining property of this enum.

Example

use outram_foam_basic_lib::ode::parallel::{GaussOrder, QuadratureRule};

assert_eq!(QuadratureRule::Trapezoid { panels: 4 }.evaluations(), 5);
assert_eq!(QuadratureRule::Simpson { panels: 4 }.evaluations(), 9);
assert_eq!(
    QuadratureRule::GaussLegendre { order: GaussOrder::G5, panels: 4 }.evaluations(),
    20
);

pub const fn label(self) -> &'static str

A short human-readable label, for benchmark tables and log lines.

Trait Implementations

impl Clone for QuadratureRule

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for QuadratureRule

impl Debug for QuadratureRule

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

Formats the value using the given formatter.

impl Eq for QuadratureRule

impl Hash for QuadratureRule

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for QuadratureRule

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for QuadratureRule