Skip to content
This repository was archived by the owner on Apr 28, 2025. It is now read-only.

Commit 1b0c539

Browse files
SchultzerSchultzer
committed
Add test suite
1 parent 2f69e15 commit 1b0c539

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

54 files changed

+21165
-3
lines changed

‎.gitignore

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,5 +4,4 @@
44
/math/src
55
/math/target
66
/target
7-
/tests
87
Cargo.lock

‎ci/run.sh

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3,9 +3,9 @@
33
set -ex
44
TARGET=$1
55

6-
cargo test --target $TARGET
6+
# cargo test --target $TARGET
77
cargo test --target $TARGET --release
88

9-
cargo test --features 'checked musl-reference-tests' --target $TARGET
9+
# cargo test --features 'checked musl-reference-tests' --target $TARGET
1010

1111
cargo test --features 'checked musl-reference-tests' --target $TARGET --release

‎tests/acos.rs

Lines changed: 315 additions & 0 deletions
Large diffs are not rendered by default.

‎tests/acosh.rs

Lines changed: 277 additions & 0 deletions
Large diffs are not rendered by default.

‎tests/asin.rs

Lines changed: 213 additions & 0 deletions
Large diffs are not rendered by default.

‎tests/asinh.rs

Lines changed: 411 additions & 0 deletions
Large diffs are not rendered by default.

‎tests/atan.rs

Lines changed: 183 additions & 0 deletions
Large diffs are not rendered by default.

‎tests/atan2.rs

