2006-02-23 Andrew John Hughes <gnu_andrew@member.fsf.org>

	* include/java_lang_VMMath.h:
	(Java_java_lang_VMMath_cbrt(JNIEnv*,jclass,jdouble)): Added.
	(Java_java_lang_VMMath_cosh(JNIEnv*,jclass,jdouble)): Added.
	(Java_java_lang_VMMath_expm1(JNIEnv*,jclass,jdouble)): Added.
	(Java_java_lang_VMMath_hypot(JNIEnv*,jclass,jdouble,jdouble)): Added.
	(Java_java_lang_VMMath_log10(JNIEnv*,jclass,jdouble)): Added.
	(Java_java_lang_VMMath_log1p(JNIEnv*,jclass,jdouble)): Added.
	(Java_java_lang_VMMath_sinh(JNIEnv*,jclass,jdouble)): Added.
	(Java_java_lang_VMMath_tanh(JNIEnv*,jclass,jdouble)): Added.
	* java/lang/Math.java:
	(cbrt(double)): Implemented.
	(cosh(double)): Implemented.
	(expm1(double)): Implemented.
	(hypot(double,double)): Implemented.
	(log10(double)): Implemented.
	(log1p(double)): Implemented.
	(signum(double)): Implemented.
	(signum(float)): Implemented.
	(sinh(double)): Implemented.
	(tanh(double)): Implemented.
	* native/fdlibm/Makefile.am:
	Added new files from fdlibm 5.3.
	* native/fdlibm/e_acos.c,
	* native/fdlibm/e_asin.c,
	* native/fdlibm/e_atan2.c,
	* native/fdlibm/e_exp.c,
	* native/fdlibm/e_fmod.c,
	* native/fdlibm/e_log.c,
	* native/fdlibm/e_rem_pio2.c,
	* native/fdlibm/e_remainder.c,
	* native/fdlibm/e_scalb.c,
	* native/fdlibm/e_sqrt.c,
	* native/fdlibm/k_cos.c,
	* native/fdlibm/k_rem_pio2.c,
	* native/fdlibm/k_sin.c,
	* native/fdlibm/k_tan.c,
	* native/fdlibm/s_atan.c,
	* native/fdlibm/s_ceil.c,
	* native/fdlibm/s_copysign.c,
	* native/fdlibm/s_cos.c,
	* native/fdlibm/s_fabs.c,
	* native/fdlibm/s_finite.c,
	* native/fdlibm/s_floor.c,
	* native/fdlibm/s_rint.c,
	* native/fdlibm/s_scalbn.c,
	* native/fdlibm/s_sin.c,
	* native/fdlibm/s_tan.c,
	* native/fdlibm/w_acos.c,
	* native/fdlibm/w_asin.c,
	* native/fdlibm/w_atan2.c,
	* native/fdlibm/w_acos.c,
	* native/fdlibm/w_exp.c,
	* native/fdlibm/w_fmod.c,
	* native/fdlibm/w_log.c,
	* native/fdlibm/w_pow.c,
	* native/fdlibm/w_remainder.c,
	* native/fdlibm/w_sqrt.c:
	Updated to fdlibm 5.3.
	* native/fdlibm/e_cosh.c,
	* native/fdlibm/e_hypot.c,
	* native/fdlibm/e_log10.c,
	* native/fdlibm/e_sinh.c,
	* native/fdlibm/s_cbrt.c,
	* native/fdlibm/s_expm1.c,
	* native/fdlibm/s_log1p.c,
	* native/fdlibm/s_tanh.c,
	* native/fdlibm/w_cosh.c,
	* native/fdlibm/w_hypot.c,
	* native/fdlibm/w_log10.c,
	* native/fdlibm/w_sinh.c:
	Imported from fdlibm 5.3.
	* native/fdlibm/fdlibm.h:
	Imported from fdlibm 5.3 with Classpath additions.
	* native/fdlibm/namespace.h:
	Updated from new math_symbols file.
	* native/jni/java-lang/java_lang_VMMath.c:
	(Java_java_lang_VMMath_cbrt(JNIEnv*,jclass,jdouble)): Implemented.
	(Java_java_lang_VMMath_cosh(JNIEnv*,jclass,jdouble)): Implemented.
	(Java_java_lang_VMMath_expm1(JNIEnv*,jclass,jdouble)): Implemented.
	(Java_java_lang_VMMath_hypot(JNIEnv*,jclass,jdouble,jdouble)):
	Implemented.
	(Java_java_lang_VMMath_log10(JNIEnv*,jclass,jdouble)): Implemented.
	(Java_java_lang_VMMath_log1p(JNIEnv*,jclass,jdouble)): Implemented.
	(Java_java_lang_VMMath_sinh(JNIEnv*,jclass,jdouble)): Implemented.
	(Java_java_lang_VMMath_tanh(JNIEnv*,jclass,jdouble)): Implemented.
	* scripts/math_symbols:
	Added tanh, expm1, log10 and log1p.
	* vm/reference/java/lang/VMMath.java:
	(cbrt(double)): Implemented.
	(cosh(double)): Implemented.
	(expm1(double)): Implemented.
	(hypot(double,double)): Implemented.
	(log10(double)): Implemented.
	(log1p(double)): Implemented.
	(sinh(double)): Implemented.
	(tanh(double)): Implemented.

