xref: /netbsd-src/tests/lib/libm/t_asin.c (revision ba65fde2d7fefa7d39838fa5fa855e62bd606b5e)
1 /* $NetBSD: t_asin.c,v 1.1 2011/09/17 18:08:35 jruoho 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 <math.h>
34 
35 /*
36  * asin(3)
37  */
38 ATF_TC(asin_nan);
39 ATF_TC_HEAD(asin_nan, tc)
40 {
41 	atf_tc_set_md_var(tc, "descr", "Test asin(NaN) == NaN");
42 }
43 
44 ATF_TC_BODY(asin_nan, tc)
45 {
46 #ifndef __vax__
47 	const double x = 0.0L / 0.0L;
48 
49 	if (isnan(asin(x)) == 0)
50 		atf_tc_fail_nonfatal("asin(NaN) != NaN");
51 #endif
52 }
53 
54 ATF_TC(asin_inf_neg);
55 ATF_TC_HEAD(asin_inf_neg, tc)
56 {
57 	atf_tc_set_md_var(tc, "descr", "Test asin(-Inf) == NaN");
58 }
59 
60 ATF_TC_BODY(asin_inf_neg, tc)
61 {
62 #ifndef __vax__
63 	const double x = -1.0L / 0.0L;
64 
65 	if (isnan(asin(x)) == 0)
66 		atf_tc_fail_nonfatal("asin(-Inf) != NaN");
67 #endif
68 }
69 
70 ATF_TC(asin_inf_pos);
71 ATF_TC_HEAD(asin_inf_pos, tc)
72 {
73 	atf_tc_set_md_var(tc, "descr", "Test asin(+Inf) == NaN");
74 }
75 
76 ATF_TC_BODY(asin_inf_pos, tc)
77 {
78 #ifndef __vax__
79 	const double x = 1.0L / 0.0L;
80 
81 	if (isnan(asin(x)) == 0)
82 		atf_tc_fail_nonfatal("asin(+Inf) != NaN");
83 #endif
84 }
85 
86 ATF_TC(asin_range);
87 ATF_TC_HEAD(asin_range, tc)
88 {
89 	atf_tc_set_md_var(tc, "descr", "Test asin(x) == NaN, x < -1, x > 1");
90 }
91 
92 ATF_TC_BODY(asin_range, tc)
93 {
94 #ifndef __vax__
95 	const double x[] = { -1.1, -1.000000001, 1.1, 1.000000001 };
96 	size_t i;
97 
98 	for (i = 0; i < __arraycount(x); i++) {
99 
100 		if (isnan(asin(x[i])) == 0)
101 			atf_tc_fail_nonfatal("asin(%f) != NaN", x[i]);
102 	}
103 #endif
104 }
105 
106 ATF_TC(asin_sin);
107 ATF_TC_HEAD(asin_sin, tc)
108 {
109 	atf_tc_set_md_var(tc, "descr", "Test asin(sin(x)) == x");
110 }
111 
112 ATF_TC_BODY(asin_sin, tc)
113 {
114 #ifndef __vax__
115 	const double x[] = { 0.0, 1.0, M_PI / 2, M_PI / 3, M_PI / 6 };
116 	const double eps = 1.0e-40;
117 	double y;
118 	size_t i;
119 
120 	for (i = 0; i < __arraycount(x); i++) {
121 
122 		y = asin(sin(x[i]));
123 
124 		if (fabs(y - x[i]) > eps)
125 			atf_tc_fail_nonfatal("asin(sin(%0.03f)) != %0.03f",
126 			    x[i], x[i]);
127 	}
128 #endif
129 }
130 
131 ATF_TC(asin_zero_neg);
132 ATF_TC_HEAD(asin_zero_neg, tc)
133 {
134 	atf_tc_set_md_var(tc, "descr", "Test asin(-0.0) == -0.0");
135 }
136 
137 ATF_TC_BODY(asin_zero_neg, tc)
138 {
139 #ifndef __vax__
140 	const double x = -0.0L;
141 	double y = asin(x);
142 
143 	if (fabs(y) > 0.0 || signbit(y) == 0)
144 		atf_tc_fail_nonfatal("asin(-0.0) != -0.0");
145 #endif
146 }
147 
148 ATF_TC(asin_zero_pos);
149 ATF_TC_HEAD(asin_zero_pos, tc)
150 {
151 	atf_tc_set_md_var(tc, "descr", "Test asin(+0.0) == +0.0");
152 }
153 
154 ATF_TC_BODY(asin_zero_pos, tc)
155 {
156 #ifndef __vax__
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 #endif
163 }
164 
165 /*
166  * asinf(3)
167  */
168 ATF_TC(asinf_nan);
169 ATF_TC_HEAD(asinf_nan, tc)
170 {
171 	atf_tc_set_md_var(tc, "descr", "Test asinf(NaN) == NaN");
172 }
173 
174 ATF_TC_BODY(asinf_nan, tc)
175 {
176 #ifndef __vax__
177 	const float x = 0.0L / 0.0L;
178 
179 	if (isnan(asinf(x)) == 0)
180 		atf_tc_fail_nonfatal("asinf(NaN) != NaN");
181 #endif
182 }
183 
184 ATF_TC(asinf_inf_neg);
185 ATF_TC_HEAD(asinf_inf_neg, tc)
186 {
187 	atf_tc_set_md_var(tc, "descr", "Test asinf(-Inf) == NaN");
188 }
189 
190 ATF_TC_BODY(asinf_inf_neg, tc)
191 {
192 #ifndef __vax__
193 	const float x = -1.0L / 0.0L;
194 
195 	if (isnan(asinf(x)) == 0)
196 		atf_tc_fail_nonfatal("asinf(-Inf) != NaN");
197 #endif
198 }
199 
200 ATF_TC(asinf_inf_pos);
201 ATF_TC_HEAD(asinf_inf_pos, tc)
202 {
203 	atf_tc_set_md_var(tc, "descr", "Test asinf(+Inf) == NaN");
204 }
205 
206 ATF_TC_BODY(asinf_inf_pos, tc)
207 {
208 #ifndef __vax__
209 	const float x = 1.0L / 0.0L;
210 
211 	if (isnan(asinf(x)) == 0)
212 		atf_tc_fail_nonfatal("asinf(+Inf) != NaN");
213 #endif
214 }
215 
216 ATF_TC(asinf_range);
217 ATF_TC_HEAD(asinf_range, tc)
218 {
219 	atf_tc_set_md_var(tc, "descr", "Test asinf(x) == NaN, x < -1, x > 1");
220 }
221 
222 ATF_TC_BODY(asinf_range, tc)
223 {
224 #ifndef __vax__
225 	const float x[] = { -1.1, -1.0000001, 1.1, 1.0000001 };
226 	size_t i;
227 
228 	for (i = 0; i < __arraycount(x); i++) {
229 
230 		if (isnan(asinf(x[i])) == 0)
231 			atf_tc_fail_nonfatal("asinf(%f) != NaN", x[i]);
232 	}
233 #endif
234 }
235 
236 ATF_TC(asinf_sinf);
237 ATF_TC_HEAD(asinf_sinf, tc)
238 {
239 	atf_tc_set_md_var(tc, "descr", "Test asinf(sinf(x)) == x");
240 }
241 
242 ATF_TC_BODY(asinf_sinf, tc)
243 {
244 #ifndef __vax__
245 	const float x[] = { 0.0, 1.0, M_PI / 2, M_PI / 3, M_PI / 6 };
246 	const float eps = 1.0e-6;
247 	float y;
248 	size_t i;
249 
250 	for (i = 0; i < __arraycount(x); i++) {
251 
252 		y = asinf(sinf(x[i]));
253 
254 		if (fabsf(y - x[i]) > eps)
255 			atf_tc_fail_nonfatal("asinf(sinf(%0.03f)) != %0.03f",
256 			    x[i], x[i]);
257 	}
258 #endif
259 }
260 
261 ATF_TC(asinf_zero_neg);
262 ATF_TC_HEAD(asinf_zero_neg, tc)
263 {
264 	atf_tc_set_md_var(tc, "descr", "Test asinf(-0.0) == -0.0");
265 }
266 
267 ATF_TC_BODY(asinf_zero_neg, tc)
268 {
269 #ifndef __vax__
270 	const float x = -0.0L;
271 	float y = asinf(x);
272 
273 	if (fabsf(y) > 0.0 || signbit(y) == 0)
274 		atf_tc_fail_nonfatal("asinf(-0.0) != -0.0");
275 #endif
276 }
277 
278 ATF_TC(asinf_zero_pos);
279 ATF_TC_HEAD(asinf_zero_pos, tc)
280 {
281 	atf_tc_set_md_var(tc, "descr", "Test asinf(+0.0) == +0.0");
282 }
283 
284 ATF_TC_BODY(asinf_zero_pos, tc)
285 {
286 #ifndef __vax__
287 	const float x = 0.0L;
288 	float y = asinf(x);
289 
290 	if (fabsf(y) > 0.0 || signbit(y) != 0)
291 		atf_tc_fail_nonfatal("asinf(+0.0) != +0.0");
292 #endif
293 }
294 
295 ATF_TP_ADD_TCS(tp)
296 {
297 
298 	ATF_TP_ADD_TC(tp, asin_nan);
299 	ATF_TP_ADD_TC(tp, asin_inf_neg);
300 	ATF_TP_ADD_TC(tp, asin_inf_pos);
301 	ATF_TP_ADD_TC(tp, asin_range);
302 	ATF_TP_ADD_TC(tp, asin_sin);
303 	ATF_TP_ADD_TC(tp, asin_zero_neg);
304 	ATF_TP_ADD_TC(tp, asin_zero_pos);
305 
306 	ATF_TP_ADD_TC(tp, asinf_nan);
307 	ATF_TP_ADD_TC(tp, asinf_inf_neg);
308 	ATF_TP_ADD_TC(tp, asinf_inf_pos);
309 	ATF_TP_ADD_TC(tp, asinf_range);
310 	ATF_TP_ADD_TC(tp, asinf_sinf);
311 	ATF_TP_ADD_TC(tp, asinf_zero_neg);
312 	ATF_TP_ADD_TC(tp, asinf_zero_pos);
313 
314 	return atf_no_error();
315 }
316