From 797b1c1f0005d8ff41df2b8a46432f650e228e6f Mon Sep 17 00:00:00 2001 From: Dennis Eichhorn Date: Wed, 28 Feb 2018 20:37:54 +0100 Subject: [PATCH] Added depreciation+tests --- Business/Finance/Depreciation.php | 252 ++++++++++++++++++-- DataStorage/Database/DataMapperAbstract.php | 2 +- tests/Business/Finance/DepreciationTest.php | 57 ++++- 3 files changed, 286 insertions(+), 25 deletions(-) diff --git a/Business/Finance/Depreciation.php b/Business/Finance/Depreciation.php index e1eb79d13..069801c6d 100644 --- a/Business/Finance/Depreciation.php +++ b/Business/Finance/Depreciation.php @@ -14,53 +14,261 @@ declare(strict_types=1); namespace phpOMS\Business\Finance; +/** + * Depreciation class. + * + * @package phpOMS\Business\Finance + * @license OMS License 1.0 + * @link http://website.orange-management.de + * @since 1.0.0 + */ class Depreciation { - public static function getLinearDepreciationRate(float $start, int $duration) : float + /** + * Calculate linear depretiation rate + * + * @param float $start Value to depreciate + * @param int $duration Useful life time + * + * @return float + * + * @since 1.0.0 + */ + public static function getStraightLineDepreciation(float $start, int $duration) : float { return $start / $duration; } - public static function getLinearDepreciationResidualInT(float $start, int $duration, int $t) : float + /** + * Calculate the residual after a specific amount of time + * + * @param float $start Value to depreciate + * @param int $duration Useful life time + * @param int $t Time passed + * + * @return float + * + * @since 1.0.0 + */ + public static function getStraightLineResidualInT(float $start, int $duration, int $t) : float { - return $start - self::getLinearDepreciationRate($start, $duration) * $t; + return $start - self::getStraightLineDepreciation($start, $duration) * $t; } - public static function getArithmeticProgressivDepreciationRate(float $start, int $duration) : float + /** + * Calculate the degression factor + * + * This factor is the amount of years + * + * @param float $start Value to depreciate (reduced by residual value if required) + * @param float $residual Residual value + * @param int $duration Useful life time + * + * @return float + * + * @since 1.0.0 + */ + public static function getArithmeticDegressivDepreciationFactor(float $start, float $residual, int $duration) : float { - return $start / ($duration * ($duration + 1) / 2); + return ($start - $residual) / ($duration * ($duration + 1) / 2); } - public static function getArithmeticProgressivDepreciationInT(float $start, int $duration, int $t) : float + /** + * Calculate the depreciation value in period t + * + * @param float $start Value to depreciate (reduced by residual value if required) + * @param float $residual Residual value + * @param int $duration Useful life time + * @param int $t Period + * + * @return float + * + * @since 1.0.0 + */ + public static function getArithmeticDegressivDepreciationInT(float $start, float $residual, int $duration, int $t) : float { - return $t * self::getArithmeticProgressivDepreciationRate($start, $duration); + return self::getArithmeticDegressivDepreciationFactor($start, $residual, $duration) * ($duration - $t + 1); } - public static function getArithmeticProgressivDepreciationResidualInT(float $start, int $duration, int $t) : float + /** + * Calculate the residual value after some periods + * + * @param float $start Value to depreciate (reduced by residual value if required) + * @param float $residual Residual value + * @param int $duration Useful life time + * @param int $t Passed periods + * + * @return float + * + * @since 1.0.0 + */ + public static function getArithmeticDegressivDepreciationResidualInT(float $start, float $residual, int $duration, int $t) : float { - return $start - self::getArithmeticProgressivDepreciationRate($start, $duration) * $t * ($t + 1) / 2; + $end = $start; + + for ($i = 1; $i <= $t; ++$i) { + $end -= self::getArithmeticDegressivDepreciationInT($start, $residual, $duration, $i); + } + + return $end; } + /** + * Calculate the progressiv factor + * + * @param float $start Value to depreciate (reduced by residual value if required) + * @param float $residual Residual value + * @param int $duration Useful life time + * + * @return float + * + * @since 1.0.0 + */ + public static function getArithmeticProgressivDepreciationFactor(float $start, float $residual, int $duration) : float + { + return ($start - $residual) / ($duration * ($duration + 1) / 2); + } + + /** + * Calculate the depreciation value in period t + * + * @param float $start Value to depreciate (reduced by residual value if required) + * @param float $residual Residual value + * @param int $duration Useful life time + * @param int $t Period + * + * @return float + * + * @since 1.0.0 + */ + public static function getArithmeticProgressivDepreciationInT(float $start, float $residual, int $duration, int $t) : float + { + return self::getArithmeticProgressivDepreciationFactor($start, $residual, $duration) * $t; + } + + /** + * Calculate the residual value after some periods + * + * @param float $start Value to depreciate (reduced by residual value if required) + * @param float $residual Residual value + * @param int $duration Useful life time + * @param int $t Passed periods + * + * @return float + * + * @since 1.0.0 + */ + public static function getArithmeticProgressivDepreciationResidualInT(float $start, float $residual, int $duration, int $t) : float + { + return $start - self::getArithmeticProgressivDepreciationFactor($start, $residual, $duration) * $t * ($t + 1) / 2; + } + + /** + * Calculate the depreciation rate + * + * @param float $start Value to depreciate (reduced by residual value if required) + * @param int $residual Residual value + * @param int $duration Useful life time + * + * @return float + * + * @since 1.0.0 + */ public static function getGeometicProgressivDepreciationRate(float $start, float $residual, int $duration) : float { return (1 - pow($residual / $start, 1 / $duration)); } + /** + * Calculate the depreciation value in a period + * + * @param float $start Value to depreciate (reduced by residual value if required) + * @param int $residual Residual value + * @param int $duration Useful life time + * @param int $t Period + * + * @return float + * + * @since 1.0.0 + */ + public static function getGeometicProgressivDepreciationInT(float $start, float $residual, int $duration, int $t) : float + { + $rate = self::getGeometicProgressivDepreciationRate($start, $residual, $duration); + + return $start * (1 - $rate) ** ($duration - $t) * $rate; + } + + /** + * Calculate the residual value after some periods + * + * @param float $start Value to depreciate (reduced by residual value if required) + * @param int $residual Residual value + * @param int $duration Useful life time + * @param int $t Period + * + * @return float + * + * @since 1.0.0 + */ + public static function getGeometicProgressivDepreciationResidualInT(float $start, float $residual, int $duration, int $t) : float + { + $end = $start; + + for ($i = 1; $i <= $t; ++$i) { + $end -= self::getGeometicProgressivDepreciationInT($start, $residual, $duration, $i); + } + + return $end; + } + + /** + * Calculate the depreciation rate + * + * @param float $start Value to depreciate (reduced by residual value if required) + * @param int $residual Residual value + * @param int $duration Useful life time + * + * @return float + * + * @since 1.0.0 + */ + public static function getGeometicDegressivDepreciationRate(float $start, float $residual, int $duration) : float + { + return (1 - pow($residual / $start, 1 / $duration)); + } + + /** + * Calculate the depreciation value in a period + * + * @param float $start Value to depreciate (reduced by residual value if required) + * @param int $residual Residual value + * @param int $duration Useful life time + * @param int $t Period + * + * @return float + * + * @since 1.0.0 + */ public static function getGeometicDegressivDepreciationInT(float $start, float $residual, int $duration, int $t) : float + { + $rate = self::getGeometicDegressivDepreciationRate($start, $residual, $duration); + return $start * (1 - $rate) ** ($t - 1) * $rate; + } + + /** + * Calculate the residual value after some periods + * + * @param float $start Value to depreciate (reduced by residual value if required) + * @param int $residual Residual value + * @param int $duration Useful life time + * @param int $t Period + * + * @return float + * + * @since 1.0.0 + */ + public static function getGeometicDegressivDepreciationResidualInT(float $start, float $residual, int $duration, int $t) : float { return $start * (1 - self::getGeometicDegressivDepreciationRate($start, $residual, $duration)) ** $t; } - - public static function getGeometicDegressivDepreciationResidualInT(float $start, float $residual, int $duration, int $t) : float - { - } - - public static function getGeometicProgressivDepreciationInT(float $start, float $residual, int $duration, int $t) : float - { - return $start * (1 - self::getGeometicProgressivDepreciationRate($start, $residual, $duration)) ** ($duration - $t + 1); - } - - public static function getGeometicProgressivDepreciationResidualInT(float $start, float $residual, int $duration, int $t) : float - { - } } diff --git a/DataStorage/Database/DataMapperAbstract.php b/DataStorage/Database/DataMapperAbstract.php index 45f2d4d96..8a82dffdd 100644 --- a/DataStorage/Database/DataMapperAbstract.php +++ b/DataStorage/Database/DataMapperAbstract.php @@ -2516,7 +2516,7 @@ class DataMapperAbstract implements DataMapperInterface } else { $limit = (int) ($request->getData('limit') ?? 1); $from = $request->getData('from') === null ? null : new \DateTime((string) $request->getData('from')); - $to = $request->getData('to') === null ? null : new \DateTime((string) $request->getData('to')); + $to = $request->getData('to') === null ? null : new \DateTime((string) $request->getData('to')); $query = static::getQuery(); $query->limit($limit); diff --git a/tests/Business/Finance/DepreciationTest.php b/tests/Business/Finance/DepreciationTest.php index e2570e8e2..d87b5a87e 100644 --- a/tests/Business/Finance/DepreciationTest.php +++ b/tests/Business/Finance/DepreciationTest.php @@ -17,8 +17,61 @@ use phpOMS\Business\Finance\Depreciation; class DepreciationTest extends \PHPUnit\Framework\TestCase { - public function testPlaceholder() + public function testStraightLine() { - self::markTestIncomplete(); + $start = 23280; + $duration = 6; + $t = 2; + + self::assertEquals(3880, Depreciation::getStraightLineDepreciation($start, $duration), '', 5); + self::assertEquals(23280 - 3880 * $t, Depreciation::getStraightLineResidualInT($start, $duration, $t), '', 5); + } + + public function testArithmeticDegressivDepreciation() + { + $start = 150000; + $residual = 18000; + $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); + } + + public function testArithmeticProgressivDepreciation() + { + $start = 40000; + $residual = 4700; + $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); + } + + public function testGeometicProgressivDepreciation() + { + $start = 150000; + $residual = 18000; + $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); + } + + public function testGeometicDegressivDepreciation() + { + $start = 150000; + $residual = 18000; + $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); } }