Jingga/phpOMS
1
0
Fork 0
mirror of https://github.com/Karaka-Management/phpOMS.git synced 2026-01-19 04:58:41 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Use equalsWithDelta

Browse Source
This commit is contained in:
Dennis Eichhorn 2019-03-17 11:38:01 +01:00
parent c316c1715a
commit a61a62adcc
42 changed files with 189 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
tests/Business/Finance/DepreciationTest.php
View File

@ -23,8 +23,8 @@ class DepreciationTest extends \PHPUnit\Framework\TestCase
$duration = 6;
$t = 2;
self::assertEquals(3880, Depreciation::getStraightLineDepreciation($start, $duration), '', 5);
self::assertEquals(23280 - 3880 * $t, Depreciation::getStraightLineResidualInT($start, $duration, $t), '', 5);
self::assertEqualsWithDelta(3880, Depreciation::getStraightLineDepreciation($start, $duration), 5);
self::assertEqualsWithDelta(23280 - 3880 * $t, Depreciation::getStraightLineResidualInT($start, $duration, $t), 5);
}
public function testArithmeticDegressivDepreciation() : void
@ -34,9 +34,9 @@ class DepreciationTest extends \PHPUnit\Framework\TestCase
$duration = 5;
$t = 2;
self::assertEquals(8800, Depreciation::getArithmeticDegressivDepreciationFactor($start, $residual, $duration), '', 5);
self::assertEquals(35200, Depreciation::getArithmeticDegressivDepreciationInT($start, $residual,$duration, $t), '', 5);
self::assertEquals(70800, Depreciation::getArithmeticDegressivDepreciationResidualInT($start, $residual, $duration, $t), '', 5);
self::assertEqualsWithDelta(8800, Depreciation::getArithmeticDegressivDepreciationFactor($start, $residual, $duration), 5);
self::assertEqualsWithDelta(35200, Depreciation::getArithmeticDegressivDepreciationInT($start, $residual,$duration, $t), 5);
self::assertEqualsWithDelta(70800, Depreciation::getArithmeticDegressivDepreciationResidualInT($start, $residual, $duration, $t), 5);
}
public function testArithmeticProgressivDepreciation() : void
@ -46,9 +46,9 @@ class DepreciationTest extends \PHPUnit\Framework\TestCase
$duration = 4;
$t = 2;
self::assertEquals(3530, Depreciation::getArithmeticProgressivDepreciationFactor($start, $residual, $duration), '', 5);
self::assertEquals(7060, Depreciation::getArithmeticProgressivDepreciationInT($start, $residual, $duration, $t), '', 5);
self::assertEquals(29410, Depreciation::getArithmeticProgressivDepreciationResidualInT($start, $residual, $duration, $t), '', 5);
self::assertEqualsWithDelta(3530, Depreciation::getArithmeticProgressivDepreciationFactor($start, $residual, $duration), 5);
self::assertEqualsWithDelta(7060, Depreciation::getArithmeticProgressivDepreciationInT($start, $residual, $duration, $t), 5);
self::assertEqualsWithDelta(29410, Depreciation::getArithmeticProgressivDepreciationResidualInT($start, $residual, $duration, $t), 5);
}
public function testGeometicProgressivDepreciation() : void
@ -58,9 +58,9 @@ class DepreciationTest extends \PHPUnit\Framework\TestCase
$duration = 5;
$t = 2;
self::assertEquals(0.3456, Depreciation::getGeometicProgressivDepreciationRate($start, $residual, $duration), '', 0.01);
self::assertEquals(14527, Depreciation::getGeometicProgressivDepreciationInT($start, $residual, $duration, $t), '', 5);
self::assertEquals(125965, Depreciation::getGeometicProgressivDepreciationResidualInT($start, $residual, $duration, $t), '', 5);
self::assertEqualsWithDelta(0.3456, Depreciation::getGeometicProgressivDepreciationRate($start, $residual, $duration), 0.01);
self::assertEqualsWithDelta(14527, Depreciation::getGeometicProgressivDepreciationInT($start, $residual, $duration, $t), 5);
self::assertEqualsWithDelta(125965, Depreciation::getGeometicProgressivDepreciationResidualInT($start, $residual, $duration, $t), 5);
}
public function testGeometicDegressivDepreciation() : void
@ -70,8 +70,8 @@ class DepreciationTest extends \PHPUnit\Framework\TestCase
$duration = 5;
$t = 2;
self::assertEquals(0.3456, Depreciation::getGeometicDegressivDepreciationRate($start, $residual, $duration), '', 0.01);
self::assertEquals(33924, Depreciation::getGeometicDegressivDepreciationInT($start, $residual, $duration, $t), '', 5);
self::assertEquals(64236, Depreciation::getGeometicDegressivDepreciationResidualInT($start, $residual, $duration, $t), '', 5);
self::assertEqualsWithDelta(0.3456, Depreciation::getGeometicDegressivDepreciationRate($start, $residual, $duration), 0.01);
self::assertEqualsWithDelta(33924, Depreciation::getGeometicDegressivDepreciationInT($start, $residual, $duration, $t), 5);
self::assertEqualsWithDelta(64236, Depreciation::getGeometicDegressivDepreciationResidualInT($start, $residual, $duration, $t), 5);
}
}

42
tests/Business/Finance/FinanceFormulasTest.php
View File

