double npy_hypot(double x, double y)
{
double yx;
if (npy_isinf(x) || npy_isinf(y)) {
return NPY_INFINITY;
}
if (npy_isnan(x) || npy_isnan(y)) {
return NPY_NAN;
}
x = npy_fabs(x);
y = npy_fabs(y);
if (x < y) {
double temp = x;
x = y;
y = temp;
}
if (x == 0.) {
return 0.;
}
else {
yx = y/x;
return x*npy_sqrt(1.+yx*yx);
}
}
npy_longdouble npy_spacingl(npy_longdouble x)
{
/* XXX: npy isnan/isinf may be optimized by bit twiddling */
if (npy_isinf(x)) {
return NPY_NANL;
}
return _nextl(x, 1) - x;
}
npy_float npy_spacingf(npy_float x)
{
/* XXX: npy isnan/isinf may be optimized by bit twiddling */
if (npy_isinf(x)) {
return NPY_NANF;
}
return _nextf(x, 1) - x;
}
double npy_log1p(double x)
{
if (npy_isinf(x) && x > 0) {
return x;
}
else {
const double u = 1. + x;
const double d = u - 1.;
if (d == 0) {
return x;
} else {
return npy_log(u) * x / d;
}
}
}
double npy_expm1(double x)
{
if (npy_isinf(x) && x > 0) {
return x;
}
else {
const double u = npy_exp(x);
if (u == 1.0) {
return x;
} else if (u - 1.0 == -1.0) {
return -1;
} else {
return (u - 1.0) * x/npy_log(u);
}
}
}
double igami(double a, double p)
{
int i;
double x, fac, f_fp, fpp_fp;
if (npy_isnan(a) || npy_isnan(p)) {
return NPY_NAN;
}
else if ((a < 0) || (p < 0) || (p > 1)) {
mtherr("gammaincinv", DOMAIN);
}
else if (p == 0.0) {
return 0.0;
}
else if (p == 1.0) {
return NPY_INFINITY;
}
else if (p > 0.9) {
return igamci(a, 1 - p);
}
x = find_inverse_gamma(a, p, 1 - p);
/* Halley's method */
for (i = 0; i < 3; i++) {
fac = igam_fac(a, x);
if (fac == 0.0) {
return x;
}
f_fp = (igam(a, x) - p) * x / fac;
/* The ratio of the first and second derivatives simplifies */
fpp_fp = -1.0 + (a - 1) / x;
if (npy_isinf(fpp_fp)) {
/* Resort to Newton's method in the case of overflow */
x = x - f_fp;
}
else {
x = x - f_fp / (1.0 - 0.5 * f_fp * fpp_fp);
}
}
return x;
}
double igamci(double a, double q)
{
int i;
double x, fac, f_fp, fpp_fp;
if (npy_isnan(a) || npy_isnan(q)) {
return NPY_NAN;
}
else if ((a < 0.0) || (q < 0.0) || (q > 1.0)) {
mtherr("gammainccinv", DOMAIN);
}
else if (q == 0.0) {
return NPY_INFINITY;
}
else if (q == 1.0) {
return 0.0;
}
else if (q > 0.9) {
return igami(a, 1 - q);
}
x = find_inverse_gamma(a, 1 - q, q);
for (i = 0; i < 3; i++) {
fac = igam_fac(a, x);
if (fac == 0.0) {
return x;
}
f_fp = (igamc(a, x) - q) * x / (-fac);
fpp_fp = -1.0 + (a - 1) / x;
if (npy_isinf(fpp_fp)) {
x = x - f_fp;
}
else {
x = x - f_fp / (1.0 - 0.5 * f_fp * fpp_fp);
}
}
return x;
}
double npy_atan2(double y, double x)
{
npy_int32 k, m, iy, ix, hx, hy;
npy_uint32 lx,ly;
double z;
EXTRACT_WORDS(hx, lx, x);
ix = hx & 0x7fffffff;
EXTRACT_WORDS(hy, ly, y);
iy = hy & 0x7fffffff;
/* if x or y is nan, return nan */
if (npy_isnan(x * y)) {
return x + y;
}
if (x == 1.0) {
return npy_atan(y);
}
m = 2 * npy_signbit(x) + npy_signbit(y);
if (y == 0.0) {
switch(m) {
case 0:
case 1: return y; /* atan(+-0,+anything)=+-0 */
case 2: return NPY_PI;/* atan(+0,-anything) = pi */
case 3: return -NPY_PI;/* atan(-0,-anything) =-pi */
}
}
if (x == 0.0) {
return y > 0 ? NPY_PI_2 : -NPY_PI_2;
}
if (npy_isinf(x)) {
if (npy_isinf(y)) {
switch(m) {
case 0: return NPY_PI_4;/* atan(+INF,+INF) */
case 1: return -NPY_PI_4;/* atan(-INF,+INF) */
case 2: return 3.0*NPY_PI_4;/*atan(+INF,-INF)*/
case 3: return -3.0*NPY_PI_4;/*atan(-INF,-INF)*/
}
} else {
switch(m) {
case 0: return NPY_PZERO; /* atan(+...,+INF) */
case 1: return NPY_NZERO; /* atan(-...,+INF) */
case 2: return NPY_PI; /* atan(+...,-INF) */
case 3: return -NPY_PI; /* atan(-...,-INF) */
}
}
}
if (npy_isinf(y)) {
return y > 0 ? NPY_PI_2 : -NPY_PI_2;
}
/* compute y/x */
k = (iy - ix) >> 20;
if (k > 60) { /* |y/x| > 2**60 */
z = NPY_PI_2 + 0.5 * NPY_DBL_EPSILON;
m &= 1;
} else if (hx < 0 && k < -60) {
z = 0.0; /* 0 > |y|/x > -2**-60 */
} else {
z = npy_atan(npy_fabs(y/x)); /* safe to do y/x */
}
switch (m) {
case 0: return z ; /* atan(+,+) */
case 1: return -z ; /* atan(-,+) */
case 2: return NPY_PI - (z - NPY_DBL_EPSILON);/* atan(+,-) */
default: /* case 3 */
return (z - NPY_DBL_EPSILON) - NPY_PI;/* atan(-,-) */
}
}
