1 /* $NetBSD: t_asin.c,v 1.5 2024/05/11 21:27:53 riastradh Exp $ */
2
3 /*-
4 * Copyright (c) 2011 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Jukka Ruohonen.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <atf-c.h>
33 #include <float.h>
34 #include <math.h>
35
36 static const struct {
37 double x;
38 double y;
39 } values[] = {
40 { -1.0, -M_PI / 2, },
41 { -0.9, -1.119769514998634, },
42 { -0.5, -M_PI / 6, },
43 { -0.1, -0.1001674211615598, },
44 { 0.1, 0.1001674211615598, },
45 { 0.5, M_PI / 6, },
46 { 0.9, 1.119769514998634, },
47 { 1.0, M_PI / 2, },
48 };
49
50 /*
51 * asin(3)
52 */
53 ATF_TC(asin_nan);
ATF_TC_HEAD(asin_nan,tc)54 ATF_TC_HEAD(asin_nan, tc)
55 {
56 atf_tc_set_md_var(tc, "descr", "Test asin(NaN) == NaN");
57 }
58
ATF_TC_BODY(asin_nan,tc)59 ATF_TC_BODY(asin_nan, tc)
60 {
61 const double x = 0.0L / 0.0L;
62
63 if (isnan(asin(x)) == 0)
64 atf_tc_fail_nonfatal("asin(NaN) != NaN");
65 }
66
67 ATF_TC(asin_inf_neg);
ATF_TC_HEAD(asin_inf_neg,tc)68 ATF_TC_HEAD(asin_inf_neg, tc)
69 {
70 atf_tc_set_md_var(tc, "descr", "Test asin(-Inf) == NaN");
71 }
72
ATF_TC_BODY(asin_inf_neg,tc)73 ATF_TC_BODY(asin_inf_neg, tc)
74 {
75 const double x = -1.0L / 0.0L;
76
77 if (isnan(asin(x)) == 0)
78 atf_tc_fail_nonfatal("asin(-Inf) != NaN");
79 }
80
81 ATF_TC(asin_inf_pos);
ATF_TC_HEAD(asin_inf_pos,tc)82 ATF_TC_HEAD(asin_inf_pos, tc)
83 {
84 atf_tc_set_md_var(tc, "descr", "Test asin(+Inf) == NaN");
85 }
86
ATF_TC_BODY(asin_inf_pos,tc)87 ATF_TC_BODY(asin_inf_pos, tc)
88 {
89 const double x = 1.0L / 0.0L;
90
91 if (isnan(asin(x)) == 0)
92 atf_tc_fail_nonfatal("asin(+Inf) != NaN");
93 }
94
95 ATF_TC(asin_range);
ATF_TC_HEAD(asin_range,tc)96 ATF_TC_HEAD(asin_range, tc)
97 {
98 atf_tc_set_md_var(tc, "descr", "Test asin(x) == NaN, x < -1, x > 1");
99 }
100
ATF_TC_BODY(asin_range,tc)101 ATF_TC_BODY(asin_range, tc)
102 {
103 const double x[] = { -1.1, -1.000000001, 1.1, 1.000000001 };
104 size_t i;
105
106 for (i = 0; i < __arraycount(x); i++) {
107
108 if (isnan(asin(x[i])) == 0)
109 atf_tc_fail_nonfatal("asin(%f) != NaN", x[i]);
110 }
111 }
112
113 ATF_TC(asin_inrange);
ATF_TC_HEAD(asin_inrange,tc)114 ATF_TC_HEAD(asin_inrange, tc)
115 {
116 atf_tc_set_md_var(tc, "descr", "Test asin(x) for some values");
117 }
118
ATF_TC_BODY(asin_inrange,tc)119 ATF_TC_BODY(asin_inrange, tc)
120 {
121 const double eps = DBL_EPSILON;
122 size_t i;
123
124 for (i = 0; i < __arraycount(values); i++) {
125 double x = values[i].x;
126 double y = values[i].y;
127
128 if (!(fabs((asin(x) - y)/y) <= eps))
129 atf_tc_fail_nonfatal("asin(%g) != %g",
130 values[i].x, values[i].y);
131 }
132 }
133
134 ATF_TC(asin_zero_neg);
ATF_TC_HEAD(asin_zero_neg,tc)135 ATF_TC_HEAD(asin_zero_neg, tc)
136 {
137 atf_tc_set_md_var(tc, "descr", "Test asin(-0.0) == -0.0");
138 }
139
ATF_TC_BODY(asin_zero_neg,tc)140 ATF_TC_BODY(asin_zero_neg, tc)
141 {
142 const double x = -0.0L;
143 double y = asin(x);
144
145 if (fabs(y) > 0.0 || signbit(y) == 0)
146 atf_tc_fail_nonfatal("asin(-0.0) != -0.0");
147 }
148
149 ATF_TC(asin_zero_pos);
ATF_TC_HEAD(asin_zero_pos,tc)150 ATF_TC_HEAD(asin_zero_pos, tc)
151 {
152 atf_tc_set_md_var(tc, "descr", "Test asin(+0.0) == +0.0");
153 }
154
ATF_TC_BODY(asin_zero_pos,tc)155 ATF_TC_BODY(asin_zero_pos, tc)
156 {
157 const double x = 0.0L;
158 double y = asin(x);
159
160 if (fabs(y) > 0.0 || signbit(y) != 0)
161 atf_tc_fail_nonfatal("asin(+0.0) != +0.0");
162 }
163
164 /*
165 * asinf(3)
166 */
167 ATF_TC(asinf_nan);
ATF_TC_HEAD(asinf_nan,tc)168 ATF_TC_HEAD(asinf_nan, tc)
169 {
170 atf_tc_set_md_var(tc, "descr", "Test asinf(NaN) == NaN");
171 }
172
ATF_TC_BODY(asinf_nan,tc)173 ATF_TC_BODY(asinf_nan, tc)
174 {
175 const float x = 0.0L / 0.0L;
176
177 if (isnan(asinf(x)) == 0)
178 atf_tc_fail_nonfatal("asinf(NaN) != NaN");
179 }
180
181 ATF_TC(asinf_inf_neg);
ATF_TC_HEAD(asinf_inf_neg,tc)182 ATF_TC_HEAD(asinf_inf_neg, tc)
183 {
184 atf_tc_set_md_var(tc, "descr", "Test asinf(-Inf) == NaN");
185 }
186
ATF_TC_BODY(asinf_inf_neg,tc)187 ATF_TC_BODY(asinf_inf_neg, tc)
188 {
189 const float x = -1.0L / 0.0L;
190
191 if (isnan(asinf(x)) == 0)
192 atf_tc_fail_nonfatal("asinf(-Inf) != NaN");
193 }
194
195 ATF_TC(asinf_inf_pos);
ATF_TC_HEAD(asinf_inf_pos,tc)196 ATF_TC_HEAD(asinf_inf_pos, tc)
197 {
198 atf_tc_set_md_var(tc, "descr", "Test asinf(+Inf) == NaN");
199 }
200
ATF_TC_BODY(asinf_inf_pos,tc)201 ATF_TC_BODY(asinf_inf_pos, tc)
202 {
203 const float x = 1.0L / 0.0L;
204
205 if (isnan(asinf(x)) == 0)
206 atf_tc_fail_nonfatal("asinf(+Inf) != NaN");
207 }
208
209 ATF_TC(asinf_range);
ATF_TC_HEAD(asinf_range,tc)210 ATF_TC_HEAD(asinf_range, tc)
211 {
212 atf_tc_set_md_var(tc, "descr", "Test asinf(x) == NaN, x < -1, x > 1");
213 }
214
ATF_TC_BODY(asinf_range,tc)215 ATF_TC_BODY(asinf_range, tc)
216 {
217 const float x[] = { -1.1, -1.0000001, 1.1, 1.0000001 };
218 size_t i;
219
220 for (i = 0; i < __arraycount(x); i++) {
221
222 if (isnan(asinf(x[i])) == 0)
223 atf_tc_fail_nonfatal("asinf(%f) != NaN", x[i]);
224 }
225 }
226
227 ATF_TC(asinf_inrange);
ATF_TC_HEAD(asinf_inrange,tc)228 ATF_TC_HEAD(asinf_inrange, tc)
229 {
230 atf_tc_set_md_var(tc, "descr", "Test asinf(x) for some values");
231 }
232
ATF_TC_BODY(asinf_inrange,tc)233 ATF_TC_BODY(asinf_inrange, tc)
234 {
235 const float eps = FLT_EPSILON;
236 size_t i;
237
238 for (i = 0; i < __arraycount(values); i++) {
239 float x = values[i].x;
240 float y = values[i].y;
241
242 if (fabs(x) == 0.5)
243 atf_tc_expect_fail("PR lib/58246:"
244 " asinf gives ~2ulp error"
245 " when it should give <1ulp");
246 if (!(fabsf((asinf(x) - y)/y) <= eps)) {
247 atf_tc_fail_nonfatal("asinf(%.8g) = %.8g != %.8g,"
248 " error=~%.1fulp",
249 x, asinf(x), y, fabsf(((asinf(x) - y)/y)/eps));
250 }
251 if (fabs(x) == 0.5)
252 atf_tc_expect_pass();
253 }
254 }
255
256 ATF_TC(asinf_zero_neg);
ATF_TC_HEAD(asinf_zero_neg,tc)257 ATF_TC_HEAD(asinf_zero_neg, tc)
258 {
259 atf_tc_set_md_var(tc, "descr", "Test asinf(-0.0) == -0.0");
260 }
261
ATF_TC_BODY(asinf_zero_neg,tc)262 ATF_TC_BODY(asinf_zero_neg, tc)
263 {
264 const float x = -0.0L;
265 float y = asinf(x);
266
267 if (fabsf(y) > 0.0 || signbit(y) == 0)
268 atf_tc_fail_nonfatal("asinf(-0.0) != -0.0");
269 }
270
271 ATF_TC(asinf_zero_pos);
ATF_TC_HEAD(asinf_zero_pos,tc)272 ATF_TC_HEAD(asinf_zero_pos, tc)
273 {
274 atf_tc_set_md_var(tc, "descr", "Test asinf(+0.0) == +0.0");
275 }
276
ATF_TC_BODY(asinf_zero_pos,tc)277 ATF_TC_BODY(asinf_zero_pos, tc)
278 {
279 const float x = 0.0L;
280 float y = asinf(x);
281
282 if (fabsf(y) > 0.0 || signbit(y) != 0)
283 atf_tc_fail_nonfatal("asinf(+0.0) != +0.0");
284 }
285
ATF_TP_ADD_TCS(tp)286 ATF_TP_ADD_TCS(tp)
287 {
288
289 ATF_TP_ADD_TC(tp, asin_nan);
290 ATF_TP_ADD_TC(tp, asin_inf_neg);
291 ATF_TP_ADD_TC(tp, asin_inf_pos);
292 ATF_TP_ADD_TC(tp, asin_range);
293 ATF_TP_ADD_TC(tp, asin_inrange);
294 ATF_TP_ADD_TC(tp, asin_zero_neg);
295 ATF_TP_ADD_TC(tp, asin_zero_pos);
296
297 ATF_TP_ADD_TC(tp, asinf_nan);
298 ATF_TP_ADD_TC(tp, asinf_inf_neg);
299 ATF_TP_ADD_TC(tp, asinf_inf_pos);
300 ATF_TP_ADD_TC(tp, asinf_range);
301 ATF_TP_ADD_TC(tp, asinf_inrange);
302 ATF_TP_ADD_TC(tp, asinf_zero_neg);
303 ATF_TP_ADD_TC(tp, asinf_zero_pos);
304
305 return atf_no_error();
306 }
307