@ -254,7 +254,7 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
{
$r = 0.05;
self::assertEquals(13.863, FinanceFormulas::getDoublingTimeContinuousCompounding($r), '', 0.01);
self::assertEqualsWithDelta(13.863, FinanceFormulas::getDoublingTimeContinuousCompounding($r), 0.01);
}
public function testEquivalentAnnualAnnuity() : void
@ -263,9 +263,9 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
$r = 0.15;
$n = 7;
self::assertEquals(240.36, FinanceFormulas::getEquivalentAnnualAnnuity($npv, $r, $n), '', 0.01);
self::assertEqualsWithDelta(240.36, FinanceFormulas::getEquivalentAnnualAnnuity($npv, $r, $n), 0.01);
self::assertEquals($n, FinanceFormulas::getPeriodsOfEAA(240.36, $npv, $r));
self::assertEquals($npv, FinanceFormulas::getNetPresentValueOfEAA(240.36, $r, $n), '', 0.01);
self::assertEqualsWithDelta($npv, FinanceFormulas::getNetPresentValueOfEAA(240.36, $r, $n), 0.01);
}
public function testFreeCashFlowToEquity() : void
@ -276,7 +276,7 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
$wc = 200;
$borrowing = 500;
self::assertEquals(1200, FinanceFormulas::getFreeCashFlowToEquity($income, $depamo, $capital, $wc, $borrowing), '', 0.01);
self::assertEqualsWithDelta(1200, FinanceFormulas::getFreeCashFlowToEquity($income, $depamo, $capital, $wc, $borrowing), 0.01);
}
public function testFreeCashFlowToFirm() : void
@ -287,7 +287,7 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
$capital = 400;
$wc = 200;
self::assertEquals(550, FinanceFormulas::getFreeCashFlowToFirm($ebit, $t, $depamo, $capital, $wc), '', 0.01);
self::assertEqualsWithDelta(550, FinanceFormulas::getFreeCashFlowToFirm($ebit, $t, $depamo, $capital, $wc), 0.01);
}
public function testFutureValue() : void
@ -296,7 +296,7 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
$r = 0.15;
$n = 7;
self::assertEquals(2660.02, FinanceFormulas::getFutureValue($c, $r, $n), '', 0.01);
self::assertEqualsWithDelta(2660.02, FinanceFormulas::getFutureValue($c, $r, $n), 0.01);
}
public function testFutureValueContinuousCompounding() : void
@ -305,7 +305,7 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
$r = 0.15;
$t = 7;
self::assertEquals(2857.65, FinanceFormulas::getFutureValueContinuousCompounding($pv, $r, $t), '', 0.01);
self::assertEqualsWithDelta(2857.65, FinanceFormulas::getFutureValueContinuousCompounding($pv, $r, $t), 0.01);
}
public function testValueFactor() : void
@ -313,15 +313,15 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
$r = 0.15;
$n = 7;
self::assertEquals(2.66, FinanceFormulas::getFutureValueFactor($r, $n), '', 0.01);
self::assertEquals(0.37594, FinanceFormulas::getPresentValueFactor($r, $n), '', 0.01);
self::assertEqualsWithDelta(2.66, FinanceFormulas::getFutureValueFactor($r, $n), 0.01);
self::assertEqualsWithDelta(0.37594, FinanceFormulas::getPresentValueFactor($r, $n), 0.01);
}
public function testGeometricMeanReturn() : void
{
$r = [0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07];
self::assertEquals(0.04123, FinanceFormulas::getGeometricMeanReturn($r), '', 0.01);
self::assertEqualsWithDelta(0.04123, FinanceFormulas::getGeometricMeanReturn($r), 0.01);
}
public function testGrowingAnnuityFV() : void
@ -331,7 +331,7 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
$g = 0.1;
$n = 7;
self::assertEquals(14226.06, FinanceFormulas::getGrowingAnnuityFV($p, $r, $g, $n), '', 0.01);
self::assertEqualsWithDelta(14226.06, FinanceFormulas::getGrowingAnnuityFV($p, $r, $g, $n), 0.01);
}
public function testGrowingAnnuityPaymentPV() : void
@ -341,7 +341,7 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
$g = 0.1;
$n = 7;
self::assertEquals(186.98, FinanceFormulas::getGrowingAnnuityPaymentPV($p, $r, $g, $n), '', 0.01);
self::assertEqualsWithDelta(186.98, FinanceFormulas::getGrowingAnnuityPaymentPV($p, $r, $g, $n), 0.01);
}
public function testGrowingAnnuityPaymentFV() : void
@ -351,7 +351,7 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
$g = 0.1;
$n = 7;
self::assertEquals(70.29, FinanceFormulas::getGrowingAnnuityPaymentFV($fv, $r, $g, $n), '', 0.01);
self::assertEqualsWithDelta(70.29, FinanceFormulas::getGrowingAnnuityPaymentFV($fv, $r, $g, $n), 0.01);
}
public function testGrowingAnnuityPV() : void
@ -361,7 +361,7 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
$g = 0.1;
$n = 7;
self::assertEquals(5348.1, FinanceFormulas::getGrowingAnnuityPV($p, $r, $g, $n), '', 0.01);
self::assertEqualsWithDelta(5348.1, FinanceFormulas::getGrowingAnnuityPV($p, $r, $g, $n), 0.01);
}
public function testGrowingPerpetuityPV() : void
@ -370,7 +370,7 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
$r = 0.15;
$g = 0.1;
self::assertEquals(20000, FinanceFormulas::getGrowingPerpetuityPV($d, $r, $g), '', 0.01);
self::assertEqualsWithDelta(20000, FinanceFormulas::getGrowingPerpetuityPV($d, $r, $g), 0.01);
}
public function testNetPresentValue() : void
@ -378,7 +378,7 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
$c = [1000, 100, 200, 300, 400, 500, 600];
$r = 0.15;
self::assertEquals(172.13, FinanceFormulas::getNetPresentValue($c, $r), '', 0.01);
self::assertEqualsWithDelta(172.13, FinanceFormulas::getNetPresentValue($c, $r), 0.01);
}
public function testInvalidNetPresentValue() : void
@ -393,12 +393,12 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
$nominal = 0.15;
$inflation = 0.05;
self::assertEquals(0.09524, FinanceFormulas::getRealRateOfReturn($nominal, $inflation), '', 0.01);
self::assertEqualsWithDelta(0.09524, FinanceFormulas::getRealRateOfReturn($nominal, $inflation), 0.01);
}
public function testNetWorkingCapital() : void
{
self::assertEquals(1000 - 600, FinanceFormulas::getNetWorkingCapital(1000, 600), '', 0.01);
self::assertEqualsWithDelta(1000 - 600, FinanceFormulas::getNetWorkingCapital(1000, 600), 0.01);
}
public function testNumberOfPeriodsPVFV() : void
@ -407,7 +407,7 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
$pv = 1000;
$r = 0.03;
self::assertEquals(6.1681, FinanceFormulas::getNumberOfPeriodsPVFV($fv, $pv, $r), '', 0.01);
self::assertEqualsWithDelta(6.1681, FinanceFormulas::getNumberOfPeriodsPVFV($fv, $pv, $r), 0.01);
}
public function testPresentValue() : void
@ -416,7 +416,7 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
$r = 0.15;
$n = 7;
self::assertEquals(375.94, FinanceFormulas::getPresentValue($c, $r, $n), '', 0.01);
self::assertEqualsWithDelta(375.94, FinanceFormulas::getPresentValue($c, $r, $n), 0.01);
}
public function testPresentValueContinuousCompounding() : void
@ -425,6 +425,6 @@ class FinanceFormulasTest extends \PHPUnit\Framework\TestCase
$r = 0.15;
$t = 7;
self::assertEquals(349.94, FinanceFormulas::getPresentValueContinuousCompounding($c, $r, $t), '', 0.01);
self::assertEqualsWithDelta(349.94, FinanceFormulas::getPresentValueContinuousCompounding($c, $r, $t), 0.01);
}
}

8
tests/Business/Finance/LoanTest.php
View File

@ -30,7 +30,7 @@ class LoanTest extends \PHPUnit\Framework\TestCase
$n = 7;
$balloon = 300;
self::assertEquals(213.25, Loan::getPaymentsOnBalloonLoan($pv, $r, $n, $balloon), '', 0.01);
self::assertEqualsWithDelta(213.25, Loan::getPaymentsOnBalloonLoan($pv, $r, $n, $balloon), 0.01);
}
public function testBalloonBalanceOfLoan() : void
@ -40,7 +40,7 @@ class LoanTest extends \PHPUnit\Framework\TestCase
$r = 0.15;
$n = 7;
self::assertEquals(-660.02, Loan::getBalloonBalanceOfLoan($pv, $p, $r, $n), '', 0.01);
self::assertEqualsWithDelta(-660.02, Loan::getBalloonBalanceOfLoan($pv, $p, $r, $n), 0.01);
}
public function testLoanPayment() : void
@ -49,7 +49,7 @@ class LoanTest extends \PHPUnit\Framework\TestCase
$r = 0.15;
$n = 7;
self::assertEquals(240.36, Loan::getLoanPayment($pv, $r, $n), '', 0.01);
self::assertEqualsWithDelta(240.36, Loan::getLoanPayment($pv, $r, $n), 0.01);
}
public function testRemainingBalanceLoan() : void
@ -59,6 +59,6 @@ class LoanTest extends \PHPUnit\Framework\TestCase
$r = 0.15;
$n = 7;
self::assertEquals(446.66, Loan::getRemainingBalanceLoan($pv, $p, $r, $n), '', 0.01);
self::assertEqualsWithDelta(446.66, Loan::getRemainingBalanceLoan($pv, $p, $r, $n), 0.01);
}
}

24
tests/Business/Finance/StockBondsTest.php
View File

