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

Added depreciation+tests

Browse Source
This commit is contained in:
Dennis Eichhorn 2018-02-28 20:37:54 +01:00
parent 1f4df655ad
commit 797b1c1f00
3 changed files with 286 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

252
Business/Finance/Depreciation.php
View File

@ -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
{
}
}

2
DataStorage/Database/DataMapperAbstract.php
View File

@ -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);

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

@ -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);
}
}