Struct IntegrationInterval 

pub struct IntegrationInterval { /* private fields */ }

A finite interval for definite integration.

Implementations

impl IntegrationInterval

pub const fn new(start: f64, end: f64) -> Self

Creates an interval from start to end.

pub fn try_new(start: f64, end: f64) -> Result<Self, CalculusError>

Creates an interval from finite bounds.

Errors

Returns CalculusError::NonFiniteBound when start or end is not finite.

Examples found in repository

examples/basic_usage.rs (line 5)

fn main() -> Result<(), use_calculus::CalculusError> {
    let differentiator = Differentiator::try_new(1.0e-5)?;
    let interval = IntegrationInterval::try_new(0.0, 1.0)?;
    let integrator = Integrator::try_new(128)?;
    let limit = LimitApproximator::try_new(1.0e-6, 1.0e-5)?;

    let slope = differentiator.derivative_at(|x| x.powi(2), 3.0)?;
    let area = integrator.simpson(|x| x * x, interval)?;
    let sinc_limit = limit.at(
        |x| {
            if x == 0.0 { 1.0 } else { x.sin() / x }
        },
        0.0,
    )?;

    assert!((slope - 6.0).abs() < 1.0e-6);
    assert!((area - (1.0 / 3.0)).abs() < 1.0e-6);
    assert!((sinc_limit - 1.0).abs() < 1.0e-5);

    Ok(())
}

pub fn validate(self) -> Result<Self, CalculusError>

Validates that the stored bounds are finite.

Errors

Returns the same error variants as Self::try_new.

pub const fn start(&self) -> f64

Returns the start bound.

pub const fn end(&self) -> f64

Returns the end bound.

pub const fn width(&self) -> f64

Returns the signed interval width, end - start.

Trait Implementations

impl Clone for IntegrationInterval

fn clone(&self) -> IntegrationInterval

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for IntegrationInterval

impl Debug for IntegrationInterval

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

Formats the value using the given formatter.

impl PartialEq for IntegrationInterval

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for IntegrationInterval