Added PhysicsProvider tests and improved coverage [#11]

JordanRL · Aug 26, 2015 · c7b044d · c7b044d
1 parent 270e4b8
commit c7b044d
Show file tree

Hide file tree

Showing 5 changed files with 245 additions and 23 deletions.
diff --git a/src/Samsara/Newton/Core/Quantity.php b/src/Samsara/Newton/Core/Quantity.php
@@ -230,6 +230,8 @@ public function divideBySquared(Quantity $quantity, $precision = 2)
 
     public function squareRoot(array $numerators, array $denominators, $precision = 2)
     {
+        $numerators[] = $this;
+
         return $this->unitCompClass->naiveSquareRoot($numerators, $denominators, $precision);
     }
 

diff --git a/src/Samsara/Newton/Core/UnitComposition.php b/src/Samsara/Newton/Core/UnitComposition.php
@@ -134,6 +134,15 @@ class UnitComposition
         'cycles'
     ];
 
+    public function __construct()
+    {
+        foreach ($this->unitComp as $unit => $unitDef) {
+            ksort($unitDef);
+
+            $this->unitComp[$unit] = $unitDef;
+        }
+    }
+
     /**
      * @param string    $class
      * @param array     $composition
@@ -173,6 +182,7 @@ public function getUnitCompArray(array $numerators, array $denominators)
         }
 
         foreach ($numerators as $unit) {
+            /** @var Quantity $unit */
             foreach ($unit->getUnitsPresent() as $unitType => $unitCount) {
                 if ($unitCount != 0) {
                     $unitComp[$unitType] += $unitCount;
@@ -181,6 +191,7 @@ public function getUnitCompArray(array $numerators, array $denominators)
         }
 
         foreach ($denominators as $unit) {
+            /** @var Quantity $unit */
             foreach ($unit->getUnitsPresent() as $unitType => $unitCount) {
                 if ($unitCount != 0) {
                     $unitComp[$unitType] -= $unitCount;
@@ -215,8 +226,8 @@ public function getUnitCompClass(array $comp)
     public function getUnitCompName(array $comp)
     {
         foreach ($this->unitComp as $unit => $unitDef) {
-            $diff = array_diff($comp, $unitDef);
-            if (count($diff) === 0) {
+            ksort($comp);
+            if ($comp === $unitDef) {
                 return $unit;
             }
         }
@@ -320,34 +331,36 @@ public function naiveDivide(Quantity $numerator, Quantity $denominator, $precisi
      */
     public function naiveMultiOpt(array $numerators, array $denominators, $precision = 2)
     {
-        $newUnit = $this->getMultiUnits($numerators, $denominators);
-
         $newVal = 1;
 
-        foreach ($numerators as $quantity) {
+        foreach ($numerators as $key => $quantity) {
             if ($quantity instanceof Quantity) {
                 $oldUnit = $quantity->getUnit();
                 $newVal = MathProvider::multiply($newVal, $quantity->toNative()->getValue());
                 $quantity->to($oldUnit);
             } elseif (is_numeric($quantity)) {
                 $newVal = MathProvider::multiply($newVal, $quantity);
+                unset($numerators[$key]);
             } else {
                 throw new \Exception('Invalid numerator');
             }
         }
 
-        foreach ($denominators as $quantity) {
+        foreach ($denominators as $key => $quantity) {
             if ($quantity instanceof Quantity) {
                 $oldUnit = $quantity->getUnit();
                 $newVal = MathProvider::divide($newVal, $quantity->toNative()->getValue(), $precision);
                 $quantity->to($oldUnit);
             } elseif (is_numeric($quantity)) {
                 $newVal = MathProvider::divide($newVal, $quantity, $precision);
+                unset($denominators[$key]);
             } else {
                 throw new \Exception('Invalid denominator');
             }
         }
 
+        $newUnit = $this->getMultiUnits($numerators, $denominators);
+
         return $newUnit->preConvertedAdd($newVal);
     }
 
@@ -361,44 +374,46 @@ public function naiveMultiOpt(array $numerators, array $denominators, $precision
      */
     public function naiveSquareRoot(array $numerators, array $denominators, $precision = 2)
     {
-        $unitComp = $this->getUnitCompArray($numerators, $denominators);
-
-        foreach ($unitComp as $unit => $exp) {
-            $newExp = $exp/2;
-            if (!is_int($newExp)) {
-                throw new \Exception('Incorrect exponents after square root.');
-            }
-            $unitComp[$unit] = $newExp;
-        }
-
-        $newUnit = $this->getUnitCompClass($unitComp);
-
         $newVal = 1;
 
-        foreach ($numerators as $quantity) {
+        foreach ($numerators as $key => $quantity) {
             if ($quantity instanceof Quantity) {
                 $oldUnit = $quantity->getUnit();
                 $newVal = MathProvider::multiply($newVal, $quantity->toNative()->getValue());
                 $quantity->to($oldUnit);
             } elseif (is_numeric($quantity)) {
                 $newVal = MathProvider::multiply($newVal, $quantity);
+                unset($numerators[$key]);
             } else {
                 throw new \Exception('Invalid numerator');
             }
         }
 
-        foreach ($denominators as $quantity) {
+        foreach ($denominators as $key => $quantity) {
             if ($quantity instanceof Quantity) {
                 $oldUnit = $quantity->getUnit();
                 $newVal = MathProvider::divide($newVal, $quantity->toNative()->getValue(), $precision);
                 $quantity->to($oldUnit);
             } elseif (is_numeric($quantity)) {
                 $newVal = MathProvider::divide($newVal, $quantity, $precision);
+                unset($denominators[$key]);
             } else {
                 throw new \Exception('Invalid denominator');
             }
         }
 
+        $unitComp = $this->getUnitCompArray($numerators, $denominators);
+
+        foreach ($unitComp as $unit => $exp) {
+            $newExp = $exp/2;
+            if (!is_int($newExp)) {
+                throw new \Exception('Incorrect exponents after square root.');
+            }
+            $unitComp[$unit] = $newExp;
+        }
+
+        $newUnit = $this->getUnitCompClass($unitComp);
+
         return $newUnit->preConvertedAdd(MathProvider::squareRoot($newVal, $precision));
     }
 

diff --git a/src/Samsara/Newton/Provider/PhysicsProvider.php b/src/Samsara/Newton/Provider/PhysicsProvider.php
@@ -70,10 +70,10 @@ public static function constantAccelCalcs(...$quantities)
             return $vals['acceleration']->multiplyBySquared($vals['time'])->preConvertedDivide(2);
         } elseif (array_key_exists('length', $vals) && array_key_exists('acceleration', $vals)) {
             /** @return Time */
-            return $vals['length']->squareRoot([2, $vals['acceleration']], []);
+            return $vals['length']->squareRoot([2], [$vals['acceleration']]);
         } else {
             /** @return Acceleration */
-            return $vals['length']->divideBySquared($vals['time'])->preConvertedMultiple(2);
+            return $vals['length']->divideBySquared($vals['time'])->preConvertedMultiply(2);
         }
     }
 
@@ -195,7 +195,7 @@ public static function kineticEnergyCalcs(...$quantities)
             return $vals['energy']->squareRoot([2], [$vals['mass']]);
         } else {
             /** @return Mass */
-            return $vals['energy']->divideBySquared($vals['velocity'])->preConvertedMultiple(2);
+            return $vals['energy']->divideBySquared($vals['velocity'])->preConvertedMultiply(2);
         }
     }
 

diff --git a/tests/Samsara/Newton/Core/UnitCompositionTest.php b/tests/Samsara/Newton/Core/UnitCompositionTest.php
@@ -246,6 +246,81 @@ public function testNaiveMultiOpt()
             '10',
             $frequency->getValue()
         );
+
+        $this->assertEquals(
+            '10',
+            $unit->naiveMultiOpt([$time, 2, 5], [])->getValue()
+        );
+
+        $this->assertEquals(
+            '2',
+            $unit->naiveMultiOpt([$time, 10], [5])->getValue()
+        );
+    }
+
+    public function testInvalidNumerator()
+    {
+        $unit = new UnitComposition();
+
+        $this->setExpectedException('Exception', 'Invalid numerator');
+
+        $unit->naiveMultiOpt(['hello', 'world'], []);
+    }
+
+    public function testInvalidDenominator()
+    {
+        $unit = new UnitComposition();
+
+        $this->setExpectedException('Exception', 'Invalid denominator');
+
+        $unit->naiveMultiOpt([], ['hello', 'world']);
+    }
+
+    public function testGetMultipliedUnit()
+    {
+        $unit = new UnitComposition();
+
+        $mass = $unit->getUnitClass(UnitComposition::MASS);
+        $acceleration = $unit->getUnitClass(UnitComposition::ACCELERATION);
+
+        $mass->preConvertedAdd(1);
+        $acceleration->preConvertedAdd(1);
+
+        $this->assertInstanceOf(
+            'Samsara\\Newton\\Units\\Force',
+            $unit->getMultipliedUnit($mass, $acceleration)
+        );
+    }
+
+    public function testNaiveSquareRoot()
+    {
+        $unit = new UnitComposition();
+
+        $length = $unit->getUnitClass(UnitComposition::LENGTH);
+        $acceleration = $unit->getUnitClass(UnitComposition::ACCELERATION);
+
+        $acceleration->preConvertedAdd(1);
+
+        $this->assertInstanceOf(
+            'Samsara\\Newton\\Units\\Time',
+            $length->squareRoot([], [$acceleration])
+        );
+    }
+
+    public function testGetDividedUnit()
+    {
+        $unit = new UnitComposition();
+
+        $mass = $unit->getUnitClass(UnitComposition::MASS);
+        $force = $unit->getUnitClass(UnitComposition::FORCE);
+
+        $mass->preConvertedAdd(1);
+        $force->preConvertedAdd(1);
+
+        $this->assertInstanceOf(
+            'Samsara\\Newton\\Units\\Acceleration',
+            $unit->getDividedUnit($force, $mass)
+        );
     }
 
 }
diff --git a/tests/Samsara/Newton/Provider/PhysicsProviderTest.php b/tests/Samsara/Newton/Provider/PhysicsProviderTest.php
@@ -0,0 +1,130 @@
+<?php
+
+namespace Samsara\Newton\Provider;
+
+use Samsara\Newton\Core\UnitComposition;
+
+class PhysicsProviderTest extends \PHPUnit_Framework_TestCase
+{
+
+    public function testConstantAccel()
+    {
+
+        $unit = new UnitComposition();
+
+        $length = $unit->getUnitClass(UnitComposition::LENGTH);
+        $time = $unit->getUnitClass(UnitComposition::TIME);
+        $accel = $unit->getUnitClass(UnitComposition::ACCELERATION);
+
+        $length->preConvertedAdd(1);
+        $time->preConvertedAdd(1);
+        $accel->preConvertedAdd(1);
+
+        $this->assertInstanceOf(
+            'Samsara\\Newton\\Units\\Time',
+            PhysicsProvider::constantAccelCalcs($length, $accel)
+        );
+
+        $this->assertInstanceOf(
+            'Samsara\\Newton\\Units\\Length',
+            PhysicsProvider::constantAccelCalcs($time, $accel)
+        );
+
+        $this->assertInstanceOf(
+            'Samsara\\Newton\\Units\\Acceleration',
+            PhysicsProvider::constantAccelCalcs($length, $time)
+        );
+
+    }
+
+    public function testNewtonsSecondLaw()
+    {
+
+        $unit = new UnitComposition();
+
+        $force = $unit->getUnitClass(UnitComposition::FORCE);
+        $mass = $unit->getUnitClass(UnitComposition::MASS);
+        $accel = $unit->getUnitClass(UnitComposition::ACCELERATION);
+
+        $force->preConvertedAdd(1);
+        $mass->preConvertedAdd(1);
+        $accel->preConvertedAdd(1);
+
+        $this->assertInstanceOf(
+            'Samsara\\Newton\\Units\\Mass',
+            PhysicsProvider::forceMassAccelCalcs($force, $accel)
+        );
+
+        $this->assertInstanceOf(
+            'Samsara\\Newton\\Units\\Force',
+            PhysicsProvider::forceMassAccelCalcs($mass, $accel)
+        );
+
+        $this->assertInstanceOf(
+            'Samsara\\Newton\\Units\\Acceleration',
+            PhysicsProvider::forceMassAccelCalcs($force, $mass)
+        );
+
+    }
+
+    public function testKineticEnergy()
+    {
+
+        $unit = new UnitComposition();
+
+        $energy = $unit->getUnitClass(UnitComposition::ENERGY);
+        $mass = $unit->getUnitClass(UnitComposition::MASS);
+        $velocity = $unit->getUnitClass(UnitComposition::VELOCITY);
+
+        $energy->preConvertedAdd(1);
+        $mass->preConvertedAdd(1);
+        $velocity->preConvertedAdd(1);
+
+        $this->assertInstanceOf(
+            'Samsara\\Newton\\Units\\Mass',
+            PhysicsProvider::kineticEnergyCalcs($energy, $velocity)
+        );
+
+        $this->assertInstanceOf(
+            'Samsara\\Newton\\Units\\Energy',
+            PhysicsProvider::kineticEnergyCalcs($mass, $velocity)
+        );
+
+        $this->assertInstanceOf(
+            'Samsara\\Newton\\Units\\Velocity',
+            PhysicsProvider::kineticEnergyCalcs($energy, $mass)
+        );
+
+    }
+
+    public function testMomentum()
+    {
+
+        $unit = new UnitComposition();
+
+        $momentum = $unit->getUnitClass(UnitComposition::MOMENTUM);
+        $mass = $unit->getUnitClass(UnitComposition::MASS);
+        $velocity = $unit->getUnitClass(UnitComposition::VELOCITY);
+
+        $momentum->preConvertedAdd(1);
+        $mass->preConvertedAdd(1);
+        $velocity->preConvertedAdd(1);
+
+        $this->assertInstanceOf(
+            'Samsara\\Newton\\Units\\Mass',
+            PhysicsProvider::momentumCalcs($momentum, $velocity)
+        );
+
+        $this->assertInstanceOf(
+            'Samsara\\Newton\\Units\\Momentum',
+            PhysicsProvider::momentumCalcs($mass, $velocity)
+        );
+
+        $this->assertInstanceOf(
+            'Samsara\\Newton\\Units\\Velocity',
+            PhysicsProvider::momentumCalcs($momentum, $mass)
+        );
+
+    }
+
+}