1 files changed, 166 insertions, 0 deletions

diff --git a/vm/reference/java/lang/VMMath.java b/vm/reference/java/lang/VMMath.java
index aa57b40d8..4d3782454 100644
--- a/vm/reference/java/lang/VMMath.java
+++ b/vm/reference/java/lang/VMMath.java
@@ -324,4 +324,170 @@ class VMMath
    */
   public static native double rint(double a);
 
+  /**
+   * <p>
+   * Take a cube root. If the argument is NaN, an infinity or zero, then
+   * the original value is returned.  The returned result must be within 1 ulp
+   * of the exact result.  For a finite value, <code>x</code>, the cube root
+   * of <code>-x</code> is equal to the negation of the cube root
+   * of <code>x</code>. 
+   * </p>
+   * <p>
+   * For a square root, use <code>sqrt</code>.  For other roots, use
+   * <code>pow(a, 1 / rootNumber)</code>.
+   * </p>
+   *
+   * @param a the numeric argument
+   * @return the cube root of the argument
+   * @see #sqrt(double)
+   * @see #pow(double, double)
+   */
+  public static native double cbrt(double a);
+
+  /**
+   * <p>
+   * Returns the hyperbolic cosine of the given value.  For a value,
+   * <code>x</code>, the hyperbolic cosine is <code>(e<sup>x</sup> + 
+   * e<sup>-x</sup>)/2</code>
+   * with <code>e</code> being <a href="#E">Euler's number</a>.  The returned
+   * result must be within 2.5 ulps of the exact result.
+   * </p>
+   * <p>
+   * If the supplied value is <code>NaN</code>, then the original value is
+   * returned.  For either infinity, positive infinity is returned.
+   * The hyperbolic cosine of zero must be 1.0.
+   * </p>
+   * 
+   * @param a the numeric argument
+   * @return the hyperbolic cosine of <code>a</code>.
+   * @since 1.5
+   */
+  public static native double cosh(double a);
+
+  /**
+   * <p>
+   * Returns <code>e<sup>a</sup> - 1.  For values close to 0, the
+   * result of <code>expm1(a) + 1</code> tend to be much closer to the
+   * exact result than simply <code>exp(x)</code>.  The result must be within
+   * 1 ulp of the exact result, and results must be semi-monotonic.  For finite
+   * inputs, the returned value must be greater than or equal to -1.0.  Once
+   * a result enters within half a ulp of this limit, the limit is returned.
+   * </p>   
+   * <p>
+   * For <code>NaN</code>, positive infinity and zero, the original value
+   * is returned.  Negative infinity returns a result of -1.0 (the limit).
+   * </p>
+   * 
+   * @param a the numeric argument
+   * @return <code>e<sup>a</sup> - 1</code>
+   * @since 1.5
+   */
+  public static native double expm1(double a);
+
+  /**
+   * <p>
+   * Returns the hypotenuse, <code>a<sup>2</sup> + b<sup>2</sup></code>,
+   * without intermediate overflow or underflow.  The returned result must be
+   * within 1 ulp of the exact result.  If one parameter is held constant,
+   * then the result in the other parameter must be semi-monotonic.
+   * </p>
+   * <p>
+   * If either of the arguments is an infinity, then the returned result
+   * is positive infinity.  Otherwise, if either argument is <code>NaN</code>,
+   * then <code>NaN</code> is returned.
+   * </p>
+   * 
+   * @param a the first parameter.
+   * @param b the second parameter.
+   * @return the hypotenuse matching the supplied parameters.
+   * @since 1.5
+   */
+  public static native double hypot(double a, double b);
+
+  /**
+   * <p>
+   * Returns the base 10 logarithm of the supplied value.  The returned
+   * result must within 1 ulp of the exact result, and the results must be
+   * semi-monotonic.
+   * </p>
+   * <p>
+   * Arguments of either <code>NaN</code> or less than zero return
+   * <code>NaN</code>.  An argument of positive infinity returns positive
+   * infinity.  Negative infinity is returned if either positive or negative
+   * zero is supplied.  Where the argument is the result of
+   * <code>10<sup>n</sup</code>, then <code>n</code> is returned.
+   * </p>
+   *
+   * @param a the numeric argument.
+   * @return the base 10 logarithm of <code>a</code>.
+   * @since 1.5
+   */
+  public static native double log10(double a);
+
+  /**
+   * <p>
+   * Returns the natural logarithm resulting from the sum of the argument,
+   * <code>a</code> and 1.  For values close to 0, the
+   * result of <code>log1p(a)</code> tend to be much closer to the
+   * exact result than simply <code>log(1.0+a)</code>.  The returned
+   * result must be within 1 ulp of the exact result, and the results must be
+   * semi-monotonic.
+   * </p>
+   * <p>
+   * Arguments of either <code>NaN</code> or less than -1 return
+   * <code>NaN</code>.  An argument of positive infinity or zero
+   * returns the original argument.  Negative infinity is returned from an
+   * argument of -1.
+   * </p>
+   *
+   * @param a the numeric argument.
+   * @return the natural logarithm of <code>a</code> + 1.
+   * @since 1.5
+   */
+  public static native double log1p(double a);
+
+  /**
+   * <p>
+   * Returns the hyperbolic sine of the given value.  For a value,
+   * <code>x</code>, the hyperbolic sine is <code>(e<sup>x</sup> - 
+   * e<sup>-x</sup>)/2</code>
+   * with <code>e</code> being <a href="#E">Euler's number</a>.  The returned
+   * result must be within 2.5 ulps of the exact result.
+   * </p>
+   * <p>
+   * If the supplied value is <code>NaN</code>, an infinity or a zero, then the
+   * original value is returned.
+   * </p>
+   * 
+   * @param a the numeric argument
+   * @return the hyperbolic sine of <code>a</code>.
+   * @since 1.5
+   */
+  public static native double sinh(double a);
+
+  /**
+   * <p>
+   * Returns the hyperbolic tangent of the given value.  For a value,
+   * <code>x</code>, the hyperbolic tangent is <code>(e<sup>x</sup> - 
+   * e<sup>-x</sup>)/(e<sup>x</sup> + e<sup>-x</sup>)</code>
+   * (i.e. <code>sinh(a)/cosh(a)</code>)
+   * with <code>e</code> being <a href="#E">Euler's number</a>.  The returned
+   * result must be within 2.5 ulps of the exact result.  The absolute value
+   * of the exact result is always less than 1.  Computed results are thus
+   * less than or equal to 1 for finite arguments, with results within
+   * half a ulp of either positive or negative 1 returning the appropriate
+   * limit value (i.e. as if the argument was an infinity).
+   * </p>
+   * <p>
+   * If the supplied value is <code>NaN</code> or zero, then the original
+   * value is returned.  Positive infinity returns +1.0 and negative infinity
+   * returns -1.0.
+   * </p>
+   * 
+   * @param a the numeric argument
+   * @return the hyperbolic tangent of <code>a</code>.
+   * @since 1.5
+   */
+  public static native double tanh(double a);
+
 }