void test_lgamma()
{
static_assert((std::is_same<decltype(lgamma((double)0)), double>::value), "");
static_assert((std::is_same<decltype(lgammaf(0)), float>::value), "");
static_assert((std::is_same<decltype(lgammal(0)), long double>::value), "");
assert(lgamma(1) == 0);
}
double MeanNormalLikelihood::logValue(RefArrayXd modelParameters)
{
unsigned long n = observations.size();
double lambda0;
double lambda;
ArrayXd argument;
ArrayXd predictions;
predictions.resize(n);
predictions.setZero();
model.predict(predictions, modelParameters);
argument = (observations - predictions);
argument = argument.square()*weights;
lambda0 = lgammal(n/2.) - log(2) - (n/2.)*log(Functions::PI) + 0.5*weights.log().sum();
lambda = lambda0 - (n/2.)*log(argument.sum());
return lambda;
}
static TACommandVerdict lgammal_cmd(TAThread thread,TAInputStream stream)
{
long double x, res;
x = readLongDouble(&stream);
START_TARGET_OPERATION(thread);
errno = 0;
res = lgammal(x);
END_TARGET_OPERATION(thread);
writeInt(thread, errno);
writeLongDouble(thread, res);
writeInt(thread, signgam);
sendResponse(thread);
return taDefaultVerdict;
}
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
}
long double
lgammal(long double x)
{
long double p, q, w, z, nx;
int i, nn;
signgam = 1;
if (! finite (x))
return x * x;
if (x == 0.0L)
{
if (signbit (x))
signgam = -1;
return one / fabsl (x);
}
if (x < 0.0L)
{
q = -x;
p = floorl (q);
if (p == q)
return (one / (p - p));
i = p;
if ((i & 1) == 0)
signgam = -1;
else
signgam = 1;
z = q - p;
if (z > 0.5L)
{
p += 1.0L;
z = p - q;
}
z = q * sinl (PIL * z);
if (z == 0.0L)
return (signgam * huge * huge);
w = lgammal (q);
z = logl (PIL / z) - w;
return (z);
}
if (x < 13.5L)
{
p = 0.0L;
nx = floorl (x + 0.5L);
nn = nx;
switch (nn)
{
case 0:
/* log gamma (x + 1) = log(x) + log gamma(x) */
if (x <= 0.125)
{
p = x * neval (x, RN1, NRN1) / deval (x, RD1, NRD1);
}
else if (x <= 0.375)
{
z = x - 0.25L;
p = z * neval (z, RN1r25, NRN1r25) / deval (z, RD1r25, NRD1r25);
p += lgam1r25b;
p += lgam1r25a;
}
else if (x <= 0.625)
{
z = x + (1.0L - x0a);
z = z - x0b;
p = neval (z, RN1r5, NRN1r5) / deval (z, RD1r5, NRD1r5);
p = p * z * z;
p = p + y0b;
p = p + y0a;
}
else if (x <= 0.875)
{
z = x - 0.75L;
p = z * neval (z, RN1r75, NRN1r75) / deval (z, RD1r75, NRD1r75);
p += lgam1r75b;
p += lgam1r75a;
}
else
{
z = x - 1.0L;
p = z * neval (z, RN2, NRN2) / deval (z, RD2, NRD2);
}
p = p - logl (x);
break;
case 1:
if (x < 0.875L)
{
if (x <= 0.625)
{
z = x + (1.0L - x0a);
z = z - x0b;
p = neval (z, RN1r5, NRN1r5) / deval (z, RD1r5, NRD1r5);
p = p * z * z;
p = p + y0b;
p = p + y0a;
}
else if (x <= 0.875)
{
z = x - 0.75L;
p = z * neval (z, RN1r75, NRN1r75)
/ deval (z, RD1r75, NRD1r75);
p += lgam1r75b;
p += lgam1r75a;
}
else
{
z = x - 1.0L;
p = z * neval (z, RN2, NRN2) / deval (z, RD2, NRD2);
}
p = p - logl (x);
}
else if (x < 1.0L)
{
z = x - 1.0L;
p = z * neval (z, RNr9, NRNr9) / deval (z, RDr9, NRDr9);
}
else if (x == 1.0L)
p = 0.0L;
else if (x <= 1.125L)
{
z = x - 1.0L;
p = z * neval (z, RN1, NRN1) / deval (z, RD1, NRD1);
}
else if (x <= 1.375)
{
z = x - 1.25L;
p = z * neval (z, RN1r25, NRN1r25) / deval (z, RD1r25, NRD1r25);
p += lgam1r25b;
p += lgam1r25a;
}
else
{
/* 1.375 <= x+x0 <= 1.625 */
z = x - x0a;
z = z - x0b;
p = neval (z, RN1r5, NRN1r5) / deval (z, RD1r5, NRD1r5);
p = p * z * z;
p = p + y0b;
p = p + y0a;
}
break;
case 2:
if (x < 1.625L)
{
z = x - x0a;
z = z - x0b;
p = neval (z, RN1r5, NRN1r5) / deval (z, RD1r5, NRD1r5);
p = p * z * z;
p = p + y0b;
p = p + y0a;
}
else if (x < 1.875L)
{
z = x - 1.75L;
p = z * neval (z, RN1r75, NRN1r75) / deval (z, RD1r75, NRD1r75);
p += lgam1r75b;
p += lgam1r75a;
}
else if (x == 2.0L)
p = 0.0L;
else if (x < 2.375L)
{
z = x - 2.0L;
p = z * neval (z, RN2, NRN2) / deval (z, RD2, NRD2);
}
else
{
z = x - 2.5L;
p = z * neval (z, RN2r5, NRN2r5) / deval (z, RD2r5, NRD2r5);
p += lgam2r5b;
p += lgam2r5a;
}
break;
case 3:
if (x < 2.75)
{
z = x - 2.5L;
p = z * neval (z, RN2r5, NRN2r5) / deval (z, RD2r5, NRD2r5);
p += lgam2r5b;
p += lgam2r5a;
}
else
{
z = x - 3.0L;
p = z * neval (z, RN3, NRN3) / deval (z, RD3, NRD3);
p += lgam3b;
p += lgam3a;
}
break;
case 4:
z = x - 4.0L;
p = z * neval (z, RN4, NRN4) / deval (z, RD4, NRD4);
p += lgam4b;
p += lgam4a;
break;
case 5:
z = x - 5.0L;
p = z * neval (z, RN5, NRN5) / deval (z, RD5, NRD5);
p += lgam5b;
p += lgam5a;
break;
case 6:
z = x - 6.0L;
p = z * neval (z, RN6, NRN6) / deval (z, RD6, NRD6);
p += lgam6b;
p += lgam6a;
break;
case 7:
z = x - 7.0L;
p = z * neval (z, RN7, NRN7) / deval (z, RD7, NRD7);
p += lgam7b;
p += lgam7a;
break;
case 8:
z = x - 8.0L;
p = z * neval (z, RN8, NRN8) / deval (z, RD8, NRD8);
p += lgam8b;
p += lgam8a;
break;
case 9:
z = x - 9.0L;
p = z * neval (z, RN9, NRN9) / deval (z, RD9, NRD9);
p += lgam9b;
p += lgam9a;
break;
case 10:
z = x - 10.0L;
p = z * neval (z, RN10, NRN10) / deval (z, RD10, NRD10);
p += lgam10b;
p += lgam10a;
break;
case 11:
z = x - 11.0L;
p = z * neval (z, RN11, NRN11) / deval (z, RD11, NRD11);
p += lgam11b;
p += lgam11a;
break;
case 12:
z = x - 12.0L;
p = z * neval (z, RN12, NRN12) / deval (z, RD12, NRD12);
p += lgam12b;
p += lgam12a;
break;
case 13:
z = x - 13.0L;
p = z * neval (z, RN13, NRN13) / deval (z, RD13, NRD13);
p += lgam13b;
p += lgam13a;
break;
}
return p;
}
if (x > MAXLGM)
return (signgam * huge * huge);
q = ls2pi - x;
q = (x - 0.5L) * logl (x) + q;
if (x > 1.0e18L)
return (q);
p = 1.0L / (x * x);
q += neval (p, RASY, NRASY) / x;
return (q);
}
TEST(math, lgammal) {
ASSERT_DOUBLE_EQ(logl(24.0L), lgammal(5.0L));
}
TEST(math, lgammal) {
ASSERT_FLOAT_EQ(logl(24.0), lgammal(5.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;
}
