Struct Basic 

pub struct Basic<'a, I> { /* private fields */ }

A non-adaptive Gauss-Kronrod integrator.

The Basic integrator applies a Gauss-Kronrod integration Rule to approximate the integral of a one-dimensional function. It is non-adaptive: it runs exactly once on the input function. Thus, it is only suitable for the integration of smooth functions with no problematic regions in the integration region. If higher accuracy is required then the Adaptive or AdaptiveSingularity integrators should be used instead.

Example

Here we present a calculation of the golden ratio $\varphi$ (std::f64::consts::GOLDEN_RATIO) using the integral representation, $$ \ln \varphi = \int_{0}^{1/2} \frac{dx}{\sqrt{1 + x^{2}}} $$

 use rint::{Integrand, Limits};
 use rint::quadrature::{Basic, Rule};

 const PHI: f64 = std::f64::consts::GOLDEN_RATIO;

 struct GoldenRatio;

 impl Integrand for GoldenRatio {
     type Point = f64;
     type Scalar = f64;

     fn evaluate(&self, x: &Self::Point) -> Self::Scalar {
         1.0 / (1.0 + x.powi(2)).sqrt()
     }
 }

 let golden_ratio = GoldenRatio;
 let limits = Limits::new(0.0,0.5)?;
 let rule = Rule::gk15();
 let integral = Basic::new(&golden_ratio, &rule, limits)
     .integrate();

 let result = integral.result();
 let error = integral.error();
 let abs_actual_error = (PHI.ln() - result).abs();
 let iters = integral.iterations();
 assert_eq!(iters, 1);
 assert!(abs_actual_error < error);

Implementations

impl<'a, I> Basic<'a, I>

where I: Integrand<Point = f64>,

pub const fn new(function: &'a I, rule: &'a Rule, limits: Limits) -> Self

Create a new Basic integrator.

The user first defines a function which is something implementing the Integrand trait and selects a Gauss-Kronrod quadrature Rule, rule, to integrate the function with between the integration Limits, limits.

pub fn integrate(&self) -> IntegralEstimate<I::Scalar>

Integrate the given function.

Applies the user supplied integration rule to obtain an IntegralEstimate, which is the numerically evaluated estimate of the integral value and error, as well as the number of function evaluations and integration routine iterations. Note: for the Basic integrator the number of iterations is 1, and the number of function evaluations for an $n$-point integration rule is $n$.

pub const fn limits(&self) -> Limits

Return the integration Limits.

Trait Implementations

impl<'a, I: Clone> Clone for Basic<'a, I>

fn clone(&self) -> Basic<'a, I>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, I: Debug> Debug for Basic<'a, I>

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

Formats the value using the given formatter.

impl<'a, I: PartialEq> PartialEq for Basic<'a, I>

fn eq(&self, other: &Basic<'a, I>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, I: PartialOrd> PartialOrd for Basic<'a, I>

fn partial_cmp(&self, other: &Basic<'a, I>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, I: Copy> Copy for Basic<'a, I>

impl<'a, I> StructuralPartialEq for Basic<'a, I>