1 /* $NetBSD: t_exp.c,v 1.9 2018/11/07 03:59:36 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 #include "t_libm.h"
36
37 /* y = exp(x) */
38 static const struct {
39 double x;
40 double y;
41 } exp_values[] = {
42 { -10, 0.4539992976248485e-4, },
43 { -5, 0.6737946999085467e-2, },
44 { -1, 0.3678794411714423, },
45 { -0.1, 0.9048374180359595, },
46 { 0, 1.0000000000000000, },
47 { 0.1, 1.1051709180756477, },
48 { 1, 2.7182818284590452, },
49 { 5, 148.41315910257660, },
50 { 10, 22026.465794806718, },
51 };
52
53 /*
54 * exp2/exp2f(3)
55 */
56 ATF_LIBM_TEST(exp2_is_nan, "Test exp2(x) == NaN")
57 {
58 #ifdef T_LIBM_NAN
59 T_LIBM_CHECK_NAN(0, exp2, T_LIBM_NAN);
60 T_LIBM_CHECK_NAN(0, exp2f, T_LIBM_NAN);
61 #else
62 atf_tc_skip("no NaN on this machine");
63 #endif
64 }
65
66 ATF_LIBM_TEST(exp2_is_plus_zero, "Test exp2(x) == +0.0")
67 {
68 #ifdef T_LIBM_MINUS_INF
69 T_LIBM_CHECK_PLUS_ZERO(0, exp2, T_LIBM_MINUS_INF);
70 T_LIBM_CHECK_PLUS_ZERO(0, exp2f, T_LIBM_MINUS_INF);
71 #else
72 atf_tc_skip("no +/-Inf on this machine");
73 #endif
74 }
75
76 ATF_LIBM_TEST(exp2_powers, "Test exp2(x) is correct for some integer x")
77 {
78 static const struct {
79 double x;
80 double d_y;
81 double f_y;
82 } v[] = {
83 { +0.0, 1.0, 1.0 },
84 { -0.0, 1.0, 1.0 },
85 { 1, 0x1p1, 0x1p1 },
86 { 2, 0x1p2, 0x1p2 },
87 { 100, 0x1p100, 0x1p100 },
88 { 125, 0x1p125, 0x1p125 },
89 { 126, 0x1p126, 0x1p126 },
90 #if __DBL_MAX_EXP__ > 129
91 { 127, 0x1p127, 0x1p127 },
92 #endif
93 #ifdef T_LIBM_PLUS_INF
94 { 128, 0x1p128, T_LIBM_PLUS_INF },
95 { 129, 0x1p129, T_LIBM_PLUS_INF },
96 { 1000, 0x1p1000, T_LIBM_PLUS_INF },
97 { 1020, 0x1p1020, T_LIBM_PLUS_INF },
98 { 1023, 0x1p1023, T_LIBM_PLUS_INF },
99 { 1024, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF },
100 { 1030, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF },
101 { 1050, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF },
102 { 2000, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF },
103 { 16383, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF },
104 { 16384, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF },
105 { 16385, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF },
106 #endif
107 { -1, 0x1p-1, 0x1p-1 },
108 { -2, 0x1p-2, 0x1p-2 },
109 { -100, 0x1p-100, 0x1p-100 },
110 { -127, 0x1p-127, 0x1p-127 },
111 { -128, 0x1p-128, 0x1p-128 },
112 #if __LDBL_MIN_EXP__ < -129
113 { -300, 0x1p-300, 0.0},
114 { -400, 0x1p-400, 0.0},
115 {-1000, 0x1p-1000, 0.0},
116 {-1022, 0x1p-1022, 0.0},
117 /* These should be denormal numbers */
118 {-1023, 0x1p-1023, 0.0},
119 {-1024, 0x1p-1024, 0.0},
120 {-1040, 0x1p-1040, 0.0},
121 {-1060, 0x1p-1060, 0.0},
122 /* This is the smallest result gcc will allow */
123 {-1074, 0x1p-1074, 0.0},
124 #endif
125 {-1075, 0x0, 0.0},
126 {-1080, 0x0, 0.0},
127 {-2000, 0x0, 0.0},
128 {-16382, 0x0, 0.0},
129 {-16383, 0x0, 0.0},
130 {-16384, 0x0, 0.0},
131 };
132 unsigned int i;
133
134 for (i = 0; i < __arraycount(v); i++) {
135 T_LIBM_CHECK(i, exp2, v[i].x, v[i].d_y, 0.0);
136 T_LIBM_CHECK(i, exp2f, v[i].x, v[i].f_y, 0.0);
137 }
138 }
139
140 ATF_LIBM_TEST(exp2_values, "Test exp2(x) is correct for some x")
141 {
142 static const struct {
143 double x;
144 double d_y;
145 float f_y;
146 double d_eps;
147 double f_eps;
148 } v[] = {
149 #if __DBL_MAX_EXP__ > 128
150 /* The largest double constant */
151 { 0x1.fffffffffffffp9, 0x1.ffffffffffd3ap1023, 0.00,
152 0x1p969, 0.0 },
153 /* The largest float constant */
154 { 0x1.fffffep6, 0x1.ffff4ep+127, 0x1.ffff4ep+127, 6e30, 0.0 },
155 #endif
156 #ifdef T_LIBM_PLUS_INF
157 { T_LIBM_PLUS_INF, T_LIBM_PLUS_INF, T_LIBM_PLUS_INF, 0.0, 0.0 },
158 #endif
159
160 /* The few values from the old tests */
161 /* Results from i386/amd64, d_eps needed on i386 */
162 /* f_y values calculated using py-mpmath */
163 { 1.1, 0x1.125fbee250664p+1, 0x1.125fc0p+1, 0x1p-52, 0x1.8p-22 },
164 { 2.2, 0x1.2611186bae675p+2, 0x1.26111ap+2, 0x1p-51, 0x1.8p-21 },
165 { 3.3, 0x1.3b2c47bff8328p+3, 0x1.3b2c48p+3, 0x1p-50, 0x1.8p-20 },
166 { 4.4, 0x1.51cb453b9536ep+4, 0x1.51cb46p+4, 0x1p-49, 0x1.8p-19 },
167 { 5.5, 0x1.6a09e667f3bcdp+5, 0x1.6a09e6p+5, 0x1p-48, 0x1.8p-18 },
168 { 6.6, 0x1.8406003b2ae5bp+6, 0x1.8405fep+6, 0x1p-47, 0x1.8p-17 },
169 { 7.7, 0x1.9fdf8bcce533ep+7, 0x1.9fdf88p+7, 0x1p-46, 0x1.8p-16 },
170 { 8.8, 0x1.bdb8cdadbe124p+8, 0x1.bdb8d2p+8, 0x1p-45, 0x1.8p-15 },
171 };
172 unsigned int i;
173
174 for (i = 0; i < __arraycount(v); i++) {
175 T_LIBM_CHECK(i, exp2, v[i].x, v[i].d_y, v[i].d_eps);
176 if (i > 1)
177 T_LIBM_CHECK(i, exp2f, v[i].x, v[i].f_y, v[i].f_eps);
178 }
179 }
180
181
182 /*
183 * exp(3)
184 */
185 ATF_TC(exp_nan);
ATF_TC_HEAD(exp_nan,tc)186 ATF_TC_HEAD(exp_nan, tc)
187 {
188 atf_tc_set_md_var(tc, "descr", "Test exp(NaN) == NaN");
189 }
190
ATF_TC_BODY(exp_nan,tc)191 ATF_TC_BODY(exp_nan, tc)
192 {
193 const double x = 0.0L / 0.0L;
194
195 if (isnan(exp(x)) == 0)
196 atf_tc_fail_nonfatal("exp(NaN) != NaN");
197 }
198
199 ATF_TC(exp_inf_neg);
ATF_TC_HEAD(exp_inf_neg,tc)200 ATF_TC_HEAD(exp_inf_neg, tc)
201 {
202 atf_tc_set_md_var(tc, "descr", "Test exp(-Inf) == +0.0");
203 }
204
ATF_TC_BODY(exp_inf_neg,tc)205 ATF_TC_BODY(exp_inf_neg, tc)
206 {
207 const double x = -1.0L / 0.0L;
208 double y = exp(x);
209
210 if (fabs(y) > 0.0 || signbit(y) != 0)
211 atf_tc_fail_nonfatal("exp(-Inf) != +0.0");
212 }
213
214 ATF_TC(exp_inf_pos);
ATF_TC_HEAD(exp_inf_pos,tc)215 ATF_TC_HEAD(exp_inf_pos, tc)
216 {
217 atf_tc_set_md_var(tc, "descr", "Test exp(+Inf) == +Inf");
218 }
219
ATF_TC_BODY(exp_inf_pos,tc)220 ATF_TC_BODY(exp_inf_pos, tc)
221 {
222 const double x = 1.0L / 0.0L;
223 double y = exp(x);
224
225 if (isinf(y) == 0 || signbit(y) != 0)
226 atf_tc_fail_nonfatal("exp(+Inf) != +Inf");
227 }
228
229 ATF_TC(exp_product);
ATF_TC_HEAD(exp_product,tc)230 ATF_TC_HEAD(exp_product, tc)
231 {
232 atf_tc_set_md_var(tc, "descr", "Test some selected exp(x)");
233 }
234
ATF_TC_BODY(exp_product,tc)235 ATF_TC_BODY(exp_product, tc)
236 {
237 const double eps = DBL_EPSILON;
238 size_t i;
239
240 for (i = 0; i < __arraycount(exp_values); i++) {
241 double x = exp_values[i].x;
242 double e_x = exp_values[i].y;
243
244 if (!(fabs((exp(x) - e_x)/e_x) <= eps)) {
245 atf_tc_fail_nonfatal("exp(%.17g) = %.17g != %.17g",
246 x, exp(x), e_x);
247 }
248 }
249 }
250
251 ATF_TC(exp_zero_neg);
ATF_TC_HEAD(exp_zero_neg,tc)252 ATF_TC_HEAD(exp_zero_neg, tc)
253 {
254 atf_tc_set_md_var(tc, "descr", "Test exp(-0.0) == 1.0");
255 }
256
ATF_TC_BODY(exp_zero_neg,tc)257 ATF_TC_BODY(exp_zero_neg, tc)
258 {
259 const double x = -0.0L;
260
261 if (fabs(exp(x) - 1.0) > 0.0)
262 atf_tc_fail_nonfatal("exp(-0.0) != 1.0");
263 }
264
265 ATF_TC(exp_zero_pos);
ATF_TC_HEAD(exp_zero_pos,tc)266 ATF_TC_HEAD(exp_zero_pos, tc)
267 {
268 atf_tc_set_md_var(tc, "descr", "Test exp(+0.0) == 1.0");
269 }
270
ATF_TC_BODY(exp_zero_pos,tc)271 ATF_TC_BODY(exp_zero_pos, tc)
272 {
273 const double x = 0.0L;
274
275 if (fabs(exp(x) - 1.0) > 0.0)
276 atf_tc_fail_nonfatal("exp(+0.0) != 1.0");
277 }
278
279 /*
280 * expf(3)
281 */
282 ATF_TC(expf_nan);
ATF_TC_HEAD(expf_nan,tc)283 ATF_TC_HEAD(expf_nan, tc)
284 {
285 atf_tc_set_md_var(tc, "descr", "Test expf(NaN) == NaN");
286 }
287
ATF_TC_BODY(expf_nan,tc)288 ATF_TC_BODY(expf_nan, tc)
289 {
290 const float x = 0.0L / 0.0L;
291
292 if (isnan(expf(x)) == 0)
293 atf_tc_fail_nonfatal("expf(NaN) != NaN");
294 }
295
296 ATF_TC(expf_inf_neg);
ATF_TC_HEAD(expf_inf_neg,tc)297 ATF_TC_HEAD(expf_inf_neg, tc)
298 {
299 atf_tc_set_md_var(tc, "descr", "Test expf(-Inf) == +0.0");
300 }
301
ATF_TC_BODY(expf_inf_neg,tc)302 ATF_TC_BODY(expf_inf_neg, tc)
303 {
304 const float x = -1.0L / 0.0L;
305 float y = expf(x);
306
307 if (fabsf(y) > 0.0 || signbit(y) != 0)
308 atf_tc_fail_nonfatal("expf(-Inf) != +0.0");
309 }
310
311 ATF_TC(expf_inf_pos);
ATF_TC_HEAD(expf_inf_pos,tc)312 ATF_TC_HEAD(expf_inf_pos, tc)
313 {
314 atf_tc_set_md_var(tc, "descr", "Test expf(+Inf) == +Inf");
315 }
316
ATF_TC_BODY(expf_inf_pos,tc)317 ATF_TC_BODY(expf_inf_pos, tc)
318 {
319 const float x = 1.0L / 0.0L;
320 float y = expf(x);
321
322 if (isinf(y) == 0 || signbit(y) != 0)
323 atf_tc_fail_nonfatal("expf(+Inf) != +Inf");
324 }
325
326 ATF_TC(expf_product);
ATF_TC_HEAD(expf_product,tc)327 ATF_TC_HEAD(expf_product, tc)
328 {
329 atf_tc_set_md_var(tc, "descr", "Test some selected expf(x)");
330 }
331
ATF_TC_BODY(expf_product,tc)332 ATF_TC_BODY(expf_product, tc)
333 {
334 const float eps = FLT_EPSILON;
335 size_t i;
336
337 for (i = 0; i < __arraycount(exp_values); i++) {
338 float x = exp_values[i].x;
339 float e_x = exp_values[i].y;
340
341 if (!(fabsf((expf(x) - e_x)/e_x) <= eps)) {
342 atf_tc_fail_nonfatal("expf(%.8g) = %.8g != %.8g",
343 x, exp(x), e_x);
344 }
345 }
346 }
347
348 ATF_TC(expf_zero_neg);
ATF_TC_HEAD(expf_zero_neg,tc)349 ATF_TC_HEAD(expf_zero_neg, tc)
350 {
351 atf_tc_set_md_var(tc, "descr", "Test expf(-0.0) == 1.0");
352 }
353
ATF_TC_BODY(expf_zero_neg,tc)354 ATF_TC_BODY(expf_zero_neg, tc)
355 {
356 const float x = -0.0L;
357
358 if (fabsf(expf(x) - 1.0f) > 0.0)
359 atf_tc_fail_nonfatal("expf(-0.0) != 1.0");
360 }
361
362 ATF_TC(expf_zero_pos);
ATF_TC_HEAD(expf_zero_pos,tc)363 ATF_TC_HEAD(expf_zero_pos, tc)
364 {
365 atf_tc_set_md_var(tc, "descr", "Test expf(+0.0) == 1.0");
366 }
367
ATF_TC_BODY(expf_zero_pos,tc)368 ATF_TC_BODY(expf_zero_pos, tc)
369 {
370 const float x = 0.0L;
371
372 if (fabsf(expf(x) - 1.0f) > 0.0)
373 atf_tc_fail_nonfatal("expf(+0.0) != 1.0");
374 }
375
376 /*
377 * expm1(3)
378 */
379 ATF_TC(expm1_nan);
ATF_TC_HEAD(expm1_nan,tc)380 ATF_TC_HEAD(expm1_nan, tc)
381 {
382 atf_tc_set_md_var(tc, "descr", "Test expm1(NaN) == NaN");
383 }
384
ATF_TC_BODY(expm1_nan,tc)385 ATF_TC_BODY(expm1_nan, tc)
386 {
387 const double x = 0.0L / 0.0L;
388
389 if (isnan(expm1(x)) == 0)
390 atf_tc_fail_nonfatal("expm1(NaN) != NaN");
391 }
392
393 ATF_TC(expm1_inf_neg);
ATF_TC_HEAD(expm1_inf_neg,tc)394 ATF_TC_HEAD(expm1_inf_neg, tc)
395 {
396 atf_tc_set_md_var(tc, "descr", "Test expm1(-Inf) == -1");
397 }
398
ATF_TC_BODY(expm1_inf_neg,tc)399 ATF_TC_BODY(expm1_inf_neg, tc)
400 {
401 const double x = -1.0L / 0.0L;
402
403 if (expm1(x) != -1.0)
404 atf_tc_fail_nonfatal("expm1(-Inf) != -1.0");
405 }
406
407 ATF_TC(expm1_inf_pos);
ATF_TC_HEAD(expm1_inf_pos,tc)408 ATF_TC_HEAD(expm1_inf_pos, tc)
409 {
410 atf_tc_set_md_var(tc, "descr", "Test expm1(+Inf) == +Inf");
411 }
412
ATF_TC_BODY(expm1_inf_pos,tc)413 ATF_TC_BODY(expm1_inf_pos, tc)
414 {
415 const double x = 1.0L / 0.0L;
416 double y = expm1(x);
417
418 if (isinf(y) == 0 || signbit(y) != 0)
419 atf_tc_fail_nonfatal("expm1(+Inf) != +Inf");
420 }
421
422 ATF_TC(expm1_zero_neg);
ATF_TC_HEAD(expm1_zero_neg,tc)423 ATF_TC_HEAD(expm1_zero_neg, tc)
424 {
425 atf_tc_set_md_var(tc, "descr", "Test expm1(-0.0) == -0.0");
426 }
427
ATF_TC_BODY(expm1_zero_neg,tc)428 ATF_TC_BODY(expm1_zero_neg, tc)
429 {
430 const double x = -0.0L;
431 double y = expm1(x);
432
433 if (fabs(y) > 0.0 || signbit(y) == 0)
434 atf_tc_fail_nonfatal("expm1(-0.0) != -0.0");
435 }
436
437 ATF_TC(expm1_zero_pos);
ATF_TC_HEAD(expm1_zero_pos,tc)438 ATF_TC_HEAD(expm1_zero_pos, tc)
439 {
440 atf_tc_set_md_var(tc, "descr", "Test expm1(+0.0) == 1.0");
441 }
442
ATF_TC_BODY(expm1_zero_pos,tc)443 ATF_TC_BODY(expm1_zero_pos, tc)
444 {
445 const double x = 0.0L;
446 double y = expm1(x);
447
448 if (fabs(y) > 0.0 || signbit(y) != 0)
449 atf_tc_fail_nonfatal("expm1(+0.0) != +0.0");
450 }
451
452 /*
453 * expm1f(3)
454 */
455 ATF_TC(expm1f_nan);
ATF_TC_HEAD(expm1f_nan,tc)456 ATF_TC_HEAD(expm1f_nan, tc)
457 {
458 atf_tc_set_md_var(tc, "descr", "Test expm1f(NaN) == NaN");
459 }
460
ATF_TC_BODY(expm1f_nan,tc)461 ATF_TC_BODY(expm1f_nan, tc)
462 {
463 const float x = 0.0L / 0.0L;
464
465 if (isnan(expm1f(x)) == 0)
466 atf_tc_fail_nonfatal("expm1f(NaN) != NaN");
467 }
468
469 ATF_TC(expm1f_inf_neg);
ATF_TC_HEAD(expm1f_inf_neg,tc)470 ATF_TC_HEAD(expm1f_inf_neg, tc)
471 {
472 atf_tc_set_md_var(tc, "descr", "Test expm1f(-Inf) == -1");
473 }
474
ATF_TC_BODY(expm1f_inf_neg,tc)475 ATF_TC_BODY(expm1f_inf_neg, tc)
476 {
477 const float x = -1.0L / 0.0L;
478
479 if (expm1f(x) != -1.0)
480 atf_tc_fail_nonfatal("expm1f(-Inf) != -1.0");
481 }
482
483 ATF_TC(expm1f_inf_pos);
ATF_TC_HEAD(expm1f_inf_pos,tc)484 ATF_TC_HEAD(expm1f_inf_pos, tc)
485 {
486 atf_tc_set_md_var(tc, "descr", "Test expm1f(+Inf) == +Inf");
487 }
488
ATF_TC_BODY(expm1f_inf_pos,tc)489 ATF_TC_BODY(expm1f_inf_pos, tc)
490 {
491 const float x = 1.0L / 0.0L;
492 float y = expm1f(x);
493
494 if (isinf(y) == 0 || signbit(y) != 0)
495 atf_tc_fail_nonfatal("expm1f(+Inf) != +Inf");
496 }
497
498 ATF_TC(expm1f_zero_neg);
ATF_TC_HEAD(expm1f_zero_neg,tc)499 ATF_TC_HEAD(expm1f_zero_neg, tc)
500 {
501 atf_tc_set_md_var(tc, "descr", "Test expm1f(-0.0) == -0.0");
502 }
503
ATF_TC_BODY(expm1f_zero_neg,tc)504 ATF_TC_BODY(expm1f_zero_neg, tc)
505 {
506 const float x = -0.0L;
507 float y = expm1f(x);
508
509 if (fabsf(y) > 0.0 || signbit(y) == 0)
510 atf_tc_fail_nonfatal("expm1f(-0.0) != -0.0");
511 }
512
513 ATF_TC(expm1f_zero_pos);
ATF_TC_HEAD(expm1f_zero_pos,tc)514 ATF_TC_HEAD(expm1f_zero_pos, tc)
515 {
516 atf_tc_set_md_var(tc, "descr", "Test expm1f(+0.0) == 1.0");
517 }
518
ATF_TC_BODY(expm1f_zero_pos,tc)519 ATF_TC_BODY(expm1f_zero_pos, tc)
520 {
521 const float x = 0.0L;
522 float y = expm1f(x);
523
524 if (fabsf(y) > 0.0 || signbit(y) != 0)
525 atf_tc_fail_nonfatal("expm1f(+0.0) != +0.0");
526 }
527
ATF_TP_ADD_TCS(tp)528 ATF_TP_ADD_TCS(tp)
529 {
530
531 ATF_TP_ADD_TC(tp, exp2_is_nan);
532 ATF_TP_ADD_TC(tp, exp2_is_plus_zero);
533 ATF_TP_ADD_TC(tp, exp2_values);
534 ATF_TP_ADD_TC(tp, exp2_powers);
535
536 ATF_TP_ADD_TC(tp, exp_nan);
537 ATF_TP_ADD_TC(tp, exp_inf_neg);
538 ATF_TP_ADD_TC(tp, exp_inf_pos);
539 ATF_TP_ADD_TC(tp, exp_product);
540 ATF_TP_ADD_TC(tp, exp_zero_neg);
541 ATF_TP_ADD_TC(tp, exp_zero_pos);
542
543 ATF_TP_ADD_TC(tp, expf_nan);
544 ATF_TP_ADD_TC(tp, expf_inf_neg);
545 ATF_TP_ADD_TC(tp, expf_inf_pos);
546 ATF_TP_ADD_TC(tp, expf_product);
547 ATF_TP_ADD_TC(tp, expf_zero_neg);
548 ATF_TP_ADD_TC(tp, expf_zero_pos);
549
550 ATF_TP_ADD_TC(tp, expm1_nan);
551 ATF_TP_ADD_TC(tp, expm1_inf_neg);
552 ATF_TP_ADD_TC(tp, expm1_inf_pos);
553 ATF_TP_ADD_TC(tp, expm1_zero_neg);
554 ATF_TP_ADD_TC(tp, expm1_zero_pos);
555
556 ATF_TP_ADD_TC(tp, expm1f_nan);
557 ATF_TP_ADD_TC(tp, expm1f_inf_neg);
558 ATF_TP_ADD_TC(tp, expm1f_inf_pos);
559 ATF_TP_ADD_TC(tp, expm1f_zero_neg);
560 ATF_TP_ADD_TC(tp, expm1f_zero_pos);
561
562 return atf_no_error();
563 }
564