abax 0.1.43

A lightweight Rust library providing high-precision mathematical constants and special functions, including Bernoulli numbers, Riemann Zeta values, robust incomplete gamma functions, and probability distribution functions like normal and lognormal CDF.
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

/// Weibull probability density function (PDF) for scalar values.
///
/// Evaluates the PDF of the Weibull distribution with scale parameter `a` 
/// and shape parameter `b` at the value `x`.
///
/// # Arguments
/// * `x` - The value at which to evaluate the PDF.
/// * `a` - Scale parameter (a > 0).
/// * `b` - Shape parameter (b > 0).
///
/// # Returns
/// The probability density at `x`. Returns `f64::NAN` if parameters are invalid.
///
/// # Mathematical Formula
/// For <math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mi>x</mi><mo>&#x2265;</mo><mn>0</mn></math>, 
/// <math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mi>a</mi><mo>&gt;</mo><mn>0</mn></math>, 
/// <math xmlns="http://www.w3.org/1998/Math/MathML" display="inline"><mi>b</mi><mo>&gt;</mo><mn>0</mn></math>:
///
/// <math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
///   <mi>f</mi>
///   <mo stretchy="false">(</mo>
///   <mi>x</mi>
///   <mo>;</mo>
///   <mi>a</mi>
///   <mo>,</mo>
///   <mi>b</mi>
///   <mo stretchy="false">)</mo>
///   <mo>=</mo>
///   <mfrac>
///     <mi>b</mi>
///     <mi>a</mi>
///   </mfrac>
///   <msup>
///     <mrow>
///       <mo>(</mo>
///       <mfrac>
///         <mi>x</mi>
///         <mi>a</mi>
///       </mfrac>
///       <mo>)</mo>
///     </mrow>
///     <mrow>
///       <mi>b</mi>
///       <mo>&#x2212;</mo>
///       <mn>1</mn>
///     </mrow>
///   </msup>
///   <msup>
///     <mi>e</mi>
///     <mrow>
///       <mo>&#x2212;</mo>
///       <msup>
///         <mrow>
///           <mo>(</mo>
///           <mfrac>
///             <mi>x</mi>
///             <mi>a</mi>
///           </mfrac>
///           <mo>)</mo>
///         </mrow>
///         <mi>b</mi>
///       </msup>
///     </mrow>
///   </msup>
/// </math>
pub fn wblpdf(x: f64, a: f64, b: f64) -> f64 {
    // 1. Return NaN for out of range parameters or incoming NaNs
    if x.is_nan() || a.is_nan() || b.is_nan() || a <= 0.0 || b <= 0.0 {
        return f64::NAN;
    }

    // 2. Handle negative x values safely.
    if x < 0.0 {
        return 0.0;
    }

    let z = x / a;

    // 3. Handle extreme right tail to prevent 0 * Inf situations.
    let zb = z.powf(b);
    let w = (-zb).exp();

    if w == 0.0 {
        return 0.0;
    }

    // 4. Standard evaluation path
    z.powf(b - 1.0) * w * b / a
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_standard_weibull() {
        // Evaluating standard parameters where a=1, b=1 (equivalent to standard exponential)
        let result = wblpdf(1.0, 1.0, 1.0);
        let expected = (-1.0f64).exp();
        assert!((result - expected).abs() < 1e-15);
    }

    #[test]
    fn test_negative_x() {
        assert_eq!(wblpdf(-5.5, 2.0, 1.5), 0.0);
        assert_eq!(wblpdf(-0.0, 1.0, 1.0), 1.0);
    }

    #[test]
    fn test_zero_x() {
        // For b > 1, PDF at 0 is 0
        assert_eq!(wblpdf(0.0, 2.0, 2.0), 0.0);
        
        // For b == 1, PDF at 0 is b/a
        assert_eq!(wblpdf(0.0, 2.0, 1.0), 0.5);
        
        // For b < 1, PDF at 0 approaches Infinity
        assert_eq!(wblpdf(0.0, 1.0, 0.5), f64::INFINITY);
    }

    #[test]
    fn test_invalid_parameters() {
        assert!(wblpdf(1.0, 0.0, 1.0).is_nan());
        assert!(wblpdf(1.0, 1.0, -0.5).is_nan());
        assert!(wblpdf(f64::NAN, 1.0, 1.0).is_nan());
    }

    #[test]
    fn test_extreme_right_tail() {
        assert_eq!(wblpdf(1000.0, 1.0, 2.0), 0.0);
    }
}