math: add jn and yn

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

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(nexttoward,  dl_d)
T(nexttowardf, fl_f)
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(j1f,         f_f)
T(y0f,         f_f)
T(y1f,         f_f)
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)

T(ilogb,       d_i)
T(ilogbf,      f_i)
T(ilogbl,      l_i)
T(llrint,      d_i)
T(llrintf,     f_i)
T(llrintl,     l_i)
T(lrint,       d_i)
T(lrintf,      f_i)
T(lrintl,      l_i)
T(llround,     d_i)
T(llroundf,    f_i)
T(llroundl,    l_i)
T(lround,      d_i)
T(lroundf,     f_i)
T(lroundl,     l_i)

T(modf,        d_dd)
T(modff,       f_ff)
T(modfl,       l_ll)
T(sincos,      d_dd)
T(sincosf,     f_ff)
T(sincosl,     l_ll)

T(remquo,      dd_di)
T(remquof,     ff_fi)
T(remquol,     ll_li)

T(fma,         ddd_d)
T(fmaf,        fff_f)
T(fmal,        lll_l)

T(jn,          di_d)
T(jnf,         fi_f)
T(yn,          di_d)
T(ynf,         fi_f)