long double tanhl(long double x)
{
union ldshape u = {x};
unsigned ex = u.i.se & 0x7fff;
unsigned sign = u.i.se & 0x8000;
uint32_t w;
long double t;
/* x = |x| */
u.i.se = ex;
x = u.f;
w = u.i.m >> 32;
if (ex > 0x3ffe || (ex == 0x3ffe && w > 0x8c9f53d5)) {
/* |x| > log(3)/2 ~= 0.5493 or nan */
if (ex >= 0x3fff+5) {
/* |x| >= 32 */
t = 1 + 0/(x + 0x1p-120f);
} else {
t = expm1l(2*x);
t = 1 - 2/(t+2);
}
} else if (ex > 0x3ffd || (ex == 0x3ffd && w > 0x82c577d4)) {
/* |x| > log(5/3)/2 ~= 0.2554 */
t = expm1l(2*x);
t = t/(t+2);
} else {
/* |x| is small */
t = expm1l(-2*x);
t = -t/(t+2);
}
return sign ? -t : t;
}
long double
tanhl(long double x) {
long double t, y, z;
int signx;
#ifndef lint
volatile long double dummy;
#endif
if (isnanl(x))
return (x + x); /* x is NaN */
signx = signbitl(x);
t = fabsl(x);
z = one;
if (t <= threshold) {
if (t > one)
z = one - two / (expm1l(t + t) + two);
else if (t > small) {
y = expm1l(-t - t);
z = -y / (y + two);
} else {
#ifndef lint
dummy = t + big;
/* inexact if t != 0 */
#endif
return (x);
}
} else if (!finitel(t))
return (copysignl(one, x));
else
return (signx ? -z + small * small : z - small * small);
return (signx ? -z : z);
}
static TACommandVerdict expm1l_cmd(TAThread thread,TAInputStream stream)
{
long double x, res;
// Prepare
x = readLongDouble(&stream);
errno = 0;
START_TARGET_OPERATION(thread);
// Execute
res = expm1l(x);
END_TARGET_OPERATION(thread);
// Response
writeLongDouble(thread, res);
writeInt(thread, errno);
sendResponse(thread);
return taDefaultVerdict;
}
long double coshl(long double x)
{
union ldshape u = {x};
unsigned ex = u.i.se & 0x7fff;
uint32_t w;
long double t;
/* |x| */
u.i.se = ex;
x = u.f;
w = u.i.m >> 32;
/* |x| < log(2) */
if (ex < 0x3fff-1 || (ex == 0x3fff-1 && w < 0xb17217f7)) {
if (ex < 0x3fff-32) {
FORCE_EVAL(x + 0x1p120f);
return 1;
}
t = expm1l(x);
return 1 + t*t/(2*(1+t));
}
/* |x| < log(LDBL_MAX) */
if (ex < 0x3fff+13 || (ex == 0x3fff+13 && w < 0xb17217f7)) {
t = expl(x);
return 0.5*(t + 1/t);
}
/* |x| > log(LDBL_MAX) or nan */
t = expl(0.5*x);
return 0.5*t*t;
}
void test_expm1()
{
static_assert((std::is_same<decltype(expm1((double)0)), double>::value), "");
static_assert((std::is_same<decltype(expm1f(0)), float>::value), "");
static_assert((std::is_same<decltype(expm1l(0)), long double>::value), "");
assert(expm1(0) == 0);
}
long double
sinhl(long double x)
{
long double r, t;
if (!finitel(x))
return (x + x); /* x is INF or NaN */
r = fabsl(x);
if (r < lnovft) {
t = expm1l(r);
r = copysignl((t + t / (one + t)) * half, x);
} else {
r = copysignl(expl((r - lnovft) - lnovlo), x);
r = scalbnl(r, 16383);
}
return (r);
}
long double
coshl(long double x)
{
long double t,w;
int32_t ex;
u_int32_t mx,lx;
/* High word of |x|. */
GET_LDOUBLE_WORDS(ex,mx,lx,x);
ex &= 0x7fff;
/* x is INF or NaN */
if(ex==0x7fff) return x*x;
/* |x| in [0,0.5*ln2], return 1+expm1l(|x|)^2/(2*expl(|x|)) */
if(ex < 0x3ffd || (ex == 0x3ffd && mx < 0xb17217f7u)) {
t = expm1l(fabsl(x));
w = one+t;
if (ex<0x3fbc) return w; /* cosh(tiny) = 1 */
return one+(t*t)/(w+w);
}
/* |x| in [0.5*ln2,22], return (exp(|x|)+1/exp(|x|)/2; */
if (ex < 0x4003 || (ex == 0x4003 && mx < 0xb0000000u)) {
t = expl(fabsl(x));
return half*t+half/t;
}
/* |x| in [22, ln(maxdouble)] return half*exp(|x|) */
if (ex < 0x400c || (ex == 0x400c && mx < 0xb1700000u))
return half*expl(fabsl(x));
/* |x| in [log(maxdouble), log(2*maxdouble)) */
if (ex == 0x400c && (mx < 0xb174ddc0u
|| (mx == 0xb174ddc0u && lx < 0x31aec0ebu)))
{
w = expl(half*fabsl(x));
t = half*w;
return t*w;
}
/* |x| >= log(2*maxdouble), cosh(x) overflow */
return huge*huge;
}
long double coshl( long double x )
{
static const long double overflow = 0x1.62e9bb80635d81d4p+13L; //ln(LDBL_MAX) + ln(2.0)
static const long double ln2 = 0.693147180559945309417232121458176568L; //ln(2)
long double fabsx = __builtin_fabsl( x );
long double t, w;
if( x != x ) return x + x;
if( fabsx < __builtin_infl() )
{
if( fabsx < 0.5L * ln2 )
{
if( fabsx > 0x1.0p-1000L ) //avoid underflow, save time
fabsx = expm1l( fabsx );
w = 1.0L + fabsx;
if( fabsx < 0x1.0p-67L )
return w;
return 1.0L + (fabsx*fabsx)/(w+w);
}
if( fabsx < 22.L )
{
t = expl( fabsx );
return 0.5L * t + 0.5L/t;
}
if( fabsx < overflow )
{
w = expl( 0.5L * fabsx );
t = 0.5L * w;
return t * w;
}
return fabsx * 0x1.0p16383L;
}
//Nan or Inf result
return fabsx + fabsx;
}
long double
coshl(long double x) {
long double t, w;
w = fabsl(x);
if (!finitel(w))
return (w + w); /* x is INF or NaN */
if (w < thr1) {
t = w < tinyl ? w : expm1l(w);
w = one + t;
if (w != one)
w = one + (t * t) / (w + w);
return (w);
} else if (w < thr2) {
t = expl(w);
return (half * (t + one / t));
} else if (w <= lnovftL)
return (half * expl(w));
else {
return (scalbnl(expl((w - MEP1 * ln2hi) - MEP1 * ln2lo), ME));
}
}
long double
coshl(long double x) {
long double w, t;
w = fabsl(x);
if (!finitel(w))
return (w + w); /* x is INF or NaN */
if (w < thr1) {
if (w < tinyl)
return (one + w); /* inexact+directed rounding */
t = expm1l(w);
w = one + t;
w = one + (t * t) / (w + w);
return (w);
}
if (w < thr2) {
t = expl(w);
return (half * (t + one / t));
}
if (w <= lnovft)
return (half * expl(w));
return (scalbnl(expl((w - lnovft) - lnovlo), 16383));
}
void
domathl (void)
{
#ifndef NO_LONG_DOUBLE
long double f1;
long double f2;
int i1;
f1 = acosl(0.0);
fprintf( stdout, "acosl : %Lf\n", f1);
f1 = acoshl(0.0);
fprintf( stdout, "acoshl : %Lf\n", f1);
f1 = asinl(1.0);
fprintf( stdout, "asinl : %Lf\n", f1);
f1 = asinhl(1.0);
fprintf( stdout, "asinhl : %Lf\n", f1);
f1 = atanl(M_PI_4);
fprintf( stdout, "atanl : %Lf\n", f1);
f1 = atan2l(2.3, 2.3);
fprintf( stdout, "atan2l : %Lf\n", f1);
f1 = atanhl(1.0);
fprintf( stdout, "atanhl : %Lf\n", f1);
f1 = cbrtl(27.0);
fprintf( stdout, "cbrtl : %Lf\n", f1);
f1 = ceill(3.5);
fprintf( stdout, "ceill : %Lf\n", f1);
f1 = copysignl(3.5, -2.5);
fprintf( stdout, "copysignl : %Lf\n", f1);
f1 = cosl(M_PI_2);
fprintf( stdout, "cosl : %Lf\n", f1);
f1 = coshl(M_PI_2);
fprintf( stdout, "coshl : %Lf\n", f1);
f1 = erfl(42.0);
fprintf( stdout, "erfl : %Lf\n", f1);
f1 = erfcl(42.0);
fprintf( stdout, "erfcl : %Lf\n", f1);
f1 = expl(0.42);
fprintf( stdout, "expl : %Lf\n", f1);
f1 = exp2l(0.42);
fprintf( stdout, "exp2l : %Lf\n", f1);
f1 = expm1l(0.00042);
fprintf( stdout, "expm1l : %Lf\n", f1);
f1 = fabsl(-1.123);
fprintf( stdout, "fabsl : %Lf\n", f1);
f1 = fdiml(1.123, 2.123);
fprintf( stdout, "fdiml : %Lf\n", f1);
f1 = floorl(0.5);
fprintf( stdout, "floorl : %Lf\n", f1);
f1 = floorl(-0.5);
fprintf( stdout, "floorl : %Lf\n", f1);
f1 = fmal(2.1, 2.2, 3.01);
fprintf( stdout, "fmal : %Lf\n", f1);
f1 = fmaxl(-0.42, 0.42);
fprintf( stdout, "fmaxl : %Lf\n", f1);
f1 = fminl(-0.42, 0.42);
fprintf( stdout, "fminl : %Lf\n", f1);
f1 = fmodl(42.0, 3.0);
fprintf( stdout, "fmodl : %Lf\n", f1);
/* no type-specific variant */
i1 = fpclassify(1.0);
fprintf( stdout, "fpclassify : %d\n", i1);
f1 = frexpl(42.0, &i1);
fprintf( stdout, "frexpl : %Lf\n", f1);
f1 = hypotl(42.0, 42.0);
fprintf( stdout, "hypotl : %Lf\n", f1);
i1 = ilogbl(42.0);
fprintf( stdout, "ilogbl : %d\n", i1);
/* no type-specific variant */
i1 = isfinite(3.0);
fprintf( stdout, "isfinite : %d\n", i1);
/* no type-specific variant */
i1 = isgreater(3.0, 3.1);
fprintf( stdout, "isgreater : %d\n", i1);
/* no type-specific variant */
i1 = isgreaterequal(3.0, 3.1);
fprintf( stdout, "isgreaterequal : %d\n", i1);
/* no type-specific variant */
i1 = isinf(3.0);
fprintf( stdout, "isinf : %d\n", i1);
/* no type-specific variant */
i1 = isless(3.0, 3.1);
fprintf( stdout, "isless : %d\n", i1);
/* no type-specific variant */
i1 = islessequal(3.0, 3.1);
fprintf( stdout, "islessequal : %d\n", i1);
/* no type-specific variant */
i1 = islessgreater(3.0, 3.1);
fprintf( stdout, "islessgreater : %d\n", i1);
/* no type-specific variant */
i1 = isnan(0.0);
fprintf( stdout, "isnan : %d\n", i1);
/* no type-specific variant */
i1 = isnormal(3.0);
fprintf( stdout, "isnormal : %d\n", i1);
/* no type-specific variant */
f1 = isunordered(1.0, 2.0);
fprintf( stdout, "isunordered : %d\n", i1);
f1 = j0l(1.2);
fprintf( stdout, "j0l : %Lf\n", f1);
f1 = j1l(1.2);
fprintf( stdout, "j1l : %Lf\n", f1);
f1 = jnl(2,1.2);
fprintf( stdout, "jnl : %Lf\n", f1);
f1 = ldexpl(1.2,3);
fprintf( stdout, "ldexpl : %Lf\n", f1);
f1 = lgammal(42.0);
fprintf( stdout, "lgammal : %Lf\n", f1);
f1 = llrintl(-0.5);
fprintf( stdout, "llrintl : %Lf\n", f1);
f1 = llrintl(0.5);
fprintf( stdout, "llrintl : %Lf\n", f1);
f1 = llroundl(-0.5);
fprintf( stdout, "lroundl : %Lf\n", f1);
f1 = llroundl(0.5);
fprintf( stdout, "lroundl : %Lf\n", f1);
f1 = logl(42.0);
fprintf( stdout, "logl : %Lf\n", f1);
f1 = log10l(42.0);
fprintf( stdout, "log10l : %Lf\n", f1);
f1 = log1pl(42.0);
fprintf( stdout, "log1pl : %Lf\n", f1);
f1 = log2l(42.0);
fprintf( stdout, "log2l : %Lf\n", f1);
f1 = logbl(42.0);
fprintf( stdout, "logbl : %Lf\n", f1);
f1 = lrintl(-0.5);
fprintf( stdout, "lrintl : %Lf\n", f1);
f1 = lrintl(0.5);
fprintf( stdout, "lrintl : %Lf\n", f1);
f1 = lroundl(-0.5);
fprintf( stdout, "lroundl : %Lf\n", f1);
f1 = lroundl(0.5);
fprintf( stdout, "lroundl : %Lf\n", f1);
f1 = modfl(42.0,&f2);
fprintf( stdout, "lmodfl : %Lf\n", f1);
f1 = nanl("");
fprintf( stdout, "nanl : %Lf\n", f1);
f1 = nearbyintl(1.5);
fprintf( stdout, "nearbyintl : %Lf\n", f1);
f1 = nextafterl(1.5,2.0);
fprintf( stdout, "nextafterl : %Lf\n", f1);
f1 = powl(3.01, 2.0);
fprintf( stdout, "powl : %Lf\n", f1);
f1 = remainderl(3.01,2.0);
fprintf( stdout, "remainderl : %Lf\n", f1);
f1 = remquol(29.0,3.0,&i1);
fprintf( stdout, "remquol : %Lf\n", f1);
f1 = rintl(0.5);
fprintf( stdout, "rintl : %Lf\n", f1);
f1 = rintl(-0.5);
fprintf( stdout, "rintl : %Lf\n", f1);
f1 = roundl(0.5);
fprintf( stdout, "roundl : %Lf\n", f1);
f1 = roundl(-0.5);
fprintf( stdout, "roundl : %Lf\n", f1);
f1 = scalblnl(1.2,3);
fprintf( stdout, "scalblnl : %Lf\n", f1);
f1 = scalbnl(1.2,3);
fprintf( stdout, "scalbnl : %Lf\n", f1);
/* no type-specific variant */
i1 = signbit(1.0);
fprintf( stdout, "signbit : %i\n", i1);
f1 = sinl(M_PI_4);
fprintf( stdout, "sinl : %Lf\n", f1);
f1 = sinhl(M_PI_4);
fprintf( stdout, "sinhl : %Lf\n", f1);
f1 = sqrtl(9.0);
fprintf( stdout, "sqrtl : %Lf\n", f1);
f1 = tanl(M_PI_4);
fprintf( stdout, "tanl : %Lf\n", f1);
f1 = tanhl(M_PI_4);
fprintf( stdout, "tanhl : %Lf\n", f1);
f1 = tgammal(2.1);
fprintf( stdout, "tgammal : %Lf\n", f1);
f1 = truncl(3.5);
fprintf( stdout, "truncl : %Lf\n", f1);
f1 = y0l(1.2);
fprintf( stdout, "y0l : %Lf\n", f1);
f1 = y1l(1.2);
fprintf( stdout, "y1l : %Lf\n", f1);
f1 = ynl(3,1.2);
fprintf( stdout, "ynl : %Lf\n", f1);
#endif
}
TEST(math, expm1l) {
ASSERT_DOUBLE_EQ(M_E - 1.0L, expm1l(1.0L));
}
TEST(math, expm1l) {
ASSERT_FLOAT_EQ(M_E - 1.0, expm1l(1.0));
}
static int testl(long double long_double_x, int int_x, long long_x)
{
int r = 0;
r += __finitel(long_double_x);
r += __fpclassifyl(long_double_x);
r += __isinfl(long_double_x);
r += __isnanl(long_double_x);
r += __signbitl(long_double_x);
r += acoshl(long_double_x);
r += acosl(long_double_x);
r += asinhl(long_double_x);
r += asinl(long_double_x);
r += atan2l(long_double_x, long_double_x);
r += atanhl(long_double_x);
r += atanl(long_double_x);
r += cbrtl(long_double_x);
r += ceill(long_double_x);
r += copysignl(long_double_x, long_double_x);
r += coshl(long_double_x);
r += cosl(long_double_x);
r += erfcl(long_double_x);
r += erfl(long_double_x);
r += exp2l(long_double_x);
r += expl(long_double_x);
r += expm1l(long_double_x);
r += fabsl(long_double_x);
r += fdiml(long_double_x, long_double_x);
r += floorl(long_double_x);
r += fmal(long_double_x, long_double_x, long_double_x);
r += fmaxl(long_double_x, long_double_x);
r += fminl(long_double_x, long_double_x);
r += fmodl(long_double_x, long_double_x);
r += frexpl(long_double_x, &int_x);
r += hypotl(long_double_x, long_double_x);
r += ilogbl(long_double_x);
r += ldexpl(long_double_x, int_x);
r += lgammal(long_double_x);
r += llrintl(long_double_x);
r += llroundl(long_double_x);
r += log10l(long_double_x);
r += log1pl(long_double_x);
r += log2l(long_double_x);
r += logbl(long_double_x);
r += logl(long_double_x);
r += lrintl(long_double_x);
r += lroundl(long_double_x);
r += modfl(long_double_x, &long_double_x);
r += nearbyintl(long_double_x);
r += nextafterl(long_double_x, long_double_x);
r += nexttowardl(long_double_x, long_double_x);
r += powl(long_double_x, long_double_x);
r += remainderl(long_double_x, long_double_x);
r += remquol(long_double_x, long_double_x, &int_x);
r += rintl(long_double_x);
r += roundl(long_double_x);
r += scalblnl(long_double_x, long_x);
r += scalbnl(long_double_x, int_x);
r += sinhl(long_double_x);
r += sinl(long_double_x);
r += sqrtl(long_double_x);
r += tanhl(long_double_x);
r += tanl(long_double_x);
r += tgammal(long_double_x);
r += truncl(long_double_x);
return r;
}
int main(int argc, char *argv[])
{
long double x = 0.0;
if (argv) x = expm1l((long double) argc);
return 0;
}
npy_longdouble npy_expm1l(npy_longdouble x)
{
return expm1l(x);
}
double expm1(double x)
{
return expm1l(x);
}