----- 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


Reply via email to