add generated math tests

[libc-test] / src / math / gen / functions.h

diff --git a/src/math/gen/functions.h b/src/math/gen/functions.h
new file mode 100644 (file)
index 0000000..104608e
--- /dev/null
+++ b/src/math/gen/functions.h
@@ -0,0 +1,166 @@
+T(acos,        d_d)
+T(acosf,       f_f)
+T(acosl,       l_l)
+T(acosh,       d_d)
+T(acoshf,      f_f)
+T(acoshl,      l_l)
+T(asin,        d_d)
+T(asinf,       f_f)
+T(asinl,       l_l)
+T(asinh,       d_d)
+T(asinhf,      f_f)
+T(asinhl,      l_l)
+T(atan,        d_d)
+T(atanf,       f_f)
+T(atanl,       l_l)
+T(atan2,       dd_d)
+T(atan2f,      ff_f)
+T(atan2l,      ll_l)
+T(atanh,       d_d)
+T(atanhf,      f_f)
+T(atanhl,      l_l)
+T(cbrt,        d_d)
+T(cbrtf,       f_f)
+T(cbrtl,       l_l)
+T(ceil,        d_d)
+T(ceilf,       f_f)
+T(ceill,       l_l)
+T(copysign,    dd_d)
+T(copysignf,   ff_f)
+T(copysignl,   ll_l)
+T(cos,         d_d)
+T(cosf,        f_f)
+T(cosl,        l_l)
+T(cosh,        d_d)
+T(coshf,       f_f)
+T(coshl,       l_l)
+T(erf,         d_d)
+T(erff,        f_f)
+T(erfl,        l_l)
+T(erfc,        d_d)
+T(erfcf,       f_f)
+T(erfcl,       l_l)
+T(exp,         d_d)
+T(expf,        f_f)
+T(expl,        l_l)
+T(exp2,        d_d)
+T(exp2f,       f_f)
+T(exp2l,       l_l)
+T(expm1,       d_d)
+T(expm1f,      f_f)
+T(expm1l,      l_l)
+T(fabs,        d_d)
+T(fabsf,       f_f)
+T(fabsl,       l_l)
+T(fdim,        dd_d)
+T(fdimf,       ff_f)
+T(fdiml,       ll_l)
+T(floor,       d_d)
+T(floorf,      f_f)
+T(floorl,      l_l)
+T(fmax,        dd_d)
+T(fmaxf,       ff_f)
+T(fmaxl,       ll_l)
+T(fmin,        dd_d)
+T(fminf,       ff_f)
+T(fminl,       ll_l)
+T(fmod,        dd_d)
+T(fmodf,       ff_f)
+T(fmodl,       ll_l)
+T(hypot,       dd_d)
+T(hypotf,      ff_f)
+T(hypotl,      ll_l)
+T(log,         d_d)
+T(logf,        f_f)
+T(logl,        l_l)
+T(log10,       d_d)
+T(log10f,      f_f)
+T(log10l,      l_l)
+T(log1p,       d_d)
+T(log1pf,      f_f)
+T(log1pl,      l_l)
+T(log2,        d_d)
+T(log2f,       f_f)
+T(log2l,       l_l)
+T(logb,        d_d)
+T(logbf,       f_f)
+T(logbl,       l_l)
+T(nearbyint,   d_d)
+T(nearbyintf,  f_f)
+T(nearbyintl,  l_l)
+T(nextafter,   dd_d)
+T(nextafterf,  ff_f)
+T(nextafterl,  ll_l)
+T(nexttowardl, ll_l)
+T(pow,         dd_d)
+T(powf,        ff_f)
+T(powl,        ll_l)
+T(remainder,   dd_d)
+T(remainderf,  ff_f)
+T(remainderl,  ll_l)
+T(rint,        d_d)
+T(rintf,       f_f)
+T(rintl,       l_l)
+T(round,       d_d)
+T(roundf,      f_f)
+T(roundl,      l_l)
+T(sin,         d_d)
+T(sinf,        f_f)
+T(sinl,        l_l)
+T(sinh,        d_d)
+T(sinhf,       f_f)
+T(sinhl,       l_l)
+T(sqrt,        d_d)
+T(sqrtf,       f_f)
+T(sqrtl,       l_l)
+T(tan,         d_d)
+T(tanf,        f_f)
+T(tanl,        l_l)
+T(tanh,        d_d)
+T(tanhf,       f_f)
+T(tanhl,       l_l)
+T(tgamma,      d_d)
+T(tgammaf,     f_f)
+T(tgammal,     l_l)
+T(trunc,       d_d)
+T(truncf,      f_f)
+T(truncl,      l_l)
+T(j0,          d_d)
+T(j1,          d_d)
+T(y0,          d_d)
+T(y1,          d_d)
+T(scalb,       dd_d)
+T(scalbf,      ff_f)
+T(j0f,         f_f)
+T(j0l,         l_l)
+T(j1f,         f_f)
+T(j1l,         l_l)
+T(y0f,         f_f)
+T(y0l,         l_l)
+T(y1f,         f_f)
+T(y1l,         l_l)
+T(exp10,       d_d)
+T(exp10f,      f_f)
+T(exp10l,      l_l)
+T(pow10,       d_d)
+T(pow10f,      f_f)
+T(pow10l,      l_l)
+
+T(frexp,       d_di)
+T(frexpf,      f_fi)
+T(frexpl,      l_li)
+T(ldexp,       di_d)
+T(ldexpf,      fi_f)
+T(ldexpl,      li_l)
+T(scalbn,      di_d)
+T(scalbnf,     fi_f)
+T(scalbnl,     li_l)
+T(scalbln,     di_d)
+T(scalblnf,    fi_f)
+T(scalblnl,    li_l)
+T(lgamma,      d_di)
+T(lgammaf,     f_fi)
+T(lgammal,     l_li)
+T(lgamma_r,    d_di)
+T(lgammaf_r,   f_fi)
+T(lgammal_r,   l_li)