@ -33,29 +33,29 @@ class StockBondsTest extends \PHPUnit\Framework\TestCase
public function testBondEquivalentYield() : void
{
self::assertEquals(0.40556, StockBonds::getBondEquivalentYield(100, 90, 100), '', 0.01);
self::assertEqualsWithDelta(0.40556, StockBonds::getBondEquivalentYield(100, 90, 100), 0.01);
}
public function testExpectedReturnCAPM() : void
{
self::assertEquals(7, StockBonds::getExpectedReturnCAPM(3, 2, 5), '', 0.01);
self::assertEqualsWithDelta(7, StockBonds::getExpectedReturnCAPM(3, 2, 5), 0.01);
}
public function testCapitalGainsYield() : void
{
self::assertEquals(0.1, StockBonds::getCapitalGainsYield(100, 110), '', 0.01);
self::assertEqualsWithDelta(0.1, StockBonds::getCapitalGainsYield(100, 110), 0.01);
}
public function testDilutedEarningsPerShare() : void
{
self::assertEquals(9.09, StockBonds::getDilutedEarningsPerShare(1000, 100, 10), '', 0.1);
self::assertEqualsWithDelta(9.09, StockBonds::getDilutedEarningsPerShare(1000, 100, 10), 0.1);
}
public function testHoldingPeriodReturn() : void
{
$r = [0.01, 0.02, 0.03, 0.04];
self::assertEquals(0.10355, StockBonds::getHoldingPeriodReturn($r), '', 0.01);
self::assertEqualsWithDelta(0.10355, StockBonds::getHoldingPeriodReturn($r), 0.01);
}
public function testTaxEquivalentYield() : void
@ -63,7 +63,7 @@ class StockBondsTest extends \PHPUnit\Framework\TestCase
$free = 0.15;
$rate = 0.05;
self::assertEquals(0.15789, StockBonds::getTaxEquivalentYield($free, $rate), '', 0.01);
self::assertEqualsWithDelta(0.15789, StockBonds::getTaxEquivalentYield($free, $rate), 0.01);
}
public function testNetAssetValue() : void
@ -72,7 +72,7 @@ class StockBondsTest extends \PHPUnit\Framework\TestCase
$liabilities = 300;
$shares = 400;
self::assertEquals(1.75, StockBonds::getNetAssetValue($assets, $liabilities, $shares), '', 0.01);
self::assertEqualsWithDelta(1.75, StockBonds::getNetAssetValue($assets, $liabilities, $shares), 0.01);
}
public function testPresentValueOfStockConstantGrowth() : void
@ -81,7 +81,7 @@ class StockBondsTest extends \PHPUnit\Framework\TestCase
$r = 0.15;
$g = 0.05;
self::assertEquals(5000, StockBonds::getPresentValueOfStockConstantGrowth($div, $r, $g), '', 0.01);
self::assertEqualsWithDelta(5000, StockBonds::getPresentValueOfStockConstantGrowth($div, $r, $g), 0.01);
}
public function testTotalStockReturn() : void
@ -90,7 +90,7 @@ class StockBondsTest extends \PHPUnit\Framework\TestCase
$p1 = 1200;
$d = 100;
self::assertEquals(0.3, StockBonds::getTotalStockReturn($p0, $p1, $d), '', 0.01);
self::assertEqualsWithDelta(0.3, StockBonds::getTotalStockReturn($p0, $p1, $d), 0.01);
}
public function testYieldToMaturity() : void
@ -100,7 +100,7 @@ class StockBondsTest extends \PHPUnit\Framework\TestCase
$p = 920;
$n = 10;
self::assertEquals(0.1138, StockBonds::getYieldToMaturity($c, $f, $p, $n), '', 0.01);
self::assertEqualsWithDelta(0.1138, StockBonds::getYieldToMaturity($c, $f, $p, $n), 0.01);
}
public function testZeroCouponBondValue() : void
@ -109,7 +109,7 @@ class StockBondsTest extends \PHPUnit\Framework\TestCase
$r = 0.06;
$t = 5;
self::assertEquals(74.73, StockBonds::getZeroCouponBondValue($f, $r, $t), '', 0.01);
self::assertEqualsWithDelta(74.73, StockBonds::getZeroCouponBondValue($f, $r, $t), 0.01);
}
public function testZeroCouponBondEffectiveYield() : void
@ -118,6 +118,6 @@ class StockBondsTest extends \PHPUnit\Framework\TestCase
$pv = 90;
$n = 5;
self::assertEquals(0.01517, StockBonds::getZeroCouponBondEffectiveYield($f, $pv, $n), '', 0.01);
self::assertEqualsWithDelta(0.01517, StockBonds::getZeroCouponBondEffectiveYield($f, $pv, $n), 0.01);
}
}

4
tests/Math/Functions/FunctionsTest.php
View File

@ -72,7 +72,7 @@ class FunctionsTest extends \PHPUnit\Framework\TestCase
self::assertEquals([4, 9, 16], Functions::powerInt([2, 3, 4], 2));
self::assertEquals([8, 27, 64], Functions::powerInt([2, 3, 4], 3));
self::assertEquals([2.0, 3.0, 4.0], Functions::powerFloat([4, 9, 16], 1 / 2), '', 0.0);
self::assertEquals([2.0, 3.0, 4.0], Functions::powerFloat([8, 27, 64], 1 / 3), '', 0.0);
self::assertEqualsWithDelta([2.0, 3.0, 4.0], Functions::powerFloat([4, 9, 16], 1 / 2), 0.0);
self::assertEqualsWithDelta([2.0, 3.0, 4.0], Functions::powerFloat([8, 27, 64], 1 / 3), 0.0);
}
}

6
tests/Math/Functions/GammaTest.php
View File

@ -38,9 +38,9 @@ class GammaTest extends \PHPUnit\Framework\TestCase
];
for ($i = 1; $i <= 10; $i++) {
self::assertEquals($stirling[$i - 1], Gamma::stirlingApproximation($i / 3), '', 0.01);
self::assertEquals($spouge[$i - 1], Gamma::spougeApproximation($i / 3), '', 0.01);
self::assertEquals($gsl[$i - 1], Gamma::lanczosApproximationReal($i / 3), '', 0.01);
self::assertEqualsWithDelta($stirling[$i - 1], Gamma::stirlingApproximation($i / 3), 0.01);
self::assertEqualsWithDelta($spouge[$i - 1], Gamma::spougeApproximation($i / 3), 0.01);
self::assertEqualsWithDelta($gsl[$i - 1], Gamma::lanczosApproximationReal($i / 3), 0.01);
}
}
}

8
tests/Math/Geometry/Shape/D2/CircleTest.php
View File

@ -19,9 +19,9 @@ class CircleTest extends \PHPUnit\Framework\TestCase
{
public function testCircle() : void
{
self::assertEquals(12.57, Circle::getSurface(2), '', 0.01);
self::assertEquals(12.57, Circle::getPerimeter(2), '', 0.01);
self::assertEquals(2.0, Circle::getRadiusBySurface(Circle::getSurface(2)), '', 0.001);
self::assertEquals(2.0, Circle::getRadiusByPerimeter(Circle::getPerimeter(2)), '', 0.001);
self::assertEqualsWithDelta(12.57, Circle::getSurface(2), 0.01);
self::assertEqualsWithDelta(12.57, Circle::getPerimeter(2), 0.01);
self::assertEqualsWithDelta(2.0, Circle::getRadiusBySurface(Circle::getSurface(2)), 0.001);
self::assertEqualsWithDelta(2.0, Circle::getRadiusByPerimeter(Circle::getPerimeter(2)), 0.001);
}
}

4
tests/Math/Geometry/Shape/D2/EllipseTest.php
View File

@ -19,7 +19,7 @@ class EllipseTest extends \PHPUnit\Framework\TestCase
{
public function testEllipse() : void
{
self::assertEquals(6.28, Ellipse::getSurface(2, 1), '', 0.01);
self::assertEquals(9.69, Ellipse::getPerimeter(2, 1), '', 0.01);
self::assertEqualsWithDelta(6.28, Ellipse::getSurface(2, 1), 0.01);
self::assertEqualsWithDelta(9.69, Ellipse::getPerimeter(2, 1), 0.01);
}
}

4
tests/Math/Geometry/Shape/D2/PolygonTest.php
View File

@ -73,7 +73,7 @@ class PolygonTest extends \PHPUnit\Framework\TestCase
['x' => 4, 'y' => 0],
['x' => 3, 'y' => 0],
]);
self::assertEquals(9.6568, $polygon->getPerimeter(), '', 0.1);
self::assertEqualsWithDelta(9.6568, $polygon->getPerimeter(), 0.1);
}
public function testArea() : void
@ -103,6 +103,6 @@ class PolygonTest extends \PHPUnit\Framework\TestCase
['x' => 4, 'y' => 0],
['x' => 3, 'y' => 0],
]);
self::assertEquals(['x' => 3.5, 'y' => 1.5], $polygon->getBarycenter(), '', 0.5);
self::assertEqualsWithDelta(['x' => 3.5, 'y' => 1.5], $polygon->getBarycenter(), 0.5);
}
}

6
tests/Math/Geometry/Shape/D2/RectangleTest.php
View File

@ -19,8 +19,8 @@ class RectangleTest extends \PHPUnit\Framework\TestCase
{
public function testRectanle() : void
{
self::assertEquals(10, Rectangle::getSurface(5, 2), '', 0.001);
self::assertEquals(10, Rectangle::getPerimeter(2, 3), '', 0.001);
self::assertEquals(32.7, Rectangle::getDiagonal(30, 13), '', 0.01);
self::assertEqualsWithDelta(10, Rectangle::getSurface(5, 2), 0.001);
self::assertEqualsWithDelta(10, Rectangle::getPerimeter(2, 3), 0.001);
self::assertEqualsWithDelta(32.7, Rectangle::getDiagonal(30, 13), 0.01);
}
}

14
tests/Math/Geometry/Shape/D2/TrapezoidTest.php
View File

