----- Original Message -----
> Signed-off-by: Pekka Enberg <penb...@kernel.org>
> ---
> java/lang/StrictMath.java | 72
> +++++++++++++++++++++++++++++++++++++++++++++
> 1 files changed, 72 insertions(+), 0 deletions(-)
>
> diff --git a/java/lang/StrictMath.java b/java/lang/StrictMath.java
> index 88f5e57..225aaa7 100644
> --- a/java/lang/StrictMath.java
> +++ b/java/lang/StrictMath.java
> @@ -1317,6 +1317,78 @@ public final strictfp class StrictMath
> }
>
> /**
> + * <p>
> + * Returns the hypotenuse, <code>a<sup>2</sup> +
> b<sup>2</sup></code>,
> + * without intermediate overflow or underflow. The returned
> result is
> + * within 1 ulp of the exact result. If one parameter is held
> constant,
> + * then the result in the other parameter is 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 double hypot(double a, double b)
> + {
> + return VMMath.hypot(a,b);
> + }
> +
> + /**
> + * <p>
> + * Returns the base 10 logarithm of the supplied value. The
> returned
> + * result is within 1 ulp of the exact result, and the results are
> + * 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 double log10(double a)
> + {
> + return VMMath.log10(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 is within 1 ulp of the exact result, and the results are
> + * 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 double log1p(double a)
> + {
> + return VMMath.log1p(a);
> + }
> +
> +
> + /**
> * Take ln(a) (the natural log). The opposite of
> <code>exp()</code>. If the
> * argument is NaN or negative, the result is NaN; if the argument
> is
> * positive infinity, the result is positive infinity; and if the
> argument
> --
> 1.7.4.1
>
>
>
No. If you look at the other methods in StrictMath, you'll see they provide
Java versions of the methods.
--
Andrew :)
Free Java Software Engineer
Red Hat, Inc. (http://www.redhat.com)
PGP Key: 248BDC07 (https://keys.indymedia.org/)
Fingerprint = EC5A 1F5E C0AD 1D15 8F1F 8F91 3B96 A578 248B DC07
