Many fixes, new failing tests

Author: castarco

src/DecimalConstants.php

@@ -12,6 +12,9 @@
  */
 final class DecimalConstants
 {
+    private static $ZERO = null;
+    private static $ONE = null;
+
     private static $PI = null;
     private static $E = null;
     private static $EulerMascheroni = null;
@@ -36,6 +39,22 @@ private function __clone()
 
     }
 
+    public static function Zero()
+    {
+        if (self::$ZERO === null) {
+            self::$ZERO = Decimal::fromString("0");
+        }
+        return self::$ZERO;
+    }
+
+    public static function One()
+    {
+        if (self::$ONE === null) {
+            self::$ONE = Decimal::fromString("1");
+        }
+        return self::$ONE;
+    }
+
     /**
      * Returns the Pi number.
      * @return Decimal

src/InfiniteDecimal.php

@@ -3,7 +3,9 @@
 namespace Litipk\BigNumbers;
 
 use Litipk\BigNumbers\Decimal as Decimal;
+use Litipk\BigNumbers\DecimalConstants as DecimalConstants;
 use Litipk\Exceptions\InvalidCastException;
+use Litipk\Exceptions\NotImplementedException;
 
 /**
  * Immutable object that represents an infinite number
@@ -26,7 +28,6 @@ class InfiniteDecimal extends Decimal
 
     /**
      * Private constructor
-     * @param integer $scale
      * @param string $value
      */
     private function __construct($value)
@@ -168,6 +169,34 @@ public function sqrt($scale = null)
         return $this;
     }
 
+    /**
+     * Powers this value to $b
+     *
+     * @param  Decimal  $b      exponent
+     * @param  integer  $scale
+     * @return Decimal
+     */
+    public function pow(Decimal $b, $scale = null)
+    {
+        if ($b->isPositive()) {
+            if ($this->isPositive()) {
+                return $this;
+            }
+
+            // if ($this->isNegative())
+            if ($b->isInfinite()) {
+                throw new \DomainException("Negative infinite elevated to infinite is undefined.");
+            }
+
+            
+
+            throw new NotImplementedException("See issues #21, #22, #23 and #24 on Github.");
+
+        } else if ($b->isNegative()) {
+            return DecimalConstants::Zero();
+        }
+    }
+
     /**
      * Returns the object's logarithm in base 10
      * @param  integer $scale
@@ -199,6 +228,7 @@ public function equals(Decimal $b, $scale = null)
      * $this > $b : returns 1 , $this < $b : returns -1 , $this == $b : returns 0
      *
      * @param  Decimal $b
+     * @param  integer $scale
      * @return integer
      */
     public function comp(Decimal $b, $scale = null)
@@ -282,6 +312,7 @@ public function tan($scale = null)
     }
 
     /**
+     * @param  integer $scale Has no effect, exists only for compatibility.
      * @return boolean
      */
     public function isZero($scale = null)

tests/InfiniteDecimal/InfiniteDecimalPowTest.php

@@ -0,0 +1,74 @@
+<?php
+
+use Litipk\BigNumbers\Decimal as Decimal;
+use Litipk\BigNumbers\InfiniteDecimal as InfiniteDecimal;
+use Litipk\BigNumbers\DecimalConstants as DecimalConstants;
+
+
+date_default_timezone_set('UTC');
+
+
+class InfiniteDecimalPowTest extends PHPUnit_Framework_TestCase
+{
+    public function testPositiveInfinitePositivePower()
+    {
+        $pInf = InfiniteDecimal::getPositiveInfinite();
+
+        $this->assertTrue($pInf->pow(Decimal::fromInteger(1))->equals($pInf));
+        $this->assertTrue($pInf->pow(Decimal::fromInteger(2))->equals($pInf));
+        $this->assertTrue($pInf->pow(Decimal::fromInteger(3))->equals($pInf));
+
+        $this->assertTrue($pInf->pow($pInf)->equals($pInf));
+    }
+
+    public function testPositiveInfiniteNegativePower()
+    {
+        $pInf = InfiniteDecimal::getPositiveInfinite();
+        $nInf = InfiniteDecimal::getNegativeInfinite();
+        $zero = DecimalConstants::Zero();
+
+        $this->assertTrue($pInf->pow(Decimal::fromInteger(-1))->equals($zero));
+        $this->assertTrue($pInf->pow(Decimal::fromInteger(-2))->equals($zero));
+        $this->assertTrue($pInf->pow(Decimal::fromInteger(-3))->equals($zero));
+
+        $this->assertTrue($pInf->pow($nInf)->equals($zero));
+    }
+
+    public function testNegativeInfinitePositiveFinitePower()
+    {
+        $pInf = InfiniteDecimal::getPositiveInfinite();
+        $nInf = InfiniteDecimal::getNegativeInfinite();
+
+        $this->assertTrue($nInf->pow(Decimal::fromInteger(1))->equals($nInf));
+        $this->assertTrue($nInf->pow(Decimal::fromInteger(2))->equals($pInf));
+        $this->assertTrue($nInf->pow(Decimal::fromInteger(3))->equals($nInf));
+        $this->assertTrue($nInf->pow(Decimal::fromInteger(4))->equals($pInf));
+    }
+
+    public function testNegativeInfinitePositiveInfinitePower()
+    {
+        $this->assertTrue(false);
+    }
+
+    public function testNegativeInfiniteNegativePower()
+    {
+        $nInf = InfiniteDecimal::getNegativeInfinite();
+        $zero = DecimalConstants::Zero();
+
+        $this->assertTrue($nInf->pow(Decimal::fromInteger(-1))->equals($zero));
+        $this->assertTrue($nInf->pow(Decimal::fromInteger(-2))->equals($zero));
+        $this->assertTrue($nInf->pow(Decimal::fromInteger(-3))->equals($zero));
+
+        $this->assertTrue($nInf->pow($nInf)->equals($zero));
+    }
+
+    public function testPositiveInfiniteZeroPower()
+    {
+        $this->assertTrue(false);
+    }
+
+    public function testNegativeInfiniteZeroPower()
+    {
+        $this->assertTrue(false);
+    }
+}