@ -19,13 +19,13 @@ class TrapezoidTest extends \PHPUnit\Framework\TestCase
{
public function testTrapezoid() : void
{
self::assertEquals(10, Trapezoid::getSurface(2, 3, 4), '', 0.001);
self::assertEquals(14, Trapezoid::getPerimeter(2, 3, 4, 5), '', 0.001);
self::assertEquals(4, Trapezoid::getHeight(10, 2, 3), '', 0.001);
self::assertEqualsWithDelta(10, Trapezoid::getSurface(2, 3, 4), 0.001);
self::assertEqualsWithDelta(14, Trapezoid::getPerimeter(2, 3, 4, 5), 0.001);
self::assertEqualsWithDelta(4, Trapezoid::getHeight(10, 2, 3), 0.001);
self::assertEquals(2, Trapezoid::getA(10, 4, 3), '', 0.001);
self::assertEquals(3, Trapezoid::getB(10, 4, 2), '', 0.001);
self::assertEquals(4, Trapezoid::getC(14, 2, 3, 5), '', 0.001);
self::assertEquals(5, Trapezoid::getD(14, 2, 3, 4), '', 0.001);
self::assertEqualsWithDelta(2, Trapezoid::getA(10, 4, 3), 0.001);
self::assertEqualsWithDelta(3, Trapezoid::getB(10, 4, 2), 0.001);
self::assertEqualsWithDelta(4, Trapezoid::getC(14, 2, 3, 5), 0.001);
self::assertEqualsWithDelta(5, Trapezoid::getD(14, 2, 3, 4), 0.001);
}
}

8
tests/Math/Geometry/Shape/D2/TriangleTest.php
View File

@ -19,9 +19,9 @@ class TriangleTest extends \PHPUnit\Framework\TestCase
{
public function testTriangle() : void
{
self::assertEquals(3, Triangle::getSurface(2, 3), '', 0.001);
self::assertEquals(9, Triangle::getPerimeter(2, 3, 4), '', 0.001);
self::assertEquals(3, Triangle::getHeight(3, 2), '', 0.001);
self::assertEquals(5, Triangle::getHypot(4, 3), '', 0.001);
self::assertEqualsWithDelta(3, Triangle::getSurface(2, 3), 0.001);
self::assertEqualsWithDelta(9, Triangle::getPerimeter(2, 3, 4), 0.001);
self::assertEqualsWithDelta(3, Triangle::getHeight(3, 2), 0.001);
self::assertEqualsWithDelta(5, Triangle::getHypot(4, 3), 0.001);
}
}

8
tests/Math/Geometry/Shape/D3/ConeTest.php
View File

@ -19,9 +19,9 @@ class ConeTest extends \PHPUnit\Framework\TestCase
{
public function testCone() : void
{
self::assertEquals(12.57, Cone::getVolume(2, 3), '', 0.01);
self::assertEquals(35.22, Cone::getSurface(2, 3), '', 0.01);
self::assertEquals(3.61, Cone::getSlantHeight(2, 3), '', 0.01);
self::assertEquals(3, Cone::getHeightFromVolume(12.57, 2), '', 0.01);
self::assertEqualsWithDelta(12.57, Cone::getVolume(2, 3), 0.01);
self::assertEqualsWithDelta(35.22, Cone::getSurface(2, 3), 0.01);
self::assertEqualsWithDelta(3.61, Cone::getSlantHeight(2, 3), 0.01);
self::assertEqualsWithDelta(3, Cone::getHeightFromVolume(12.57, 2), 0.01);
}
}

4
tests/Math/Geometry/Shape/D3/CuboidTest.php
View File

@ -19,7 +19,7 @@ class CuboidTest extends \PHPUnit\Framework\TestCase
{
public function testCuboid() : void
{
self::assertEquals(200, Cuboid::getVolume(10, 5, 4), '', 0.001);
self::assertEquals(220, Cuboid::getSurface(10, 5, 4), '', 0.001);
self::assertEqualsWithDelta(200, Cuboid::getVolume(10, 5, 4), 0.001);
self::assertEqualsWithDelta(220, Cuboid::getSurface(10, 5, 4), 0.001);
}
}

6
tests/Math/Geometry/Shape/D3/CylinderTest.php
View File

@ -19,8 +19,8 @@ class CylinderTest extends \PHPUnit\Framework\TestCase
{
public function testCylinder() : void
{
self::assertEquals(37.7, Cylinder::getVolume(2, 3), '', 0.01);
self::assertEquals(62.83, Cylinder::getSurface(2, 3), '', 0.01);
self::assertEquals(37.7, Cylinder::getLateralSurface(2, 3), '', 0.01);
self::assertEqualsWithDelta(37.7, Cylinder::getVolume(2, 3), 0.01);
self::assertEqualsWithDelta(62.83, Cylinder::getSurface(2, 3), 0.01);
self::assertEqualsWithDelta(37.7, Cylinder::getLateralSurface(2, 3), 0.01);
}
}

6
tests/Math/Geometry/Shape/D3/RectangularPyramidTest.php
View File

@ -19,8 +19,8 @@ class RectangularPyramidTest extends \PHPUnit\Framework\TestCase
{
public function testCylinder() : void
{
self::assertEquals(8, RectangularPyramid::getVolume(2, 3, 4), '', 0.01);
self::assertEquals(26.91, RectangularPyramid::getSurface(2, 3, 4), '', 0.01);
self::assertEquals(20.91, RectangularPyramid::getLateralSurface(2, 3, 4), '', 0.01);
self::assertEqualsWithDelta(8, RectangularPyramid::getVolume(2, 3, 4), 0.01);
self::assertEqualsWithDelta(26.91, RectangularPyramid::getSurface(2, 3, 4), 0.01);
self::assertEqualsWithDelta(20.91, RectangularPyramid::getLateralSurface(2, 3, 4), 0.01);
}
}

12
tests/Math/Geometry/Shape/D3/SphereTest.php
View File

@ -20,21 +20,21 @@ class SphereTest extends \PHPUnit\Framework\TestCase
public function testSphere() : void
{
$sphere = new Sphere(3);
self::assertEquals(113.1, $sphere->getVolume(), '', 0.1);
self::assertEquals(113.1, $sphere->getSurface(), '', 0.1);
self::assertEqualsWithDelta(113.1, $sphere->getVolume(), 0.1);
self::assertEqualsWithDelta(113.1, $sphere->getSurface(), 0.1);
self::assertEquals(422740, Sphere::distance2PointsOnSphere(32.9697, -96.80322, 29.46786, -98.53506), '', 50);
self::assertEqualsWithDelta(422740, Sphere::distance2PointsOnSphere(32.9697, -96.80322, 29.46786, -98.53506), 50);
}
public function testGetBy() : void
{
$sphere = Sphere::byRadius(3);
self::assertEquals(3, $sphere->getRadius(), '', 0.1);
self::assertEqualsWithDelta(3, $sphere->getRadius(), 0.1);
$sphere = Sphere::byVolume(4);
self::assertEquals(4, $sphere->getVolume(), '', 0.1);
self::assertEqualsWithDelta(4, $sphere->getVolume(), 0.1);
$sphere = Sphere::bySurface(5);
self::assertEquals(5, $sphere->getSurface(), '', 0.1);
self::assertEqualsWithDelta(5, $sphere->getSurface(), 0.1);
}
}

6
tests/Math/Geometry/Shape/D3/TetrahedronTest.php
View File

@ -19,8 +19,8 @@ class TetrahedronTest extends \PHPUnit\Framework\TestCase
{
public function testTetrahedron() : void
{
self::assertEquals(3.18, Tetrahedron::getVolume(3), '', 0.01);
self::assertEquals(15.59, Tetrahedron::getSurface(3), '', 0.01);
self::assertEquals(3.9, Tetrahedron::getFaceArea(3), '', 0.01);
self::assertEqualsWithDelta(3.18, Tetrahedron::getVolume(3), 0.01);
self::assertEqualsWithDelta(15.59, Tetrahedron::getSurface(3), 0.01);
self::assertEqualsWithDelta(3.9, Tetrahedron::getFaceArea(3), 0.01);
}
}

2
tests/Math/Matrix/CholeskyDecompositionTest.php
View File

@ -72,7 +72,7 @@ class CholeskyDecompositionTest extends \PHPUnit\Framework\TestCase
$vec = new Vector();
$vec->setMatrix([[40], [49], [28]]);
self::assertEquals([[1], [2], [3]], $cholesky->solve($vec)->toArray(), '', 0.2);
self::assertEqualsWithDelta([[1], [2], [3]], $cholesky->solve($vec)->toArray(), 0.2);
}
public function testInvalidDimension() : void

4
tests/Math/Matrix/EigenvalueDecompositionTest.php
View File