Lines changed: 230 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,230 @@
1+
mod utils;
2+
3+
#[test]
4+
fn atan2() {
5+
use std::f64::consts::{PI, FRAC_PI_2, FRAC_PI_4};
6+
use core::f64::{INFINITY, NEG_INFINITY, MAX, MIN, MIN_POSITIVE, NAN};
7+
use libm::atan2;
8+
use utils::F64_MIN_SUBNORM;
9+
10+
assert_eq!(atan2(1., INFINITY), 0.);
11+
assert_eq!(atan2(0., INFINITY), 0.);
12+
assert_eq!(atan2(MIN, INFINITY), 0.);
13+
assert_eq!(atan2(F64_MIN_SUBNORM, INFINITY), 0.);
14+
assert_eq!(atan2(MIN_POSITIVE, INFINITY), 0.);
15+
assert_eq!(atan2(MAX, INFINITY), 0.);
16+
17+
assert_eq!(atan2(-1., INFINITY), -0.);
18+
assert_eq!(atan2(-0., INFINITY), -0.);
19+
assert_eq!(atan2(-MIN, INFINITY), -0.);
20+
assert_eq!(atan2(-F64_MIN_SUBNORM, INFINITY), -0.);
21+
assert_eq!(atan2(-MIN_POSITIVE, INFINITY), -0.);
22+
assert_eq!(atan2(-MAX, INFINITY), -0.);
23+
24+
assert_eq!(atan2(INFINITY, 1.), FRAC_PI_2);
25+
assert_eq!(atan2(INFINITY, 0.), FRAC_PI_2);
26+
assert_eq!(atan2(INFINITY, MIN), FRAC_PI_2);
27+
assert_eq!(atan2(INFINITY, MIN_POSITIVE), FRAC_PI_2);
28+
assert_eq!(atan2(INFINITY, MAX), FRAC_PI_2);
29+
assert_eq!(atan2(INFINITY, -1.), FRAC_PI_2);
30+
assert_eq!(atan2(INFINITY, -0.), FRAC_PI_2);
31+
assert_eq!(atan2(INFINITY, -MIN), FRAC_PI_2);
32+
assert_eq!(atan2(INFINITY, -MIN_POSITIVE), FRAC_PI_2);
33+
assert_eq!(atan2(INFINITY, -MAX), FRAC_PI_2);
34+
35+
assert_eq!(atan2(NEG_INFINITY, 1.), -FRAC_PI_2);
36+
assert_eq!(atan2(NEG_INFINITY, 0.), -FRAC_PI_2);
37+
assert_eq!(atan2(NEG_INFINITY, MIN), -FRAC_PI_2);
38+
assert_eq!(atan2(NEG_INFINITY, MIN_POSITIVE), -FRAC_PI_2);
39+
assert_eq!(atan2(NEG_INFINITY, MAX), -FRAC_PI_2);
40+
assert_eq!(atan2(NEG_INFINITY, -1.), -FRAC_PI_2);
41+
assert_eq!(atan2(NEG_INFINITY, -0.), -FRAC_PI_2);
42+
assert_eq!(atan2(NEG_INFINITY, -MIN), -FRAC_PI_2);
43+
assert_eq!(atan2(NEG_INFINITY, -MIN_POSITIVE), -FRAC_PI_2);
44+
assert_eq!(atan2(NEG_INFINITY, -MAX), -FRAC_PI_2);
45+
46+
assert_eq!(atan2(1., NEG_INFINITY), PI);
47+
assert_eq!(atan2(0., NEG_INFINITY), PI);
48+
assert_eq!(atan2(F64_MIN_SUBNORM, NEG_INFINITY), PI);
49+
// assert_eq!(atan2(MIN, NEG_INFINITY), PI);
50+
assert_eq!(atan2(MIN_POSITIVE, NEG_INFINITY), PI);
51+
assert_eq!(atan2(MAX, NEG_INFINITY), PI);
52+
53+
assert_eq!(atan2(-1., NEG_INFINITY), -PI);
54+
assert_eq!(atan2(-0., NEG_INFINITY), -PI);
55+
assert_eq!(atan2(-F64_MIN_SUBNORM, NEG_INFINITY), -PI);
56+
// assert_eq!(atan2(-MIN, NEG_INFINITY), -PI);
57+
assert_eq!(atan2(-MIN_POSITIVE, NEG_INFINITY), -PI);
58+
assert_eq!(atan2(-MAX, NEG_INFINITY), -PI);
59+
assert_eq!(atan2(INFINITY, INFINITY), PI / 4.);
60+
assert_eq!(atan2(NEG_INFINITY, INFINITY), -FRAC_PI_4);
61+
assert_eq!(atan2(INFINITY, NEG_INFINITY), (PI * 3.) / 4.);
62+
assert_eq!(atan2(NEG_INFINITY, NEG_INFINITY), -((PI * 3.) / 4.));
63+
assert!(atan2(NAN, NAN).is_nan());
64+
assert!(atan2(NAN, -NAN).is_nan());
65+
assert!(atan2(-NAN, NAN).is_nan());
66+
assert!(atan2(-NAN, -NAN).is_nan());
67+
assert!(atan2(NAN, INFINITY).is_nan());
68+
assert!(atan2(NAN, NEG_INFINITY).is_nan());
69+
assert!(atan2(NAN, 0.).is_nan());
70+
assert!(atan2(NAN, -0.).is_nan());
71+
assert!(atan2(NAN, 1.).is_nan());
72+
assert!(atan2(NAN, -1.).is_nan());
73+
assert!(atan2(NAN, MIN).is_nan());
74+
assert!(atan2(NAN, -MIN).is_nan());
75+
assert!(atan2(NAN, MIN_POSITIVE).is_nan());
76+
assert!(atan2(NAN, -MIN_POSITIVE).is_nan());
77+
assert!(atan2(NAN, MAX).is_nan());
78+
assert!(atan2(NAN, -MAX).is_nan());
79+
assert!(atan2(-NAN, INFINITY).is_nan());
80+
assert!(atan2(-NAN, NEG_INFINITY).is_nan());
81+
assert!(atan2(-NAN, 0.).is_nan());
82+
assert!(atan2(-NAN, -0.).is_nan());
83+
assert!(atan2(-NAN, 1.).is_nan());
84+
assert!(atan2(-NAN, -1.).is_nan());
85+
assert!(atan2(-NAN, MIN).is_nan());
86+
assert!(atan2(-NAN, -MIN).is_nan());
87+
assert!(atan2(-NAN, MIN_POSITIVE).is_nan());
88+
assert!(atan2(-NAN, -MIN_POSITIVE).is_nan());
89+
assert!(atan2(-NAN, MAX).is_nan());
90+
assert!(atan2(-NAN, -MAX).is_nan());
91+
assert!(atan2(INFINITY, NAN).is_nan());
92+
assert!(atan2(NEG_INFINITY, NAN).is_nan());
93+
assert!(atan2(0., NAN).is_nan());
94+
assert!(atan2(-0., NAN).is_nan());
95+
assert!(atan2(1., NAN).is_nan());
96+
assert!(atan2(-1., NAN).is_nan());
97+
assert!(atan2(MIN, NAN).is_nan());
98+
assert!(atan2(-MIN, NAN).is_nan());
99+
assert!(atan2(MIN_POSITIVE, NAN).is_nan());
100+
assert!(atan2(-MIN_POSITIVE, NAN).is_nan());
101+
assert!(atan2(MAX, NAN).is_nan());
102+
assert!(atan2(-MAX, NAN).is_nan());
103+
assert!(atan2(INFINITY, -NAN).is_nan());
104+
assert!(atan2(NEG_INFINITY, -NAN).is_nan());
105+
assert!(atan2(0., -NAN).is_nan());
106+
assert!(atan2(-0., -NAN).is_nan());
107+
assert!(atan2(1., -NAN).is_nan());
108+
assert!(atan2(-1., -NAN).is_nan());
109+
assert!(atan2(MIN, -NAN).is_nan());
110+
assert!(atan2(-MIN, -NAN).is_nan());
111+
assert!(atan2(MIN_POSITIVE, -NAN).is_nan());
112+
assert!(atan2(-MIN_POSITIVE, -NAN).is_nan());
113+
assert!(atan2(MAX, -NAN).is_nan());
114+
assert!(atan2(-MAX, -NAN).is_nan());
115+
}
116+
117+
#[test]
118+
fn atan2f() {
119+
use std::f32::consts::{PI, FRAC_PI_2, FRAC_PI_4};
120+
use core::f32::{INFINITY, NEG_INFINITY, MAX, MIN, MIN_POSITIVE, NAN};
121+
use libm::atan2f;
122+
use utils::F32_MIN_SUBNORM;
123+
124+
assert_eq!(atan2f(1., INFINITY), 0.);
125+
assert_eq!(atan2f(0., INFINITY), 0.);
126+
assert_eq!(atan2f(MIN, INFINITY), 0.);
127+
assert_eq!(atan2f(MIN_POSITIVE, INFINITY), 0.);
128+
assert_eq!(atan2f(MIN, INFINITY), 0.);
129+
130+
assert_eq!(atan2f(-1., INFINITY), -0.);
131+
assert_eq!(atan2f(-0., INFINITY), -0.);
132+
assert_eq!(atan2f(-MIN, INFINITY), -0.);
133+
assert_eq!(atan2f(-MIN_POSITIVE, INFINITY), -0.);
134+
assert_eq!(atan2f(-MIN, INFINITY), -0.);
135+
136+
assert_ulp!(atan2f(INFINITY, 1.), FRAC_PI_2, i32); // // ULP at 1
137+
assert_eq!(atan2f(INFINITY, 0.), FRAC_PI_2);
138+
assert_eq!(atan2f(INFINITY, MIN), FRAC_PI_2);
139+
assert_eq!(atan2f(INFINITY, MIN_POSITIVE), FRAC_PI_2);
140+
assert_eq!(atan2f(INFINITY, MIN), FRAC_PI_2);
141+
assert_eq!(atan2f(INFINITY, -1.), FRAC_PI_2);
142+
assert_eq!(atan2f(INFINITY, -0.), FRAC_PI_2);
143+
assert_eq!(atan2f(INFINITY, -MIN), FRAC_PI_2);
144+
assert_eq!(atan2f(INFINITY, -MIN_POSITIVE), FRAC_PI_2);
145+
assert_eq!(atan2f(INFINITY, -MIN), FRAC_PI_2);
146+
147+
assert_ulp!(atan2f(NEG_INFINITY, 1.), -FRAC_PI_2, i32); // ULP at 1
148+
assert_eq!(atan2f(NEG_INFINITY, 0.), -FRAC_PI_2);
149+
assert_eq!(atan2f(NEG_INFINITY, MIN), -FRAC_PI_2);
150+
assert_eq!(atan2f(NEG_INFINITY, MIN_POSITIVE), -FRAC_PI_2);
151+
assert_eq!(atan2f(NEG_INFINITY, MIN), -FRAC_PI_2);
152+
assert_eq!(atan2f(NEG_INFINITY, -1.), -FRAC_PI_2);
153+
assert_eq!(atan2f(NEG_INFINITY, -0.),-FRAC_PI_2);
154+
assert_eq!(atan2f(NEG_INFINITY, -MIN),-FRAC_PI_2);
155+
assert_eq!(atan2f(NEG_INFINITY, -MIN_POSITIVE),-FRAC_PI_2);
156+
assert_eq!(atan2f(NEG_INFINITY, -MIN),-FRAC_PI_2);
157+
158+
assert_eq!(atan2f(1., NEG_INFINITY), PI);
159+
assert_eq!(atan2f(0., NEG_INFINITY), PI);
160+
assert_eq!(atan2f(F32_MIN_SUBNORM, NEG_INFINITY), PI);
161+
// assert_eq!(atan2f(MIN, NEG_INFINITY), PI);
162+
assert_eq!(atan2f(MIN_POSITIVE, NEG_INFINITY), PI);
163+
assert_eq!(atan2f(MAX, NEG_INFINITY), PI);
164+
165+
assert_eq!(atan2f(-1., NEG_INFINITY), -PI);
166+
assert_eq!(atan2f(-0., NEG_INFINITY), -PI);
167+
assert_eq!(atan2f(-F32_MIN_SUBNORM, NEG_INFINITY), -PI);
168+
// assert_eq!(atan2f(-MIN, NEG_INFINITY), -PI);
169+
assert_eq!(atan2f(-MIN_POSITIVE, NEG_INFINITY), -PI);
170+
// assert_eq!(atan2f(-MIN, NEG_INFINITY), -PI); ULP at 6
171+
172+
assert_eq!(atan2f(INFINITY, INFINITY), FRAC_PI_4);
173+
assert_eq!(atan2f(NEG_INFINITY, INFINITY), -FRAC_PI_4);
174+
assert_eq!(atan2f(INFINITY, NEG_INFINITY),(PI * 3.) / 4.);
175+
assert_eq!(atan2f(NEG_INFINITY, NEG_INFINITY), -((PI * 3.) / 4.));
176+
assert!(atan2f(NAN, NAN).is_nan());
177+
assert!(atan2f(NAN, -NAN).is_nan());
178+
assert!(atan2f(-NAN, NAN).is_nan());
179+
assert!(atan2f(-NAN, -NAN).is_nan());
180+
assert!(atan2f(NAN, INFINITY).is_nan());
181+
assert!(atan2f(NAN, NEG_INFINITY).is_nan());
182+
assert!(atan2f(NAN, 0.).is_nan());
183+
assert!(atan2f(NAN, -0.).is_nan());
184+
assert!(atan2f(NAN, 1.).is_nan());
185+
assert!(atan2f(NAN, -1.).is_nan());
186+
assert!(atan2f(NAN, MIN).is_nan());
187+
assert!(atan2f(NAN, -MIN).is_nan());
188+
assert!(atan2f(NAN, MIN_POSITIVE).is_nan());
189+
assert!(atan2f(NAN, -MIN_POSITIVE).is_nan());
190+
assert!(atan2f(NAN, MIN).is_nan());
191+
assert!(atan2f(NAN, -MIN).is_nan());
192+
assert!(atan2f(-NAN, INFINITY).is_nan());
193+
assert!(atan2f(-NAN, NEG_INFINITY).is_nan());
194+
assert!(atan2f(-NAN, 0.).is_nan());
195+
assert!(atan2f(-NAN, -0.).is_nan());
196+
assert!(atan2f(-NAN, 1.).is_nan());
197+
assert!(atan2f(-NAN, -1.).is_nan());
198+
assert!(atan2f(-NAN, MIN).is_nan());
199+
assert!(atan2f(-NAN, -MIN).is_nan());
200+
assert!(atan2f(-NAN, MIN_POSITIVE).is_nan());
201+
assert!(atan2f(-NAN, -MIN_POSITIVE).is_nan());
202+
assert!(atan2f(-NAN, MIN).is_nan());
203+
assert!(atan2f(-NAN, -MIN).is_nan());
204+
205+
assert!(atan2f(INFINITY, NAN).is_nan());
206+
assert!(atan2f(INFINITY, NAN).is_nan());
207+
assert!(atan2f(NEG_INFINITY, NAN).is_nan());
208+
assert!(atan2f(0., NAN).is_nan());
209+
assert!(atan2f(-0., NAN).is_nan());
210+
assert!(atan2f(1., NAN).is_nan());
211+
assert!(atan2f(-1., NAN).is_nan());
212+
assert!(atan2f(MIN, NAN).is_nan());
213+
assert!(atan2f(-MIN, NAN).is_nan());
214+
assert!(atan2f(MIN_POSITIVE, NAN).is_nan());
215+
assert!(atan2f(-MIN_POSITIVE, NAN).is_nan());
216+
assert!(atan2f(MIN, NAN).is_nan());
217+
assert!(atan2f(-MIN, NAN).is_nan());
218+
assert!(atan2f(INFINITY, -NAN).is_nan());
219+
assert!(atan2f(NEG_INFINITY, -NAN).is_nan());
220+
assert!(atan2f(0., -NAN).is_nan());
221+
assert!(atan2f(-0., -NAN).is_nan());
222+
assert!(atan2f(1., -NAN).is_nan());
223+
assert!(atan2f(-1., -NAN).is_nan());
224+
assert!(atan2f(MIN, -NAN).is_nan());
225+
assert!(atan2f(-MIN, -NAN).is_nan());
226+
assert!(atan2f(MIN_POSITIVE, -NAN).is_nan());
227+
assert!(atan2f(-MIN_POSITIVE, -NAN).is_nan());
228+
assert!(atan2f(MIN, -NAN).is_nan());
229+
assert!(atan2f(-MIN, -NAN).is_nan());
230+
}

0 commit comments

Comments
 (0)