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