Ejemplo n.º 1
0
long double
cbrtl(long double x) {
	long double s, t, r, w, y;
	double dx, dy;
	int *py = (int *) &dy;
	int n, m, m3, sx;

	if (!finitel(x))
		return (x + x);
	if (iszerol(x))
		return (x);
	sx = signbitl(x);
	x = fabsl(x);
	n = ilogbl(x);
	m = n / 3;
	m3 = m + m + m;
	y = scalbnl(x, -m3);
	dx = (double) y;
	dy = cbrt(dx);
	py[1 - n0] += 2;
	if (py[1 - n0] == 0)
		py[n0] += 1;

	/* one step newton iteration to 113 bits with error < 0.667ulps */
	t = (long double) dy;
	t = scalbnl(t, m);
	s = t * t;
	r = x / s;
	w = t + t;
	r = (r - t) / (w + r);
	t += t * r;

	return (sx == 0 ? t : -t);
}
Ejemplo n.º 2
0
long double
log10l(long double x) {
	long double y, z;
	enum fp_direction_type rd;
	int n;

	if (!finitel(x))
		return (x + fabsl(x));	/* x is +-INF or NaN */
	else if (x > zero) {
		n = ilogbl(x);
		if (n < 0)
			n += 1;
		rd = __swapRD(fp_nearest);
		y = n;
		x = scalbnl(x, -n);
		z = y * log10_2lo + ivln10 * logl(x);
		z += y * log10_2hi;
		if (rd != fp_nearest)
			(void) __swapRD(rd);
		return (z);
	} else if (x == zero)	/* -INF */
		return (-one / zero);
	else			/* x <0 , return NaN */
		return (zero / zero);
}
Ejemplo n.º 3
0
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);
}
Ejemplo n.º 4
0
long double
floorl(long double x) {
	long double t;

	if (!finitel(x))
		return (x + x);
	t = rintl(x);
	if (t <= x)
		return (t);		/* already floor(x) */
	else 				/* x < t case: return t-1  */
	    return (copysignl(t - qone, x));
}
Ejemplo n.º 5
0
long double
ceill(long double x) {
	long double t;

	if (!finitel(x))
		return (x + x);
	t = rintl(x);
	if (t >= x) 			/* already ceil(x) */
		return (t);
	else				/* t < x case: return t+1  */
		return (copysignl(t + qone, x));
}
Ejemplo n.º 6
0
long double
aintl(long double x) {
	long double t, w;

	if (!finitel(x))
		return (x + x);
	w = fabsl(x);
	t = rintl(w);
	if (t <= w)
		return (copysignl(t, x));	/* NaN or already aint(|x|) */
	else	/* |t|>|x| case */
		return (copysignl(t - qone, x));	/* |t-1|*sign(x) */
}
Ejemplo n.º 7
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);
}
Ejemplo n.º 8
0
long double
anintl(long double x) {
	long double t, w, z;

	if (!finitel(x))
		return (x + x);
	w = fabsl(x);
	t = rintl(w);
	if (t == w)
		return (copysignl(t, x));
	z = t - w;
	if (z > qhalf)
		t = t - qone;
	else if (z <= qmhalf)
		t = t + qone;
	return (copysignl(t, x));
}
Ejemplo n.º 9
0
void
sincosl(long double x, long double *s, long double *c) {
	long double y[2], z = 0.0L;
	int n, ix;
#if defined(__i386) || defined(__amd64)
	int *px = (int *) &x;
#endif

	/* trig(Inf or NaN) is NaN */
	if (!finitel(x)) {
		*s = *c = x - x;
		return;
	}

	/* High word of x. */
#if defined(__i386) || defined(__amd64)
	XTOI(px, ix);
#else
	ix = *(int *) &x;
#endif

	/* |x| ~< pi/4 */
	ix &= 0x7fffffff;
	if (ix <= 0x3ffe9220)
		*s = __k_sincosl(x, z, c);

	/* argument reduction needed */
	else {
		n = __rem_pio2l(x, y);
		switch (n & 3) {
		case 0:
			*s = __k_sincosl(y[0], y[1], c);
			break;
		case 1:
			*c = -__k_sincosl(y[0], y[1], s);
			break;
		case 2:
			*s = -__k_sincosl(y[0], y[1], c);
			*c = -*c;
			break;
		case 3:
			*c = __k_sincosl(y[0], y[1], s);
			*s = -*s;
		}
	}
}
Ejemplo n.º 10
0
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));
	}
}
Ejemplo n.º 11
0
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));
}
Ejemplo n.º 12
0
long double
atan2l(long double y, long double x) {
	long double t, z;
	int k, m, signy, signx;

	if (x != x || y != y)
		return (x + y);	/* return NaN if x or y is NAN */
	signy = signbitl(y);
	signx = signbitl(x);
	if (x == one)
		return (atanl(y));
	m = signy + signx + signx;

	/* when y = 0 */
	if (y == zero)
		switch (m) {
		case 0:
			return (y);	/* atan(+0,+anything) */
		case 1:
			return (y);	/* atan(-0,+anything) */
		case 2:
			return (PI + tiny);	/* atan(+0,-anything) */
		case 3:
			return (-PI - tiny);	/* atan(-0,-anything) */
		}

	/* when x = 0 */
	if (x == zero)
		return (signy == 1 ? -PIo2 - tiny : PIo2 + tiny);

	/* when x is INF */
	if (!finitel(x))
		if (!finitel(y)) {
			switch (m) {
			case 0:
				return (PIo4 + tiny);	/* atan(+INF,+INF) */
			case 1:
				return (-PIo4 - tiny);	/* atan(-INF,+INF) */
			case 2:
				return (PI3o4 + tiny);	/* atan(+INF,-INF) */
			case 3:
				return (-PI3o4 - tiny);	/* atan(-INF,-INF) */
			}
		} else {
			switch (m) {
			case 0:
				return (zero);	/* atan(+...,+INF) */
			case 1:
				return (-zero);	/* atan(-...,+INF) */
			case 2:
				return (PI + tiny);	/* atan(+...,-INF) */
			case 3:
				return (-PI - tiny);	/* atan(-...,-INF) */
			}
		}

	/* when y is INF */
	if (!finitel(y))
		return (signy == 1 ? -PIo2 - tiny : PIo2 + tiny);

	/* compute y/x */
	x = fabsl(x);
	y = fabsl(y);
	t = PI_lo;
	k = (ilogbl(y) - ilogbl(x));

	if (k > 120)
		z = PIo2 + half * t;
	else if (m > 1 && k < -120)
		z = zero;
	else
		z = atanl(y / x);

	switch (m) {
	case 0:
		return (z);	/* atan(+,+) */
	case 1:
		return (-z);	/* atan(-,+) */
	case 2:
		return (PI - (z - t));	/* atan(+,-) */
	case 3:
		return ((z - t) - PI);	/* atan(-,-) */
	}
	/* NOTREACHED */
}