gkquad 0.0.4

Numerical integration library for Rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

use super::algorithm::*;
use super::common::{Integrand2, IntegrationConfig2, Points2};
use super::range::IntoRange2;

use crate::{IntegrationResult, Tolerance};

/// 2-dimentional integration Executor
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Integrator2<F: Integrand2, A> {
    integrand: F,
    algorithm: A,
    config: IntegrationConfig2,
}

impl<F: Integrand2, A> Integrator2<F, A> {
    #[inline]
    pub fn with_algorithm(integrand: F, algorithm: A) -> Integrator2<F, A> {
        Self {
            integrand,
            algorithm,
            config: IntegrationConfig2::default(),
        }
    }

    /// Set tolerance
    #[inline]
    pub fn tolerance(mut self, t: Tolerance) -> Self {
        assert!(!t.contains_nan(), "Tolerance must not contain NAN.");

        self.config.tolerance = t;
        self
    }

    /// Set maximum number of subranges
    #[inline]
    pub fn max_iters(mut self, max_iters: usize) -> Self {
        self.config.max_iters = max_iters;
        self
    }

    /// Set singular points
    pub fn points(mut self, pts: &[(f64, f64)]) -> Self {
        assert!(
            pts.iter().all(|(x, y)| !x.is_nan() && !y.is_nan()),
            "cannot include NAN value in singular points: {:?}",
            pts
        );

        self.config.points = Points2::from(pts);

        self
    }

    #[inline]
    pub fn get_algorithm(&self) -> &A {
        &self.algorithm
    }

    #[inline]
    pub fn run<'a, T>(&mut self, range: T) -> IntegrationResult
    where
        T: IntoRange2,
        A: Algorithm2<F, T::IntoRange>,
    {
        self.algorithm
            .integrate(&mut self.integrand, &range.into_range(), &self.config)
    }
}