@ -30,7 +30,7 @@ class EigenvalueDecompositionTest extends \PHPUnit\Framework\TestCase
$eig = new EigenvalueDecomposition($A);
self::assertTrue($eig->isSymmetric());
self::assertEquals([0, 2, 5], $eig->getRealEigenvalues()->toArray(), '', 0.2);
self::assertEqualsWithDelta([0, 2, 5], $eig->getRealEigenvalues()->toArray(), 0.2);
self::assertEquals([
[0, 2/sqrt(6), 1/sqrt(3)],
@ -57,7 +57,7 @@ class EigenvalueDecompositionTest extends \PHPUnit\Framework\TestCase
$eig = new EigenvalueDecomposition($A);
self::assertFalse($eig->isSymmetric());
self::assertEquals([-5, 3, 6], $eig->getRealEigenvalues()->toArray(), '', 0.2);
self::assertEqualsWithDelta([-5, 3, 6], $eig->getRealEigenvalues()->toArray(), 0.2);
self::assertEquals([
[-sqrt(2/3), sqrt(2/7), -1/sqrt(293)],

2
tests/Math/Matrix/LUDecompositionTest.php
View File

@ -45,7 +45,7 @@ class LUDecompositionTest extends \PHPUnit\Framework\TestCase
$vec = new Vector();
$vec->setMatrix([[40], [49], [28]]);
self::assertTrue($lu->isNonSingular());
self::assertEquals([[1], [2], [3]], $lu->solve($vec)->toArray(), '', 0.2);
self::assertEqualsWithDelta([[1], [2], [3]], $lu->solve($vec)->toArray(), 0.2);
self::assertEquals([0, 1, 2], $lu->getPivot());
}

2
tests/Math/Matrix/MatrixTest.php
View File

@ -124,7 +124,7 @@ class MatrixTest extends \PHPUnit\Framework\TestCase
$vec = new Vector();
$vec->setMatrix([[40], [49], [28]]);
self::assertEquals([[1], [2], [3]], $A->solve($vec)->toArray(), '', 0.2);
self::assertEqualsWithDelta([[1], [2], [3]], $A->solve($vec)->toArray(), 0.2);
}
public function testRank() : void

2
tests/Math/Matrix/QRDecompositionTest.php
View File

@ -78,6 +78,6 @@ class QRDecompositionTest extends \PHPUnit\Framework\TestCase
$vec = new Vector();
$vec->setMatrix([[40], [49], [28]]);
self::assertEquals([[1], [2], [3]], $QR->solve($vec)->toArray(), '', 0.2);
self::assertEqualsWithDelta([[1], [2], [3]], $QR->solve($vec)->toArray(), 0.2);
}
}

2
tests/Math/Number/ComplexTest.php
View File

@ -95,7 +95,7 @@ class ComplexTest extends \PHPUnit\Framework\TestCase
{
$cpl = new Complex(4, 3);
self::assertEquals(5, $cpl->abs(), '', 0.01);
self::assertEqualsWithDelta(5, $cpl->abs(), 0.01);
}
public function testSqrt() : void

4
tests/Math/Parser/EvaluatorTest.php
View File

@ -19,8 +19,8 @@ class EvaluatorTest extends \PHPUnit\Framework\TestCase
{
public function testBasicEvaluation() : void
{
self::assertEquals(4.5, Evaluator::evaluate('3 + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3 + 1.5'), '', 2);
self::assertEquals(4.5, Evaluator::evaluate('3+4*2/(1-5)^2^3+1.5'), '', 2);
self::assertEqualsWithDelta(4.5, Evaluator::evaluate('3 + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3 + 1.5'), 2);
self::assertEqualsWithDelta(4.5, Evaluator::evaluate('3+4*2/(1-5)^2^3+1.5'), 2);
self::assertEquals(null, Evaluator::evaluate('invalid'));
self::assertEquals(null, Evaluator::evaluate('3+4*2/(1-5^2^3+1.5'));
}

22
tests/Math/Statistic/AverageTest.php
View File

@ -24,16 +24,16 @@ class AverageTest extends \PHPUnit\Framework\TestCase
public function testAngleMean() : void
{
self::assertEquals(-90, Average::angleMean([90.0, 180.0, 270.0, 360.0]), '', 0.01);
self::assertEquals(9.999999999999977, Average::angleMean([370.0]), '', 0.01);
self::assertEqualsWithDelta(-90, Average::angleMean([90.0, 180.0, 270.0, 360.0]), 0.01);
self::assertEqualsWithDelta(9.999999999999977, Average::angleMean([370.0]), 0.01);
self::assertEquals(270, Average::angleMean2([90.0, 180.0, 270.0, 360.0]), '', 0.01);
self::assertEquals(9.999999999999977, Average::angleMean2([370.0]), '', 0.01);
self::assertEqualsWithDelta(270, Average::angleMean2([90.0, 180.0, 270.0, 360.0]), 0.01);
self::assertEqualsWithDelta(9.999999999999977, Average::angleMean2([370.0]), 0.01);
}
public function testArithmeticMean() : void
{
self::assertEquals(4, Average::arithmeticMean([1, 2, 3, 4, 5, 6, 7]), '', 0.01);
self::assertEqualsWithDelta(4, Average::arithmeticMean([1, 2, 3, 4, 5, 6, 7]), 0.01);
}
public function testWeightedAverage() : void
@ -46,12 +46,12 @@ class AverageTest extends \PHPUnit\Framework\TestCase
public function testGeometricMean() : void
{
self::assertEquals(3.3800151591413, Average::geometricMean([1, 2, 3, 4, 5, 6, 7]), '', 0.01);
self::assertEqualsWithDelta(3.3800151591413, Average::geometricMean([1, 2, 3, 4, 5, 6, 7]), 0.01);
}
public function testHarmonicMean() : void
{
self::assertEquals(2.6997245179063, Average::harmonicMean([1, 2, 3, 4, 5, 6, 7]), '', 0.01);
self::assertEqualsWithDelta(2.6997245179063, Average::harmonicMean([1, 2, 3, 4, 5, 6, 7]), 0.01);
}
public function testMovingAverage() : void
@ -63,7 +63,7 @@ class AverageTest extends \PHPUnit\Framework\TestCase
$average = [66.39, 66.03, 65.79, 65.6, 65.24, 64.8, 64.46, 63.94, 63.3, 62.87, 62.4];
self::assertEquals($average, Average::totalMovingAverage($data, 10), '', 0.1);
self::assertEqualsWithDelta($average, Average::totalMovingAverage($data, 10), 0.1);
}
public function testInvalidWeightedAverageDimension() : void
@ -96,12 +96,12 @@ class AverageTest extends \PHPUnit\Framework\TestCase
public function testMode() : void
{
self::assertEquals(2, Average::mode([1, 2, 2, 3, 4, 4, 2]), '', 0.01);
self::assertEqualsWithDelta(2, Average::mode([1, 2, 2, 3, 4, 4, 2]), 0.01);
}
public function testMedia() : void
{
self::assertEquals(4, Average::median([1, 2, 3, 4, 5, 6, 7]), '', 0.01);
self::assertEquals(3.5, Average::median([1, 2, 3, 4, 5, 6]), '', 0.01);
self::assertEqualsWithDelta(4, Average::median([1, 2, 3, 4, 5, 6, 7]), 0.01);
self::assertEqualsWithDelta(3.5, Average::median([1, 2, 3, 4, 5, 6]), 0.01);
}
}

8
tests/Math/Statistic/CorrelationTest.php
View File

@ -37,8 +37,8 @@ class CorrelationTest extends \PHPUnit\Framework\TestCase
51, 20, 65, 45, 87, 68, 36, 31, 79, 7, 95, 37
];
self::assertEquals(0.022, Correlation::autocorrelationCoefficient($data, 1), '', 0.01);
self::assertEquals(0.098, Correlation::autocorrelationCoefficient($data, 2), '', 0.01);
self::assertEqualsWithDelta(0.022, Correlation::autocorrelationCoefficient($data, 1), 0.01);
self::assertEqualsWithDelta(0.098, Correlation::autocorrelationCoefficient($data, 2), 0.01);
}
public function testPortmanteauTest() : void
@ -55,7 +55,7 @@ class CorrelationTest extends \PHPUnit\Framework\TestCase
$correlations[] = Correlation::autocorrelationCoefficient($data, $i + 1);
}
self::assertEquals(16.46, Correlation::boxPierceTest($correlations, 24, 48), '', 0.01);
self::assertEquals(24.92, Correlation::ljungBoxTest($correlations, 24, 48), '', 0.01);
self::assertEqualsWithDelta(16.46, Correlation::boxPierceTest($correlations, 24, 48), 0.01);
self::assertEqualsWithDelta(24.92, Correlation::ljungBoxTest($correlations, 24, 48), 0.01);
}
}

