Le 2012-08-09 13:50, Gilles Sadowski a écrit :
Hi.
Hi Gilles,
On Thu, Aug 09, 2012 at 08:07:25AM -0000, l...@apache.org wrote:
Author: luc
Date: Thu Aug 9 08:07:25 2012
New Revision: 1371082
URL: http://svn.apache.org/viewvc?rev=1371082&view=rev
Log:
added a function to raise a double to an int power
Modified:
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/FastMath.java
Modified:
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/FastMath.java
URL:
http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/FastMath.java?rev=1371082&r1=1371081&r2=1371082&view=diff
==============================================================================
---
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/FastMath.java
(original)
+++
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/FastMath.java
Thu Aug 9 08:07:25 2012
@@ -1582,6 +1582,34 @@ public class FastMath {
/**
+ * Raise a double to an int power.
+ *
+ * @param d Number to raise.
+ * @param e Exponent.
+ * @return d<sup>e</sup>
+ */
+ public static double pow(double d, int e) {
+ if (e == 0) {
+ return 1.0;
+ } else if (e < 0) {
+ e = -e;
+ d = 1.0 / d;
+ }
+
+ double result = 1;
+ double d2p = d;
+ while (e != 0) {
+ if ((e & 0x1) != 0) {
+ result *= d2p;
+ }
+ d2p *= d2p;
+ e = e >> 1;
+ }
+
+ return result;
+ }
I've added a unit test for this function. It shows that the result is
not
the same as with "pow(double, double)" (cf. tolerance in
"assertEquals").
I didn't check which one is more accurate, but I thought that we
should be
aware of the discrepancy.
I have checked this further. The pow(double, double) seems to be always
slightly
better than pow(double, int). I have used a comparison with Dfp set up
at 60 digits
and 100 digits too. I have also checked depending on the initial number
being representable
or not.
I expected the method to be slightly more accurate for small powers
(say up to 20) and most
importantly be much faster. The first part of my assumption is not
true, so it is a major
drawback. Even for very small powers I quickly have one ulp.
I'll take a further look at the current speed of pow(double,double) and
if it is reasonable,
I'll remove the new method. Adding a method that decreases accuracy is
never good.
Thanks for having looked at this;
best regards,
Luc
Regards,
Gilles
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscr...@commons.apache.org
For additional commands, e-mail: dev-h...@commons.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscr...@commons.apache.org
For additional commands, e-mail: dev-h...@commons.apache.org
