Struct LimitApproximator

Source

pub struct LimitApproximator { /* private fields */ }

Expand description

Symmetric two-sided limit approximation settings.

Implementations§

Source §

impl LimitApproximator

Source

pub const fn new(step: f64, tolerance: f64) -> Self

Creates a limit approximator from a sample step and comparison tolerance.

Source

pub fn try_new(step: f64, tolerance: f64) -> Result<Self, CalculusError>

Creates a limit approximator from a finite positive step and a finite non-negative tolerance.

§Errors

Returns CalculusError::NonFiniteStep or CalculusError::NonPositiveStep when step is invalid, and returns CalculusError::NonFiniteTolerance or CalculusError::NegativeTolerance when tolerance is invalid.

Examples found in repository ?

examples/basic_usage.rs (line 7)

3fn main() -> Result<(), use_calculus::CalculusError> {
4    let differentiator = Differentiator::try_new(1.0e-5)?;
5    let interval = IntegrationInterval::try_new(0.0, 1.0)?;
6    let integrator = Integrator::try_new(128)?;
7    let limit = LimitApproximator::try_new(1.0e-6, 1.0e-5)?;
8
9    let slope = differentiator.derivative_at(|x| x.powi(2), 3.0)?;
10    let area = integrator.simpson(|x| x * x, interval)?;
11    let sinc_limit = limit.at(
12        |x| {
13            if x == 0.0 { 1.0 } else { x.sin() / x }
14        },
15        0.0,
16    )?;
17
18    assert!((slope - 6.0).abs() < 1.0e-6);
19    assert!((area - (1.0 / 3.0)).abs() < 1.0e-6);
20    assert!((sinc_limit - 1.0).abs() < 1.0e-5);
21
22    Ok(())
23}

Source

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

Validates that the stored step and tolerance are acceptable.

§Errors

Returns the same error variants as Self::try_new.

Source

pub const fn step(&self) -> f64

Returns the symmetric sample step.

Source

pub const fn tolerance(&self) -> f64

Returns the acceptance tolerance between the left and right samples.

Source

pub fn at<F>(self, function: F, at: f64) -> Result<f64, CalculusError>
where F: FnMut(f64) -> f64,

Approximates a two-sided limit at at using one symmetric sample scale.

§Errors

Returns CalculusError when the stored step or tolerance is invalid, at is not finite, sampled evaluations are not finite, or the left and right samples disagree by more than tolerance.

Examples found in repository ?

examples/basic_usage.rs (lines 11-16)

3fn main() -> Result<(), use_calculus::CalculusError> {
4    let differentiator = Differentiator::try_new(1.0e-5)?;
5    let interval = IntegrationInterval::try_new(0.0, 1.0)?;
6    let integrator = Integrator::try_new(128)?;
7    let limit = LimitApproximator::try_new(1.0e-6, 1.0e-5)?;
8
9    let slope = differentiator.derivative_at(|x| x.powi(2), 3.0)?;
10    let area = integrator.simpson(|x| x * x, interval)?;
11    let sinc_limit = limit.at(
12        |x| {
13            if x == 0.0 { 1.0 } else { x.sin() / x }
14        },
15        0.0,
16    )?;
17
18    assert!((slope - 6.0).abs() < 1.0e-6);
19    assert!((area - (1.0 / 3.0)).abs() < 1.0e-6);
20    assert!((sinc_limit - 1.0).abs() < 1.0e-5);
21
22    Ok(())
23}