Struct Basic 

pub struct Basic<'a, I, R, const N: usize> { /* private fields */ }

A non-adaptive multi-dimensional integrator.

The Basic integrator applies a fully-symmetric integration Rule to approximate the integral of an $N$-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.

Example

Here we present a calculation of Catalan’s constant $G$ using the integral representation: $$ G = \int_{0}^{1} \int_{0}^{1} \frac{1}{1 + x^{2} y^{2}} dy dx $$

 use rint::{Integrand, Limits};
 use rint::multi::{Basic, Rule13};

 const G: f64 = 0.915_965_594_177_219_015_054_603_514_932_384_110_774;
 const N: usize = 2;

 struct Catalan;

 impl Integrand for Catalan {
     type Point = [f64; N];
     type Scalar = f64;

     fn evaluate(&self, coordinate: &[f64; N]) -> Self::Scalar {
         let x = coordinate[0];
         let y = coordinate[1];

         1.0 / (1.0 + x.powi(2) * y.powi(2))
     }
 }

 let catalan = Catalan;
 let limits = [Limits::new(0.0,1.0)?,Limits::new(0.0,1.0)?];
 let rule = Rule13::generate();
 let integral = Basic::new(&catalan, &rule, limits)?.integrate();

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

Implementations

impl<'a, I, const N: usize, const FINAL: usize, const TOTAL: usize> Basic<'a, I, Rule<N, FINAL, TOTAL>, N>

where I: Integrand<Point = [f64; N]>,

pub fn new( function: &'a I, rule: &'a Rule<N, FINAL, TOTAL>, limits: [Limits; N], ) -> Result<Self, InitialisationError>

Create a new Basic multi-dimensional integrator.

The user first defines a function which is something implementing the Integrand trait and selects a fully-symmetric multi-dimensional integration Rule, rule, to integrate the function in the hypercube formed by the Limits, limits in each of the $N$ integration directions.

Errors

Will fail if $N < 2$ or $N > 15$. The routines probided in this module are developed for dimensionalities between $2 \le N \le 15$.

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.

Trait Implementations

impl<'a, I: Clone, R: Clone, const N: usize> Clone for Basic<'a, I, R, N>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, I: Debug, R: Debug, const N: usize> Debug for Basic<'a, I, R, N>

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

Formats the value using the given formatter.

impl<'a, I: PartialEq, R: PartialEq, const N: usize> PartialEq for Basic<'a, I, R, N>

fn eq(&self, other: &Basic<'a, I, R, N>) -> 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, R: PartialOrd, const N: usize> PartialOrd for Basic<'a, I, R, N>

fn partial_cmp(&self, other: &Basic<'a, I, R, N>) -> 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, R: Copy, const N: usize> Copy for Basic<'a, I, R, N>

impl<'a, I, R, const N: usize> StructuralPartialEq for Basic<'a, I, R, N>