runmat-runtime 0.6.0

Core runtime for RunMat with builtins, BLAS/LAPACK integration, and execution APIs
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
138

const MIN_ALWAYS_INTEGRAL: f64 = 4_503_599_627_370_496.0;

fn half_turn_mod4(value: f64) -> Option<i32> {
    if !value.is_finite() {
        return None;
    }
    let doubled = value * 2.0;
    if !doubled.is_finite() {
        return (value.abs() >= MIN_ALWAYS_INTEGRAL).then_some(0);
    }
    let rounded = doubled.round();
    if doubled != rounded {
        return None;
    }
    match rounded.rem_euclid(4.0) {
        0.0 => Some(0),
        1.0 => Some(1),
        2.0 => Some(2),
        3.0 => Some(3),
        _ => None,
    }
}

pub(crate) fn sinpi_real(value: f64) -> f64 {
    if !value.is_finite() {
        return f64::NAN;
    }
    match half_turn_mod4(value) {
        Some(0 | 2) => 0.0,
        Some(1) => 1.0,
        Some(3) => -1.0,
        _ => (std::f64::consts::PI * value).sin(),
    }
}

pub(crate) fn cospi_real(value: f64) -> f64 {
    if !value.is_finite() {
        return f64::NAN;
    }
    match half_turn_mod4(value) {
        Some(0) => 1.0,
        Some(1 | 3) => 0.0,
        Some(2) => -1.0,
        _ => (std::f64::consts::PI * value).cos(),
    }
}

fn mul_preserving_exact_zero(factor: f64, magnitude: f64) -> f64 {
    if factor == 0.0 && !magnitude.is_nan() {
        factor
    } else {
        factor * magnitude
    }
}

pub(crate) fn sinpi_complex(re: f64, im: f64) -> (f64, f64) {
    let scaled_im = std::f64::consts::PI * im;
    let sin_re = sinpi_real(re);
    let cos_re = cospi_real(re);
    (
        mul_preserving_exact_zero(sin_re, scaled_im.cosh()),
        mul_preserving_exact_zero(cos_re, scaled_im.sinh()),
    )
}

pub(crate) fn cospi_complex(re: f64, im: f64) -> (f64, f64) {
    let scaled_im = std::f64::consts::PI * im;
    let cos_re = cospi_real(re);
    let neg_sin_re = -sinpi_real(re);
    (
        mul_preserving_exact_zero(cos_re, scaled_im.cosh()),
        mul_preserving_exact_zero(neg_sin_re, scaled_im.sinh()),
    )
}

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

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[cfg_attr(not(target_arch = "wasm32"), test)]
    fn sinpi_exact_half_turns() {
        assert_eq!(sinpi_real(0.0), 0.0);
        assert_eq!(sinpi_real(0.5), 1.0);
        assert_eq!(sinpi_real(1.0), 0.0);
        assert_eq!(sinpi_real(1.5), -1.0);
        assert_eq!(sinpi_real(-0.5), -1.0);
        assert_eq!(sinpi_real(-1.0), 0.0);
        assert_eq!(sinpi_real(9_007_199_254_740_991.0), 0.0);
        assert_eq!(sinpi_real(9_007_199_254_740_992.0), 0.0);
        assert_eq!(sinpi_real(1.0e300), 0.0);
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[cfg_attr(not(target_arch = "wasm32"), test)]
    fn cospi_exact_half_turns() {
        assert_eq!(cospi_real(0.0), 1.0);
        assert_eq!(cospi_real(0.5), 0.0);
        assert_eq!(cospi_real(1.0), -1.0);
        assert_eq!(cospi_real(1.5), 0.0);
        assert_eq!(cospi_real(-0.5), 0.0);
        assert_eq!(cospi_real(-1.0), -1.0);
        assert_eq!(cospi_real(9_007_199_254_740_991.0), -1.0);
        assert_eq!(cospi_real(9_007_199_254_740_992.0), 1.0);
        assert_eq!(cospi_real(1.0e300), 1.0);
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[cfg_attr(not(target_arch = "wasm32"), test)]
    fn complex_exact_zero_factors_survive_overflowing_imaginary_scale() {
        let (re, im) = sinpi_complex(0.0, f64::INFINITY);
        assert_eq!(re, 0.0);
        assert!(im.is_infinite() && im.is_sign_positive());

        let (re, im) = sinpi_complex(0.5, f64::INFINITY);
        assert!(re.is_infinite() && re.is_sign_positive());
        assert_eq!(im, 0.0);

        let (re, im) = cospi_complex(0.5, f64::INFINITY);
        assert_eq!(re, 0.0);
        assert!(im.is_infinite() && im.is_sign_negative());

        let (re, im) = cospi_complex(1.0, 1.0e300);
        assert!(re.is_infinite() && re.is_sign_negative());
        assert_eq!(im, -0.0);
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[cfg_attr(not(target_arch = "wasm32"), test)]
    fn real_nonfinite_inputs_return_nan() {
        assert!(sinpi_real(f64::NAN).is_nan());
        assert!(sinpi_real(f64::INFINITY).is_nan());
        assert!(sinpi_real(f64::NEG_INFINITY).is_nan());
        assert!(cospi_real(f64::NAN).is_nan());
        assert!(cospi_real(f64::INFINITY).is_nan());
        assert!(cospi_real(f64::NEG_INFINITY).is_nan());
    }
}