10
tests/Math/Statistic/Forecast/ErrorTest.php
View File

@ -38,7 +38,7 @@ class ErrorTest extends \PHPUnit\Framework\TestCase
public function testErrorPercentage() : void
{
self::assertEquals(300 / 1000, Error::getPercentageError(300, 1000), '', 0.01);
self::assertEqualsWithDelta(300 / 1000, Error::getPercentageError(300, 1000), 0.01);
self::assertEquals(
[
(400 - 300) / 400,
@ -65,9 +65,9 @@ class ErrorTest extends \PHPUnit\Framework\TestCase
500 - -300
];
self::assertEquals(300, Error::getMeanAbsoulteError($errors), '', 0.01);
self::assertEquals(125000, Error::getMeanSquaredError($errors), '', 0.01);
self::assertEquals(406.2019, Error::getRootMeanSquaredError($errors), '', 0.01);
self::assertEqualsWithDelta(300, Error::getMeanAbsoulteError($errors), 0.01);
self::assertEqualsWithDelta(125000, Error::getMeanSquaredError($errors), 0.01);
self::assertEqualsWithDelta(406.2019, Error::getRootMeanSquaredError($errors), 0.01);
}
public function testMASE() : void
@ -85,7 +85,7 @@ class ErrorTest extends \PHPUnit\Framework\TestCase
$errors = Error::getForecastErrorArray($observed, $forecast);
$scaledErrors = Error::getScaledErrorArray($errors, $observed);
self::assertEquals(0.0983, Error::getMeanAbsoluteScaledError($scaledErrors), '', 0.01);
self::assertEqualsWithDelta(0.0983, Error::getMeanAbsoluteScaledError($scaledErrors), 0.01);
}
public function testScaledError() : void

4
tests/Math/Statistic/Forecast/Regression/LevelLevelRegressionTest.php
View File

@ -30,7 +30,7 @@ class LevelLevelRegressionTest extends \PHPUnit\Framework\TestCase
public function testRegression() : void
{
self::assertEquals(['b0' => 3, 'b1' => 4], $this->reg, '', 0.2);
self::assertEqualsWithDelta(['b0' => 3, 'b1' => 4], $this->reg, 0.2);
}
public function testSlope() : void
@ -40,7 +40,7 @@ class LevelLevelRegressionTest extends \PHPUnit\Framework\TestCase
public function testElasticity() : void
{
self::assertEquals(0.7273, LevelLevelRegression::getElasticity($this->reg['b1'], 11, 2), '', 0.01);
self::assertEqualsWithDelta(0.7273, LevelLevelRegression::getElasticity($this->reg['b1'], 11, 2), 0.01);
}
public function testInvalidDimension() : void

6
tests/Math/Statistic/Forecast/Regression/LevelLogRegressionTest.php
View File

@ -30,19 +30,19 @@ class LevelLogRegressionTest extends \PHPUnit\Framework\TestCase
public function testRegression() : void
{
self::assertEquals(['b0' => 1, 'b1' => 1], $this->reg, '', 0.2);
self::assertEqualsWithDelta(['b0' => 1, 'b1' => 1], $this->reg, 0.2);
}
public function testSlope() : void
{
$x = 2;
self::assertEquals($this->reg['b1'] / $x, LevelLogRegression::getSlope($this->reg['b1'], 0, $x), '', 0.2);
self::assertEqualsWithDelta($this->reg['b1'] / $x, LevelLogRegression::getSlope($this->reg['b1'], 0, $x), 0.2);
}
public function testElasticity() : void
{
$y = 3;
self::assertEquals($this->reg['b1'] / $y, LevelLogRegression::getElasticity($this->reg['b1'], $y, 0), '', 0.2);
self::assertEqualsWithDelta($this->reg['b1'] / $y, LevelLogRegression::getElasticity($this->reg['b1'], $y, 0), 0.2);
}
public function testInvalidDimension() : void

6
tests/Math/Statistic/Forecast/Regression/LogLevelRegressionTest.php
View File

@ -30,19 +30,19 @@ class LogLevelRegressionTest extends \PHPUnit\Framework\TestCase
public function testRegression() : void
{
self::assertEquals(['b0' => -1, 'b1' => 2], $this->reg, '', 0.2);
self::assertEqualsWithDelta(['b0' => -1, 'b1' => 2], $this->reg, 0.2);
}
public function testSlope() : void
{
$y = 3;
self::assertEquals($this->reg['b1'] * $y, LogLevelRegression::getSlope($this->reg['b1'], $y, 0), '', 0.2);
self::assertEqualsWithDelta($this->reg['b1'] * $y, LogLevelRegression::getSlope($this->reg['b1'], $y, 0), 0.2);
}
public function testElasticity() : void
{
$x = 2;
self::assertEquals($this->reg['b1'] * $x, LogLevelRegression::getElasticity($this->reg['b1'], 0, $x), '', 0.2);
self::assertEqualsWithDelta($this->reg['b1'] * $x, LogLevelRegression::getElasticity($this->reg['b1'], 0, $x), 0.2);
}
public function testInvalidDimension() : void

6
tests/Math/Statistic/Forecast/Regression/LogLogRegressionTest.php
View File

@ -30,19 +30,19 @@ class LogLogRegressionTest extends \PHPUnit\Framework\TestCase
public function testRegression() : void
{
self::assertEquals(['b0' => 2, 'b1' => 3], $this->reg, '', 0.2);
self::assertEqualsWithDelta(['b0' => 2, 'b1' => 3], $this->reg, 0.2);
}
public function testSlope() : void
{
$y = 3;
$x = 2;
self::assertEquals($this->reg['b1'] * $y / $x, LogLogRegression::getSlope($this->reg['b1'], $y, $x), '', 0.2);
self::assertEqualsWithDelta($this->reg['b1'] * $y / $x, LogLogRegression::getSlope($this->reg['b1'], $y, $x), 0.2);
}
public function testElasticity() : void
{
self::assertEquals($this->reg['b1'], LogLogRegression::getElasticity($this->reg['b1'], 0, 0), '', 0.2);
self::assertEqualsWithDelta($this->reg['b1'], LogLogRegression::getElasticity($this->reg['b1'], 0, 0), 0.2);
}
public function testInvalidDimension() : void

14
tests/Math/Statistic/MeasureOfDispersionTest.php
View File

@ -24,7 +24,7 @@ class MeasureOfDispersionTest extends \PHPUnit\Framework\TestCase
public function testStandardDeviation() : void
{
self::assertEquals(2.160246, MeasureOfDispersion::standardDeviation([1, 2, 3, 4, 5, 6, 7]), '', 0.01);
self::assertEqualsWithDelta(2.160246, MeasureOfDispersion::standardDeviation([1, 2, 3, 4, 5, 6, 7]), 0.01);
}
public function testEmpiricalCovariance() : void
@ -40,20 +40,20 @@ class MeasureOfDispersionTest extends \PHPUnit\Framework\TestCase
public function testVariance() : void
{
self::assertEquals(6219.9, MeasureOfDispersion::sampleVariance([3, 21, 98, 203, 17, 9]), '', 0.01);
self::assertEquals(5183.25, MeasureOfDispersion::empiricalVariance([3, 21, 98, 203, 17, 9]), '', 0.01);
self::assertEqualsWithDelta(6219.9, MeasureOfDispersion::sampleVariance([3, 21, 98, 203, 17, 9]), 0.01);
self::assertEqualsWithDelta(5183.25, MeasureOfDispersion::empiricalVariance([3, 21, 98, 203, 17, 9]), 0.01);
}
public function testDeviation() : void
{
self::assertEquals(0.0, MeasureOfDispersion::meanDeviation([3, 4, 5, 9, 7, 8, 9]), '', 0.01);
self::assertEquals(2.0816, MeasureOfDispersion::meanAbsoluteDeviation([3, 4, 5, 9, 7, 8, 9]), '', 0.01);
self::assertEquals((12.96 + 2.56 + 0.36 + 5.76 + 11.56) / 5, MeasureOfDispersion::squaredMeanDeviation([1, 3, 4, 7, 8]), '', 0.01);
self::assertEqualsWithDelta(0.0, MeasureOfDispersion::meanDeviation([3, 4, 5, 9, 7, 8, 9]), 0.01);
self::assertEqualsWithDelta(2.0816, MeasureOfDispersion::meanAbsoluteDeviation([3, 4, 5, 9, 7, 8, 9]), 0.01);
self::assertEqualsWithDelta((12.96 + 2.56 + 0.36 + 5.76 + 11.56) / 5, MeasureOfDispersion::squaredMeanDeviation([1, 3, 4, 7, 8]), 0.01);
}
public function testEmpiricalVariationCoefficient() : void
{
self::assertEquals(0.5400, MeasureOfDispersion::empiricalVariationCoefficient([1, 2, 3, 4, 5, 6, 7]), '', 0.01);
self::assertEqualsWithDelta(0.5400, MeasureOfDispersion::empiricalVariationCoefficient([1, 2, 3, 4, 5, 6, 7]), 0.01);
}
public function testIQR() : void

