Added the pow method to the Decimal class. Fixed a bug in the Decimal::isPositive method

Author: castarco

src/Litipk/BigNumbers/Decimal.php

@@ -369,7 +369,7 @@ public function div (BigNumber $b, $scale = null)
 
     /**
      * Returns the square root of this object
-     * 
+     * @param  integer $scale
      * @return Decimal
      */
     public function sqrt ($scale = null)
@@ -384,10 +384,56 @@ public function sqrt ($scale = null)
 
         return self::fromString(
             bcsqrt($this->value, $sqrt_scale+1),
-            $scale
+            $sqrt_scale
         );
     }
 
+    /**
+     * Powers this value to $b
+     * 
+     * @param  Decimal  $b      exponent
+     * @param  integer  $scale
+     * @return Decimal
+     */
+    public function pow(Decimal $b, $scale = null)
+    {
+        if ($this->isZero()) {
+            if ($b->isPositive()) {
+                return Decimal::fromDecimal($this, $scale);
+            } else {
+                return NaN::getNaN();
+            }
+        } elseif($b->isZero()) {
+            return Decimal::fromInteger(1, $scale);
+        } elseif ($b->scale == 0) {
+            $pow_scale = $scale === null ?
+                max($this->scale, $b->scale) : max($this->scale, $b->scale, $scale);
+
+            return self::fromString(
+                bcpow($this->value, $b->value, $pow_scale+1),
+                $pow_scale
+            );
+        } else {
+            if ($this->isPositive()) {
+                $pow_scale = $scale === null ?
+                    max($this->scale, $b->scale) : max($this->scale, $b->scale, $scale);
+
+                $truncated_b = bcadd($b->value, '0', 0);
+                $remaining_b = bcsub($b->value, $truncated_b, $b->scale);
+
+                $first_pow_approx = bcpow($this->value, $truncated_b, $pow_scale+1);
+                $intermediate_root = self::innerPowWithLittleExponent($this->value, $remaining_b, $b->scale, $pow_scale+1);
+
+                return Decimal::fromString(
+                    bcmul($first_pow_approx, $intermediate_root, $pow_scale+1),
+                    $pow_scale
+                );
+            } else { // elseif ($this->isNegative())
+                return NaN::getNaN();
+            }
+        }
+    }
+
     /**
      * Returns the object's logarithm in base 10
      * @param  integer $scale
@@ -422,7 +468,7 @@ public function isZero ($scale = null)
      */
     public function isPositive ()
     {
-        return ($this->value[0] !== '-');
+        return ($this->value[0] !== '-' && !$this->isZero());
     }
 
     /**
@@ -647,4 +693,52 @@ private static function innerLog10 ($value, $in_scale, $out_scale)
                 return '0';
         }
     }
+    
+
+    private static function innerPowWithLittleExponent ($base, $exponent, $exp_scale, $out_scale)
+    {
+        $inner_scale = ceil($exp_scale*log(10)/log(2))+1;
+
+        $result_a = '1';
+        $result_b = '0';
+
+        $actual_index = 0;
+        $exponent_remaining = $exponent;
+
+        while (bccomp($result_a, $result_b, $out_scale) !== 0 && bccomp($exponent_remaining, '0', $inner_scale) !== 0) {
+            $result_b = $result_a;
+            $index_info = self::computeSquareIndex($exponent_remaining, $actual_index, $exp_scale, $inner_scale);
+            $exponent_remaining = $index_info[1];
+            $result_a = bcmul($result_a, self::compute2NRoot($base, $index_info[0], 2*($out_scale+1)), 2*($out_scale+1));
+        }
+
+        return self::innerRound($result_a, $out_scale);
+    }
+
+    
+    private static function computeSquareIndex ($exponent_remaining, $actual_index, $exp_scale, $inner_scale)
+    {
+        $actual_rt = bcpow('0.5', $actual_index, $exp_scale);
+        $r = bcsub($exponent_remaining, $actual_rt, $inner_scale);
+        
+        while (bccomp($r, 0, $exp_scale) === -1) {
+            ++$actual_index;
+            $actual_rt = bcmul('0.5', $actual_rt, $inner_scale);
+            $r = bcsub($exponent_remaining, $actual_rt, $inner_scale);
+        }
+        
+        return [$actual_index, $r];
+    }
+
+
+    private static function compute2NRoot ($base, $index, $out_scale)
+    {
+        $result = $base;
+
+        for ($i=0; $i<$index; $i++) {
+            $result = bcsqrt($result, ($out_scale+1)*($index-$i)+1);
+        }
+
+        return self::innerRound($result, $out_scale);
+    }
 }

tests/Litipk/BigNumbers/Decimal/DecimalPowTest.php

@@ -0,0 +1,79 @@
+<?php
+
+use Litipk\BigNumbers\Decimal  as Decimal;
+
+class DecimalPowTest extends PHPUnit_Framework_TestCase
+{
+	public function testZeroPositive ()
+	{
+		$zero = Decimal::fromInteger(0);
+		$two = Decimal::fromInteger(2);
+
+		$this->assertTrue($zero->pow($two)->isZero());
+	}
+
+	public function testZeroNoPositive ()
+	{
+		$zero = Decimal::fromInteger(0);
+		$nTwo = Decimal::fromInteger(-2);
+
+		$this->assertTrue($zero->pow($nTwo)->isNaN());
+		$this->assertTrue($zero->pow($zero)->isNaN());
+	}
+
+	public function testNoZeroZero ()
+	{
+		$zero = Decimal::fromInteger(0);
+		$one = Decimal::fromInteger(1);
+
+		$nTwo = Decimal::fromInteger(-2);
+		$pTwo = Decimal::fromInteger(2);
+
+		$this->assertTrue($nTwo->pow($zero)->equals($one));
+		$this->assertTrue($pTwo->pow($zero)->equals($one));
+	}
+
+	public function testLittleIntegerInteger ()
+	{
+		$two = Decimal::fromInteger(2);
+		$three = Decimal::fromInteger(3);
+		$four = Decimal::fromInteger(4);
+		$eight = Decimal::fromInteger(8);
+		$nine = Decimal::fromInteger(9);
+		$twentyseven = Decimal::fromInteger(27);
+
+		$this->assertTrue($two->pow($two)->equals($four));
+		$this->assertTrue($two->pow($three)->equals($eight));
+
+		$this->assertTrue($three->pow($two)->equals($nine));
+		$this->assertTrue($three->pow($three)->equals($twentyseven)); 
+	}
+
+	public function testLittlePositiveSquareRoot ()
+	{
+		$half = Decimal::fromString('0.5');
+		$two = Decimal::fromInteger(2);
+		$three = Decimal::fromInteger(3);
+		$four = Decimal::fromInteger(4);
+		$nine = Decimal::fromInteger(9);
+
+		$this->assertTrue($four->pow($half)->equals($two));
+		$this->assertTrue($nine->pow($half)->equals($three));
+	}
+
+	public function testBigPositiveSquareRoot ()
+	{
+		$half = Decimal::fromString('0.5');
+		$bignum1 = Decimal::fromString('922337203685477580700');
+
+		$this->assertTrue($bignum1->pow($half, 6)->equals($bignum1->sqrt(6)));
+	}
+
+	public function testNegativeSquareRoot ()
+	{
+		$half = Decimal::fromString('0.5');
+		$nThree = Decimal::fromInteger(-3);
+
+		$this->assertTrue($nThree->pow($half)->isNaN());
+	}
+}