lambert_w 2.0.1

Fast and accurate evaluation of the Lambert W function by the method of T. Fukushima.
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
133
134
135
136
137

// Copyright 2024-2026 Johanna Sörngård
// SPDX-License-Identifier: MIT OR Apache-2.0

//! This file contains unit tests for non-public functions.

use crate::{
    all_complex_branches::are_nearly_equal,
    generic_math::{ln, rational_function, sqrt},
};

use approx::{assert_abs_diff_eq, assert_relative_eq};
use num_complex::{c32, c64};

#[test]
fn test_are_nearly_equal() {
    assert!(are_nearly_equal(c32(0.0, 0.0), c32(0.0, 0.0), f32::EPSILON));
    assert!(!are_nearly_equal(
        c32(0.0, f32::NAN),
        c32(0.0, 0.0),
        f32::EPSILON
    ));
    assert!(are_nearly_equal(c32(10.0, 0.0), c32(10.000001, 0.0), 0.01));
    assert!(!are_nearly_equal(
        c32(f32::MIN_POSITIVE / 3.0, 0.0),
        c32(f32::MIN_POSITIVE / 6.0, 0.0),
        0.1,
    ));

    assert!(are_nearly_equal(c64(0.0, 0.0), c64(0.0, 0.0), f64::EPSILON));
    assert!(!are_nearly_equal(
        c64(0.0, f64::NAN),
        c64(0.0, 0.0),
        f64::EPSILON
    ));
    assert!(are_nearly_equal(c64(10.0, 0.0), c64(10.000001, 0.0), 0.01));
    assert!(!are_nearly_equal(
        c64(f64::MIN_POSITIVE / 3.0, 0.0),
        c64(f64::MIN_POSITIVE / 6.0, 0.0),
        0.1,
    ));
}

#[test]
fn sanity_check_rational_3_over_3() {
    let n = [1.0, 2.0, 3.0, 4.0];
    let d = [5.0, 6.0, 7.0, 8.0];
    let x = 1.0;
    let expected = (1.0 + 2.0 + 3.0 + 4.0) / (5.0 + 6.0 + 7.0 + 8.0);
    assert_abs_diff_eq!(rational_function(x, n, d), expected);
}

#[test]
fn sanity_check_rational_3_over_3f() {
    let n = [1.0, 2.0, 3.0, 4.0];
    let d = [5.0, 6.0, 7.0, 8.0];
    let x: f32 = 1.0;
    let expected = (1.0 + 2.0 + 3.0 + 4.0) / (5.0 + 6.0 + 7.0 + 8.0);
    assert_abs_diff_eq!(rational_function(x, n, d), expected);
}

#[test]
fn sanity_check_rational_4_over_3() {
    let n = [1.0, 2.0, 3.0, 4.0, 5.0];
    let d = [6.0, 7.0, 8.0, 9.0];
    let x = 1.0;
    let expected = (1.0 + 2.0 + 3.0 + 4.0 + 5.0) / (6.0 + 7.0 + 8.0 + 9.0);
    assert_abs_diff_eq!(rational_function(x, n, d), expected);
}

#[test]
fn sanity_check_rational_4_over_3f() {
    let n = [1.0, 2.0, 3.0, 4.0, 5.0];
    let d = [6.0, 7.0, 8.0, 9.0];
    let x: f32 = 1.0;
    let expected = (1.0 + 2.0 + 3.0 + 4.0 + 5.0) / (6.0 + 7.0 + 8.0 + 9.0);
    assert_abs_diff_eq!(rational_function(x, n, d), expected);
}

#[test]
fn sanity_check_rational_7_over_7() {
    let n = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0];
    let d = [9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0];
    let x = 1.0;
    let expected = (1.0 + 2.0 + 3.0 + 4.0 + 5.0 + 6.0 + 7.0 + 8.0)
        / (9.0 + 10.0 + 11.0 + 12.0 + 13.0 + 14.0 + 15.0 + 16.0);
    assert_abs_diff_eq!(rational_function(x, n, d), expected);
}

#[test]
fn sanity_check_rational_8_over_7() {
    let n = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0];
    let d = [10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0];
    let x = 1.0;
    let expected = (1.0 + 2.0 + 3.0 + 4.0 + 5.0 + 6.0 + 7.0 + 8.0 + 9.0)
        / (10.0 + 11.0 + 12.0 + 13.0 + 14.0 + 15.0 + 16.0 + 17.0);
    assert_abs_diff_eq!(rational_function(x, n, d), expected);
}

#[test]
fn sanity_check_log() {
    assert!(ln(-1.0_f64).is_nan());
    assert_abs_diff_eq!(ln(1.0_f64), 0.0);
    assert_abs_diff_eq!(ln(2.0_f64), core::f64::consts::LN_2);
    assert_abs_diff_eq!(ln(f64::MAX), 709.782_712_893_384);
    assert_eq!(ln(f64::INFINITY), f64::INFINITY);
}

#[test]
fn sanity_check_logf() {
    assert!(ln(-1.0_f32).is_nan());
    assert_abs_diff_eq!(ln(1.0_f32), 0.0);
    assert_abs_diff_eq!(ln(2.0_f32), core::f32::consts::LN_2);
    assert_abs_diff_eq!(ln(f32::MAX), 88.722_84);
    assert_eq!(ln(f32::INFINITY), f32::INFINITY);
}

#[test]
fn sanity_check_sqrt() {
    assert!(sqrt(-1.0_f64).is_nan());
    assert_abs_diff_eq!(sqrt(0.0_f64), 0.0);
    assert_abs_diff_eq!(sqrt(1.0_f64), 1.0);
    assert_abs_diff_eq!(sqrt(2.0_f64), core::f64::consts::SQRT_2);
    assert_abs_diff_eq!(sqrt(4.0_f64), 2.0);
    assert_abs_diff_eq!(sqrt(f64::MAX), 1.340_780_792_994_259_6e154);
    assert_eq!(sqrt(f64::INFINITY), f64::INFINITY);
}

#[test]
fn sanity_check_sqrtf() {
    assert!(sqrt(-1.0_f32).is_nan());
    assert_abs_diff_eq!(sqrt(0.0_f32), 0.0);
    assert_abs_diff_eq!(sqrt(1.0_f32), 1.0);
    assert_abs_diff_eq!(sqrt(2.0_f32), core::f32::consts::SQRT_2);
    assert_abs_diff_eq!(sqrt(4.0_f32), 2.0);
    assert_relative_eq!(sqrt(f32::MAX), 1.844_674_4e19);
    assert_eq!(sqrt(f32::INFINITY), f32::INFINITY);
}