36
tests/Math/Stochastic/Distribution/BernoulliDistributionTest.php
View File

@ -19,34 +19,34 @@ class BernoulliDistributionTest extends \PHPUnit\Framework\TestCase
{
public function testPmf() : void
{
self::assertEquals(0.3, BernoulliDistribution::getPmf(0.7, 0), '', 0.01);
self::assertEquals(0.7, BernoulliDistribution::getPmf(0.7, 1), '', 0.01);
self::assertEqualsWithDelta(0.3, BernoulliDistribution::getPmf(0.7, 0), 0.01);
self::assertEqualsWithDelta(0.7, BernoulliDistribution::getPmf(0.7, 1), 0.01);
}
public function testMode() : void
{
self::assertEquals(1, BernoulliDistribution::getMode(0.7), '', 0.01);
self::assertEquals(0, BernoulliDistribution::getMode(0.5), '', 0.01);
self::assertEquals(0, BernoulliDistribution::getMode(0.3), '', 0.01);
self::assertEqualsWithDelta(1, BernoulliDistribution::getMode(0.7), 0.01);
self::assertEqualsWithDelta(0, BernoulliDistribution::getMode(0.5), 0.01);
self::assertEqualsWithDelta(0, BernoulliDistribution::getMode(0.3), 0.01);
}
public function testMean() : void
{
self::assertEquals(0.4, BernoulliDistribution::getMean(0.4), '', 0.01);
self::assertEqualsWithDelta(0.4, BernoulliDistribution::getMean(0.4), 0.01);
}
public function testCdf() : void
{
self::assertEquals(0, BernoulliDistribution::getCdf(0.4, -2), '', 0.01);
self::assertEquals(1, BernoulliDistribution::getCdf(0.4, 2), '', 0.01);
self::assertEquals(0.3, BernoulliDistribution::getCdf(0.7, 0.4), '', 0.01);
self::assertEqualsWithDelta(0, BernoulliDistribution::getCdf(0.4, -2), 0.01);
self::assertEqualsWithDelta(1, BernoulliDistribution::getCdf(0.4, 2), 0.01);
self::assertEqualsWithDelta(0.3, BernoulliDistribution::getCdf(0.7, 0.4), 0.01);
}
public function testMedian() : void
{
self::assertEquals(0.5, BernoulliDistribution::getMedian(0.5), '', 0.01);
self::assertEquals(1, BernoulliDistribution::getMedian(0.7), '', 0.01);
self::assertEquals(0, BernoulliDistribution::getMedian(0.3), '', 0.01);
self::assertEqualsWithDelta(0.5, BernoulliDistribution::getMedian(0.5), 0.01);
self::assertEqualsWithDelta(1, BernoulliDistribution::getMedian(0.7), 0.01);
self::assertEqualsWithDelta(0, BernoulliDistribution::getMedian(0.3), 0.01);
}
public function testVariance() : void
@ -54,7 +54,7 @@ class BernoulliDistributionTest extends \PHPUnit\Framework\TestCase
$p = 0.3;
$q = 1 - $p;
self::assertEquals($p * $q, BernoulliDistribution::getVariance($p), '', 0.01);
self::assertEqualsWithDelta($p * $q, BernoulliDistribution::getVariance($p), 0.01);
}
public function testSkewness() : void
@ -62,7 +62,7 @@ class BernoulliDistributionTest extends \PHPUnit\Framework\TestCase
$p = 0.3;
$q = 1 - $p;
self::assertEquals((1 - 2 * $p) / \sqrt($p * $q), BernoulliDistribution::getSkewness($p), '', 0.01);
self::assertEqualsWithDelta((1 - 2 * $p) / \sqrt($p * $q), BernoulliDistribution::getSkewness($p), 0.01);
}
public function testExKurtosis() : void
@ -70,7 +70,7 @@ class BernoulliDistributionTest extends \PHPUnit\Framework\TestCase
$p = 0.3;
$q = 1 - $p;
self::assertEquals((1 - 6 * $p * $q) / ($p * $q), BernoulliDistribution::getExKurtosis($p), '', 0.01);
self::assertEqualsWithDelta((1 - 6 * $p * $q) / ($p * $q), BernoulliDistribution::getExKurtosis($p), 0.01);
}
public function testEntropy() : void
@ -78,7 +78,7 @@ class BernoulliDistributionTest extends \PHPUnit\Framework\TestCase
$p = 0.3;
$q = 1 - $p;
self::assertEquals(-$q * \log($q) - $p * \log($p), BernoulliDistribution::getEntropy($p), '', 0.01);
self::assertEqualsWithDelta(-$q * \log($q) - $p * \log($p), BernoulliDistribution::getEntropy($p), 0.01);
}
public function testMgf() : void
@ -87,7 +87,7 @@ class BernoulliDistributionTest extends \PHPUnit\Framework\TestCase
$q = 1 - $p;
$t = 2;
self::assertEquals($q + $p * \exp($t), BernoulliDistribution::getMgf($p, $t), '', 0.01);
self::assertEqualsWithDelta($q + $p * \exp($t), BernoulliDistribution::getMgf($p, $t), 0.01);
}
public function testFisherInformation() : void
@ -95,6 +95,6 @@ class BernoulliDistributionTest extends \PHPUnit\Framework\TestCase
$p = 0.3;
$q = 1 - $p;
self::assertEquals(1 / ($p * $q), BernoulliDistribution::getFisherInformation($p), '', 0.01);
self::assertEqualsWithDelta(1 / ($p * $q), BernoulliDistribution::getFisherInformation($p), 0.01);
}
}

20
tests/Math/Stochastic/Distribution/BinomialDistributionTest.php
View File

@ -23,7 +23,7 @@ class BinomialDistributionTest extends \PHPUnit\Framework\TestCase
$n = 20;
$k = 7;
self::assertEquals(0.1659, BinomialDistribution::getPmf($n, $k, $p), '', 0.01);
self::assertEqualsWithDelta(0.1659, BinomialDistribution::getPmf($n, $k, $p), 0.01);
}
public function testCdf() : void
@ -32,7 +32,7 @@ class BinomialDistributionTest extends \PHPUnit\Framework\TestCase
$n = 20;
$k = 7;
self::assertEquals(0.25, BinomialDistribution::getCdf($n, $k, $p), '', 0.01);
self::assertEqualsWithDelta(0.25, BinomialDistribution::getCdf($n, $k, $p), 0.01);
}
public function testMean() : void
@ -40,7 +40,7 @@ class BinomialDistributionTest extends \PHPUnit\Framework\TestCase
$n = 20;
$p = 0.4;
self::assertEquals($n * $p, BinomialDistribution::getMean($n, $p), '', 0.01);
self::assertEqualsWithDelta($n * $p, BinomialDistribution::getMean($n, $p), 0.01);
}
public function testMedian() : void
@ -48,7 +48,7 @@ class BinomialDistributionTest extends \PHPUnit\Framework\TestCase
$n = 20;
$p = 0.4;
self::assertEquals(\floor($n * $p), BinomialDistribution::getMedian($n, $p), '', 0.01);
self::assertEqualsWithDelta(\floor($n * $p), BinomialDistribution::getMedian($n, $p), 0.01);
}
public function testMode() : void
@ -56,7 +56,7 @@ class BinomialDistributionTest extends \PHPUnit\Framework\TestCase
$n = 20;
$p = 0.4;
self::assertEquals(\floor(($n + 1) * $p), BinomialDistribution::getMode($n, $p), '', 0.01);
self::assertEqualsWithDelta(\floor(($n + 1) * $p), BinomialDistribution::getMode($n, $p), 0.01);
}
public function testVariance() : void
@ -64,7 +64,7 @@ class BinomialDistributionTest extends \PHPUnit\Framework\TestCase
$n = 20;
$p = 0.4;
self::assertEquals($n * $p * (1 - $p), BinomialDistribution::getVariance($n, $p), '', 0.01);
self::assertEqualsWithDelta($n * $p * (1 - $p), BinomialDistribution::getVariance($n, $p), 0.01);
}
public function testSkewness() : void
@ -72,7 +72,7 @@ class BinomialDistributionTest extends \PHPUnit\Framework\TestCase
$n = 20;
$p = 0.4;
self::assertEquals((1 - 2 * $p) / \sqrt($n * $p * (1 - $p)), BinomialDistribution::getSkewness($n, $p), '', 0.01);
self::assertEqualsWithDelta((1 - 2 * $p) / \sqrt($n * $p * (1 - $p)), BinomialDistribution::getSkewness($n, $p), 0.01);
}
public function testExKurtosis() : void
@ -80,7 +80,7 @@ class BinomialDistributionTest extends \PHPUnit\Framework\TestCase
$n = 20;
$p = 0.4;
self::assertEquals((1 - 6 * $p * (1 - $p)) / ($n * $p * (1 - $p)), BinomialDistribution::getExKurtosis($n, $p), '', 0.01);
self::assertEqualsWithDelta((1 - 6 * $p * (1 - $p)) / ($n * $p * (1 - $p)), BinomialDistribution::getExKurtosis($n, $p), 0.01);
}
public function testMgf() : void
@ -89,7 +89,7 @@ class BinomialDistributionTest extends \PHPUnit\Framework\TestCase
$p = 0.4;
$t = 3;
self::assertEquals((1 - $p + $p * \exp($t)) ** $n, BinomialDistribution::getMgf($n, $t, $p), '', 0.01);
self::assertEqualsWithDelta((1 - $p + $p * \exp($t)) ** $n, BinomialDistribution::getMgf($n, $t, $p), 0.01);
}
public function testFisherInformation() : void
@ -97,6 +97,6 @@ class BinomialDistributionTest extends \PHPUnit\Framework\TestCase
$n = 20;
$p = 0.4;
self::assertEquals($n / ($p * (1 - $p)), BinomialDistribution::getFisherInformation($n, $p), '', 0.01);
self::assertEqualsWithDelta($n / ($p * (1 - $p)), BinomialDistribution::getFisherInformation($n, $p), 0.01);
}
}

