Пример #1
0
 /**
  * Computes the value of this number raised to an integral power. Follows semantics of Java
  * Math.pow as closely as possible.
  *
  * @param exp the integer exponent
  * @return x raised to the integral power exp
  */
 public WB_DoubleDouble pow(final int exp) {
   if (exp == 0.0) {
     return valueOf(1.0);
   }
   WB_DoubleDouble r = new WB_DoubleDouble(this);
   WB_DoubleDouble s = valueOf(1.0);
   int n = Math.abs(exp);
   if (n > 1) {
     /* Use binary exponentiation */
     while (n > 0) {
       if ((n % 2) == 1) {
         s.selfMultiply(r);
       }
       n /= 2;
       if (n > 0) {
         r = r.sqr();
       }
     }
   } else {
     s = r;
   }
   /* Compute the reciprocal if n is negative. */
   if (exp < 0) {
     return s.reciprocal();
   }
   return s;
 }
Пример #2
0
 /**
  * Computes the positive square root of this value. If the number is NaN or negative, NaN is
  * returned.
  *
  * @return the positive square root of this number. If the argument is NaN or less than zero, the
  *     result is NaN.
  */
 public WB_DoubleDouble sqrt() {
   /*
    * Strategy: Use Karp's trick: if x is an approximation to sqrt(a), then
    *
    * sqrt(a) = a*x + [a - (a*x)^2] * x / 2 (approx)
    *
    * The approximation is accurate to twice the accuracy of x. Also, the
    * multiplication (a*x) and [-]*x can be done with only half the
    * precision.
    */
   if (isZero()) {
     return valueOf(0.0);
   }
   if (isNegative()) {
     return NaN;
   }
   final double x = 1.0 / Math.sqrt(hi);
   final double ax = hi * x;
   final WB_DoubleDouble axdd = valueOf(ax);
   final WB_DoubleDouble diffSq = this.subtract(axdd.sqr());
   final double d2 = diffSq.hi * (x * 0.5);
   return axdd.add(d2);
 }