integrate 0.3.1

Small, lightweight Rust library for performing numerical integration.
Documentation 
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
69
70
71
72

use num::{Float, Unsigned, Zero};

/// Validates arguments common to all Newton-Cotes integration methods.
///
/// * `a` - lower limit of the integration interval.
/// * `b` - upper limit of the integration interval.
/// * `n` - number of steps (sub-intervals).
///
/// # Panics
///
/// - Panics if `n` is zero.
/// - Panics if `a` or `b` is infinite or NaN.
/// - Panics if `a > b` (the lower limit must not exceed the upper limit).
pub fn check_newton_method_args<F: Float, U: Unsigned>(a: F, b: F, n: U) {
    if n.is_zero() {
        panic!("number of steps can't be zero");
    }

    if a.is_infinite() | b.is_infinite() {
        panic!("Integral limits a and b can't be infinite");
    }

    if a.is_nan() || b.is_nan() {
        panic!("Integral limits a and b can't be NaN");
    }

    if a > b {
        panic!("a must be strictly less than b");
    }
}

/// Validates the degree argument for Gaussian quadrature rules.
///
/// * `n` - number of quadrature nodes (must be at least 1).
///
/// # Panics
///
/// - Panics if `n` is zero.
pub fn check_gauss_rule_args(n: usize) {
    if n.is_zero() {
        panic!("number of steps can't be zero");
    }
}

/// Validates arguments for Gaussian quadrature rules that integrate over a
/// finite interval $[a, b]$.
///
/// * `a` - lower limit of integration.
/// * `b` - upper limit of integration.
/// * `n` - number of quadrature nodes (must be at least 1).
///
/// # Panics
///
/// - Panics if `n` is zero.
/// - Panics if `a` or `b` is infinite.
/// - Panics if `a` or `b` is NaN.
/// - Panics if `a > b` (lower limit must not exceed upper limit).
pub fn check_gauss_rule_with_limits<F: Float>(a: F, b: F, n: usize) {
    check_gauss_rule_args(n);

    if a.is_infinite() || b.is_infinite() {
        panic!("integration limits a and b can't be infinite");
    }

    if a.is_nan() || b.is_nan() {
        panic!("integration limits a and b can't be NaN");
    }

    if a > b {
        panic!("lower_limit must not exceed upper_limit");
    }
}