yggdrasil/gcc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merged gcj-eclipse branch to trunk.

Browse Source 
From-SVN: r120621
This commit is contained in:
Tom Tromey
2007-01-09 19:58:05 +00:00
parent c648dedbde
commit 97b8365caf
17478 changed files with 606493 additions and 100744 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libjava/classpath/java/lang/StrictMath.java
+190 -36
View File
@@ -632,6 +632,94 @@ public final strictfp class StrictMath
return y > 0 ? PI - (z - PI_L) : z - PI_L - PI;
}
/**
* Returns the hyperbolic sine of <code>x</code> which is defined as
* (exp(x) - exp(-x)) / 2.
*
* Special cases:
* <ul>
* <li>If the argument is NaN, the result is NaN</li>
* <li>If the argument is positive infinity, the result is positive
* infinity.</li>
* <li>If the argument is negative infinity, the result is negative
* infinity.</li>
* <li>If the argument is zero, the result is zero.</li>
* </ul>
*
* @param x the argument to <em>sinh</em>
* @return the hyperbolic sine of <code>x</code>
*
* @since 1.5
*/
public static double sinh(double x)
{
// Method :
// mathematically sinh(x) if defined to be (exp(x)-exp(-x))/2
// 1. Replace x by |x| (sinh(-x) = -sinh(x)).
// 2.
// E + E/(E+1)
// 0 <= x <= 22 : sinh(x) := --------------, E=expm1(x)
// 2
//
// 22 <= x <= lnovft : sinh(x) := exp(x)/2
// lnovft <= x <= ln2ovft: sinh(x) := exp(x/2)/2 * exp(x/2)
// ln2ovft < x : sinh(x) := +inf (overflow)
double t, w, h;
long bits;
long h_bits;
long l_bits;
// handle special cases
if (x != x)
return x;
if (x == Double.POSITIVE_INFINITY)
return Double.POSITIVE_INFINITY;
if (x == Double.NEGATIVE_INFINITY)
return Double.NEGATIVE_INFINITY;
if (x < 0)
h = - 0.5;
else
h = 0.5;
bits = Double.doubleToLongBits(x);
h_bits = getHighDWord(bits) & 0x7fffffffL; // ignore sign
l_bits = getLowDWord(bits);
// |x| in [0, 22], return sign(x) * 0.5 * (E+E/(E+1))
if (h_bits < 0x40360000L) // |x| < 22
{
if (h_bits < 0x3e300000L) // |x| < 2^-28
return x; // for tiny arguments return x
t = expm1(abs(x));
if (h_bits < 0x3ff00000L)
return h * (2.0 * t - t * t / (t + 1.0));
return h * (t + t / (t + 1.0));
}
// |x| in [22, log(Double.MAX_VALUE)], return 0.5 * exp(|x|)
if (h_bits < 0x40862e42L)
return h * exp(abs(x));
// |x| in [log(Double.MAX_VALUE), overflowthreshold]
if ((h_bits < 0x408633ceL)
|| ((h_bits == 0x408633ceL) && (l_bits <= 0x8fb9f87dL)))
{
w = exp(0.5 * abs(x));
t = h * w;
return t * w;
}
// |x| > overflowthershold
return h * Double.POSITIVE_INFINITY;
}
/**
* Returns the hyperbolic cosine of <code>x</code>, which is defined as
* (exp(x) + exp(-x)) / 2.
@@ -670,36 +758,36 @@ public final strictfp class StrictMath
double t, w;
long bits;
int hx;
int lx;
long hx;
long lx;
// handle special cases
if (x != x)
return Double.NaN;
return x;
if (x == Double.POSITIVE_INFINITY)
return Double.POSITIVE_INFINITY;
if (x == Double.NEGATIVE_INFINITY)
return Double.POSITIVE_INFINITY;
bits = Double.doubleToLongBits(x);
hx = getHighDWord(bits) & 0x7fffffff; // ignore sign
hx = getHighDWord(bits) & 0x7fffffffL; // ignore sign
lx = getLowDWord(bits);
// |x| in [0, 0.5 * ln(2)], return 1 + expm1(|x|)^2 / (2 * exp(|x|))
if (hx < 0x3fd62e43)
if (hx < 0x3fd62e43L)
{
t = expm1(abs(x));
w = 1.0 + t;
// for tiny arguments return 1.
if (hx < 0x3c800000)
if (hx < 0x3c800000L)
return w;
return 1.0 + (t * t) / (w + w);
}
// |x| in [0.5 * ln(2), 22], return exp(|x|)/2 + 1 / (2 * exp(|x|))
if (hx < 0x40360000)
if (hx < 0x40360000L)
{
t = exp(abs(x));
@@ -707,16 +795,13 @@ public final strictfp class StrictMath
}
// |x| in [22, log(Double.MAX_VALUE)], return 0.5 * exp(|x|)
if (hx < 0x40862e42)
if (hx < 0x40862e42L)
return 0.5 * exp(abs(x));
// |x| in [log(Double.MAX_VALUE), overflowthreshold],
// return exp(x/2)/2 * exp(x/2)
// we need to force an unsigned <= compare, thus can not use lx.
if ((hx < 0x408633ce)
|| ((hx == 0x408633ce)
&& ((bits & 0x00000000ffffffffL) <= 0x8fb9f87dL)))
if ((hx < 0x408633ceL)
|| ((hx == 0x408633ceL) && (lx <= 0x8fb9f87dL)))
{
w = exp(0.5 * abs(x));
t = 0.5 * w;
@@ -728,14 +813,83 @@ public final strictfp class StrictMath
return Double.POSITIVE_INFINITY;
}
/**
* Returns the hyperbolic tangent of <code>x</code>, which is defined as
* (exp(x) - exp(-x)) / (exp(x) + exp(-x)), i.e. sinh(x) / cosh(x).
*
Special cases:
* <ul>
* <li>If the argument is NaN, the result is NaN</li>
* <li>If the argument is positive infinity, the result is 1.</li>
* <li>If the argument is negative infinity, the result is -1.</li>
* <li>If the argument is zero, the result is zero.</li>
* </ul>
*
* @param x the argument to <em>tanh</em>
* @return the hyperbolic tagent of <code>x</code>
*
* @since 1.5
*/
public static double tanh(double x)
{
// Method :
// 0. tanh(x) is defined to be (exp(x) - exp(-x)) / (exp(x) + exp(-x))
// 1. reduce x to non-negative by tanh(-x) = -tanh(x).
// 2. 0 <= x <= 2^-55 : tanh(x) := x * (1.0 + x)
// -t
// 2^-55 < x <= 1 : tanh(x) := -----; t = expm1(-2x)
// t + 2
// 2
// 1 <= x <= 22.0 : tanh(x) := 1 - ----- ; t=expm1(2x)
// t + 2
// 22.0 < x <= INF : tanh(x) := 1.
double t, z;
long bits;
long h_bits;
// handle special cases
if (x != x)
return x;
if (x == Double.POSITIVE_INFINITY)
return 1.0;
if (x == Double.NEGATIVE_INFINITY)
return -1.0;
bits = Double.doubleToLongBits(x);
h_bits = getHighDWord(bits) & 0x7fffffffL; // ingnore sign
if (h_bits < 0x40360000L) // |x| < 22
{
if (h_bits < 0x3c800000L) // |x| < 2^-55
return x * (1.0 + x);
if (h_bits >= 0x3ff00000L) // |x| >= 1
{
t = expm1(2.0 * abs(x));
z = 1.0 - 2.0 / (t + 2.0);
}
else // |x| < 1
{
t = expm1(-2.0 * abs(x));
z = -t / (t + 2.0);
}
}
else // |x| >= 22
z = 1.0;
return (x >= 0) ? z : -z;
}
/**
* Returns the lower two words of a long. This is intended to be
* used like this:
* <code>getLowDWord(Double.doubleToLongBits(x))</code>.
*/
private static int getLowDWord(long x)
private static long getLowDWord(long x)
{
return (int) (x & 0x00000000ffffffffL);
return x & 0x00000000ffffffffL;
}
/**
@@ -743,19 +897,19 @@ public final strictfp class StrictMath
* used like this:
* <code>getHighDWord(Double.doubleToLongBits(x))</code>.
*/
private static int getHighDWord(long x)
private static long getHighDWord(long x)
{
return (int) ((x & 0xffffffff00000000L) >> 32);
return (x & 0xffffffff00000000L) >> 32;
}
/**
* Returns a double with the IEEE754 bit pattern given in the lower
* and higher two words <code>lowDWord</code> and <code>highDWord</code>.
*/
private static double buildDouble(int lowDWord, int highDWord)
private static double buildDouble(long lowDWord, long highDWord)
{
return Double.longBitsToDouble((((long) highDWord & 0xffffffffL) << 32)
| ((long) lowDWord & 0xffffffffL));
return Double.longBitsToDouble(((highDWord & 0xffffffffL) << 32)
| (lowDWord & 0xffffffffL));
}
/**
@@ -788,12 +942,12 @@ public final strictfp class StrictMath
double w;
long bits;
int l;
int h;
long l;
long h;
// handle the special cases
if (x != x)
return Double.NaN;
return x;
if (x == Double.POSITIVE_INFINITY)
return Double.POSITIVE_INFINITY;
if (x == Double.NEGATIVE_INFINITY)
@@ -847,7 +1001,7 @@ public final strictfp class StrictMath
s = t * t; // t * t is exact
r = x / s;
w = t + t;
r = (r - t) / (w + r); // r - s is exact
r = (r - t) / (w + r); // r - t is exact
t = t + t * r;
return negative ? -t : t;
@@ -1008,8 +1162,8 @@ public final strictfp class StrictMath
int k;
long bits;
int h_bits;
int l_bits;
long h_bits;
long l_bits;
c = 0.0;
y = abs(x);
@@ -1019,14 +1173,14 @@ public final strictfp class StrictMath
l_bits = getLowDWord(bits);
// handle special cases and large arguments
if (h_bits >= 0x4043687a) // if |x| >= 56 * ln(2)
if (h_bits >= 0x4043687aL) // if |x| >= 56 * ln(2)
{
if (h_bits >= 0x40862e42) // if |x| >= EXP_LIMIT_H
if (h_bits >= 0x40862e42L) // if |x| >= EXP_LIMIT_H
{
if (h_bits >= 0x7ff00000)
if (h_bits >= 0x7ff00000L)
{
if (((h_bits & 0x000fffff) | (l_bits & 0xffffffff)) != 0)
return Double.NaN; // exp(NaN) = NaN
if (((h_bits & 0x000fffffL) | (l_bits & 0xffffffffL)) != 0)
return x; // exp(NaN) = NaN
else
return negative ? -1.0 : x; // exp({+-inf}) = {+inf, -1}
}
@@ -1040,9 +1194,9 @@ public final strictfp class StrictMath
}
// argument reduction
if (h_bits > 0x3fd62e42) // |x| > 0.5 * ln(2)
if (h_bits > 0x3fd62e42L) // |x| > 0.5 * ln(2)
{
if (h_bits < 0x3ff0a2b2) // |x| < 1.5 * ln(2)
if (h_bits < 0x3ff0a2b2L) // |x| < 1.5 * ln(2)
{
if (negative)
{
@@ -1069,7 +1223,7 @@ public final strictfp class StrictMath
c = (hi - x) - lo;
}
else if (h_bits < 0x3c900000) // |x| < 2^-54 return x
else if (h_bits < 0x3c900000L) // |x| < 2^-54 return x
return x;
else
k = 0;
@@ -1124,7 +1278,7 @@ public final strictfp class StrictMath
if (k < 20)
{
bits = Double.doubleToLongBits(t);
h_bits = 0x3ff00000 - (0x00200000 >> k);
h_bits = 0x3ff00000L - (0x00200000L >> k);
l_bits = getLowDWord(bits);
t = buildDouble(l_bits, h_bits); // t = 1 - 2^(-k)
@@ -1141,7 +1295,7 @@ public final strictfp class StrictMath
else
{
bits = Double.doubleToLongBits(t);
h_bits = (0x000003ff - k) << 20;
h_bits = (0x000003ffL - k) << 20;
l_bits = getLowDWord(bits);
t = buildDouble(l_bits, h_bits); // t = 2^(-k)