6
tests/Math/Stochastic/Distribution/CauchyDistributionTest.php
View File

@ -29,7 +29,7 @@ class CauchyDistributionTest extends \PHPUnit\Framework\TestCase
$x0 = 0.5;
$gamma = 2;
self::assertEquals(0.14979, CauchyDistribution::getPdf($x, $x0, $gamma), '', 0.01);
self::assertEqualsWithDelta(0.14979, CauchyDistribution::getPdf($x, $x0, $gamma), 0.01);
}
public function testCdf() : void
@ -38,13 +38,13 @@ class CauchyDistributionTest extends \PHPUnit\Framework\TestCase
$x0 = 0.5;
$gamma = 2;
self::assertEquals(0.57798, CauchyDistribution::getCdf($x, $x0, $gamma), '', 0.01);
self::assertEqualsWithDelta(0.57798, CauchyDistribution::getCdf($x, $x0, $gamma), 0.01);
}
public function testEntropy() : void
{
$gamma = 1.5;
self::assertEquals(\log(4 * M_PI * $gamma), CauchyDistribution::getEntropy($gamma), '', 0.01);
self::assertEqualsWithDelta(\log(4 * M_PI * $gamma), CauchyDistribution::getEntropy($gamma), 0.01);
}
}

2
tests/Math/Stochastic/Distribution/ChiSquaredDistributionTest.php
View File

@ -28,7 +28,7 @@ class ChiSquaredDistributionTest extends \PHPUnit\Framework\TestCase
$test = ChiSquaredDistribution::testHypothesis($observed, $expected, $a);
self::assertEquals(8.46, $test['Chi2'], '', 0.1);
self::assertEqualsWithDelta(8.46, $test['Chi2'], 0.1);
self::assertNotEquals(0, $test['P']);
self::assertFalse($test['H0']);
self::assertEquals(2, $test['df']);

4
tests/Math/Stochastic/Distribution/ExponentialDistributionTest.php
View File

@ -22,7 +22,7 @@ class ExponentialDistributionTest extends \PHPUnit\Framework\TestCase
$lambda = 0.1;
$x = 7;
self::assertEquals(0.049659, ExponentialDistribution::getPdf($x, $lambda), '', 0.01);
self::assertEqualsWithDelta(0.049659, ExponentialDistribution::getPdf($x, $lambda), 0.01);
}
public function testCdf() : void
@ -30,7 +30,7 @@ class ExponentialDistributionTest extends \PHPUnit\Framework\TestCase
$lambda = 0.1;
$x = 7;
self::assertEquals(0.5034, ExponentialDistribution::getCdf($x, $lambda), '', 0.01);
self::assertEqualsWithDelta(0.5034, ExponentialDistribution::getCdf($x, $lambda), 0.01);
}
public function testMean() : void

4
tests/Math/Stochastic/Distribution/GeometricDistributionTest.php
View File

@ -22,7 +22,7 @@ class GeometricDistributionTest extends \PHPUnit\Framework\TestCase
$p = 0.2;
$k = 4;
self::assertEquals(0.1024, GeometricDistribution::getPmf($p, $k), '', 0.01);
self::assertEqualsWithDelta(0.1024, GeometricDistribution::getPmf($p, $k), 0.01);
}
public function testCdf() : void
@ -31,7 +31,7 @@ class GeometricDistributionTest extends \PHPUnit\Framework\TestCase
$k = 6;
// P(X > 6) = P(X <= 6) => 1 - CDF
self::assertEquals(0.262, 1 - GeometricDistribution::getCdf($p, $k), '', 0.01);
self::assertEqualsWithDelta(0.262, 1 - GeometricDistribution::getCdf($p, $k), 0.01);
}
public function testMode() : void

4
tests/Math/Stochastic/Distribution/LaplaceDistributionTest.php
View File

@ -23,7 +23,7 @@ class LaplaceDistributionTest extends \PHPUnit\Framework\TestCase
$m = 1;
$b = 0.7;
self::assertEquals(0.17118, LaplaceDistribution::getPdf($x, $m, $b), '', 0.01);
self::assertEqualsWithDelta(0.17118, LaplaceDistribution::getPdf($x, $m, $b), 0.01);
}
public function testCdf() : void
@ -32,7 +32,7 @@ class LaplaceDistributionTest extends \PHPUnit\Framework\TestCase
$m = 1;
$b = 0.7;
self::assertEquals(0.88017, LaplaceDistribution::getCdf($x, $m, $b), '', 0.01);
self::assertEqualsWithDelta(0.88017, LaplaceDistribution::getCdf($x, $m, $b), 0.01);
}
public function testMode() : void

4
tests/Math/Stochastic/Distribution/NormalDistributionTest.php
View File

@ -23,7 +23,7 @@ class NormalDistributionTest extends \PHPUnit\Framework\TestCase
$sig = 1;
$x = 3;
self::assertEquals(0.24197, NormalDistribution::getPdf($x, $mean, $sig), '', 0.01);
self::assertEqualsWithDelta(0.24197, NormalDistribution::getPdf($x, $mean, $sig), 0.01);
}
public function testCdf() : void
@ -32,7 +32,7 @@ class NormalDistributionTest extends \PHPUnit\Framework\TestCase
$sig = 1;
$x = 3;
self::assertEquals(0.84134, NormalDistribution::getCdf($x, $mean, $sig), '', 0.01);
self::assertEqualsWithDelta(0.84134, NormalDistribution::getCdf($x, $mean, $sig), 0.01);
}
public function testMean() : void

6
tests/Math/Stochastic/Distribution/PoissonDistributionTest.php
View File

@ -22,7 +22,7 @@ class PoissonDistributionTest extends \PHPUnit\Framework\TestCase
$k = 4;
$l = 3;
self::assertEquals(0.16803, PoissonDistribution::getPmf(4, 3), '', 0.01);
self::assertEqualsWithDelta(0.16803, PoissonDistribution::getPmf(4, 3), 0.01);
}
public function testCdf() : void
@ -30,14 +30,14 @@ class PoissonDistributionTest extends \PHPUnit\Framework\TestCase
$k = 4;
$l = 3;
self::assertEquals(0.81526, PoissonDistribution::getCdf(4, 3), '', 0.01);
self::assertEqualsWithDelta(0.81526, PoissonDistribution::getCdf(4, 3), 0.01);
}
public function testMode() : void
{
$l = 4.6;
self::assertEquals(4, PoissonDistribution::getMode($l), '', 0.01);
self::assertEqualsWithDelta(4, PoissonDistribution::getMode($l), 0.01);
}
public function testMean() : void