use-calculus

use-calculus provides a deliberately small numerical-calculus surface. The crate prefers explicit assumptions over magic defaults: finite-difference steps are caller-chosen, integration sample counts are explicit, and two-sided limit estimates fail when the left and right samples do not agree within a caller-provided tolerance.

What this crate provides

Area	Root exports	Best fit
Differentiation	`Differentiator`, `central_difference`, `second_central_difference`	Small slope and curvature estimates on `f64` functions
Integration	`IntegrationInterval`, `Integrator`, `trapezoidal_integral`, `simpson_integral`	Signed area approximations with explicit sample density
Limits	`LimitApproximator`, `symmetric_limit`	Two-sided limits where a single symmetric sample scale is a reasonable model

If you need to...	Start here
Estimate a derivative at one point	`Differentiator::derivative_at(...)`
Approximate a definite integral	`Integrator::trapezoidal(...)` or `Integrator::simpson(...)`
Model a signed interval directly	`IntegrationInterval::try_new(...)`
Reject discontinuities instead of hiding them	`symmetric_limit(...)` or `LimitApproximator`

When to use it directly

Choose use-calculus directly when numerical-calculus helpers are the only math surface you need, or when you want the approximation policy to stay visible instead of being hidden behind a broader abstraction.

Scenario	Use `use-calculus` directly?	Why
You need a few direct derivative or integral estimates	Yes	The crate stays small and explicit
You want validation at the boundary of your app	Yes	Invalid steps, bounds, and evaluations become errors
You need symbolic manipulation or automatic differentiation	No	This crate intentionally stays numerical and lightweight
You also need several other math surfaces	Usually no	`use-math` may become the better integration point

Installation

[dependencies]
use-calculus = "0.0.1"

Quick examples

Differentiate and integrate small `f64` functions

use use_calculus::{Differentiator, IntegrationInterval, Integrator};

let differentiator = Differentiator::try_new(1.0e-5)?;
let interval = IntegrationInterval::try_new(0.0, 1.0)?;
let integrator = Integrator::try_new(128)?;

let slope = differentiator.derivative_at(|x| x.powi(3), 2.0)?;
let area = integrator.simpson(|x| x * x, interval)?;

assert!((slope - 12.0).abs() < 1.0e-3);
assert!((area - (1.0 / 3.0)).abs() < 1.0e-6);
# Ok::<(), use_calculus::CalculusError>(())

Explicitly reject mismatched one-sided limits

use use_calculus::{CalculusError, LimitApproximator};

let limit = LimitApproximator::try_new(1.0e-6, 1.0e-5)?;
let sinc_limit = limit.at(
    |x| {
        if x == 0.0 {
            1.0
        } else {
            x.sin() / x
        }
    },
    0.0,
)?;

assert!((sinc_limit - 1.0).abs() < 1.0e-5);
assert!(matches!(
    limit.at(|x| if x < 0.0 { -1.0 } else { 1.0 }, 0.0),
    Err(CalculusError::LimitMismatch { .. })
));
# Ok::<(), use_calculus::CalculusError>(())

Validation model

Use try_new when sample sizes, step sizes, tolerances, and interval bounds may come from user input, files, or network payloads. Use infallible constructors like Differentiator::new(...), IntegrationInterval::new(...), Integrator::new(...), and LimitApproximator::new(...) when values are already trusted and you want direct assembly.

[!IMPORTANT] This crate does not hide approximation policy behind a global epsilon or default grid density. Callers choose the differentiation step, integration density, and limit tolerance directly.

Scope

Small numerical APIs are preferred over symbolic or trait-heavy abstractions.
The initial concrete surface is f64-based and focused on explicit approximation helpers.
Adaptive quadrature, automatic differentiation, and symbolic manipulation are intentionally out of scope for this first slice.
Broader real-number utilities and statistical analysis belong in adjacent focused crates.

Status

use-calculus is a concrete pre-1.0 crate in the RustUse docs surface. The API remains intentionally small while the broader calculus roadmap is still being designed.

use-calculus 0.0.1