Struct Rule 

pub struct Rule<T> {
    pub x: Vec<T>,
    pub w: Vec<T>,
    pub x_forward: Vec<T>,
    pub x_backward: Vec<T>,
    pub a: T,
    pub b: T,
}

Quadrature rule for numerical integration.

Represents an approximation of an integral by a weighted sum over discrete points. The rule contains quadrature points x, weights w, and auxiliary arrays x_forward and x_backward for efficient computation.

Fields

x: Vec<T>

Quadrature points

w: Vec<T>

Quadrature weights

x_forward: Vec<T>

Distance from left endpoint: x - a

x_backward: Vec<T>

Distance from right endpoint: b - x

a: T

Left endpoint of integration interval

b: T

Right endpoint of integration interval

Implementations

impl<T> Rule<T>

where T: CustomNumeric,

pub fn new(x: Vec<T>, w: Vec<T>, a: T, b: T) -> Self

Create a new quadrature rule from points and weights.

Arguments

• x - Quadrature points
• w - Quadrature weights
• a - Left endpoint (default: -1.0)
• b - Right endpoint (default: 1.0)

Panics

Panics if x and w have different lengths.

pub fn from_vectors(x: Vec<T>, w: Vec<T>, a: T, b: T) -> Self

Create a new quadrature rule from vectors.

pub fn empty() -> Self

Create a default rule with empty arrays.

pub fn reseat(&self, a: T, b: T) -> Self

Reseat the rule to a new interval [a, b].

Scales and translates the quadrature points and weights to the new interval.

pub fn scale(&self, factor: T) -> Self

Scale the weights by a factor.

pub fn piecewise(&self, edges: &[T]) -> Self

Create a piecewise rule over multiple segments.

Arguments

• edges - Segment boundaries (must be sorted in ascending order)

Panics

Panics if edges are not sorted or have less than 2 elements.

pub fn join(rules: &[Self]) -> Self

Join multiple rules into a single rule.

Arguments

• rules - Vector of rules to join (must be contiguous and sorted)

Panics

Panics if rules are empty, not contiguous, or not sorted.

pub fn convert<U>(&self) -> Rule<U>

where U: CustomNumeric + Copy + Debug + Display,

Convert the rule to a different numeric type.

pub fn validate(&self) -> bool

Validate the rule for consistency.

Returns

true if the rule is valid, false otherwise.

impl<T> Rule<T>

where T: CustomNumeric,

CustomNumeric-based implementation for f64 and Df64 support

pub fn new_custom(x: Vec<T>, w: Vec<T>, a: T, b: T) -> Self

Create a new quadrature rule from points and weights (CustomNumeric version).

pub fn from_vectors_custom(x: Vec<T>, w: Vec<T>, a: T, b: T) -> Self

Create a new quadrature rule from vectors (CustomNumeric version).

pub fn reseat_custom(&self, a: T, b: T) -> Self

Reseat the rule to a new interval [a, b] (CustomNumeric version).

pub fn scale_custom(&self, factor: T) -> Self

Scale the weights by a factor (CustomNumeric version).

pub fn validate_custom(&self) -> bool

Validate the rule for consistency (CustomNumeric version).

impl Rule<Df64>

Df64-specific implementation without ScalarOperand requirement

pub fn new_twofloat(x: Vec<Df64>, w: Vec<Df64>, a: Df64, b: Df64) -> Self

Create a new quadrature rule from points and weights (Df64 version).

pub fn from_vectors_twofloat( x: Vec<Df64>, w: Vec<Df64>, a: Df64, b: Df64, ) -> Self

Create a new quadrature rule from vectors (Df64 version).

pub fn reseat_twofloat(&self, a: Df64, b: Df64) -> Self

Reseat the rule to a new interval [a, b] (Df64 version).

pub fn scale_twofloat(&self, factor: Df64) -> Self

Scale the weights by a factor (Df64 version).

pub fn validate_twofloat(&self) -> bool

Validate the rule for consistency (Df64 version).

Trait Implementations

impl<T: Clone> Clone for Rule<T>

fn clone(&self) -> Rule<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Rule<T>

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

Formats the value using the given formatter.