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

impl. tests

Browse Source
This commit is contained in:
Dennis Eichhorn 2020-09-27 16:49:19 +02:00
parent 290a997444
commit 96f8f25d6e
55 changed files with 1504 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Ai/Ocr/BasicOcr.php
View File

@ -161,7 +161,7 @@ final class BasicOcr
$labels = [];
for ($i = 0; $i < $numberOfLabels; ++$i) {
$read = \fread($fp, 4);
$read = \fread($fp, 1);
if (!$read) {
return [];
}

2
DataStorage/Cache/Connection/ConnectionAbstract.php
View File

@ -113,7 +113,7 @@ abstract class ConnectionAbstract implements ConnectionInterface
*/
public function getPort() : int
{
return (int) $this->dbdata['port'] ?? 0;
return (int) ($this->dbdata['port'] ?? 0);
}
/**

8
DataStorage/Cache/Connection/MemCached.php
View File

@ -144,13 +144,7 @@ final class MemCached extends ConnectionAbstract
*/
public function flush(int $expire = 0) : bool
{
if ($this->status !== CacheStatus::OK) {
return false;
}
$this->con->flush();
return true;
return $this->flushAll();
}
/**

8
DataStorage/Cache/Connection/RedisCache.php
View File

@ -172,13 +172,7 @@ final class RedisCache extends ConnectionAbstract
*/
public function flush(int $expire = 0) : bool
{
if ($this->status !== CacheStatus::OK) {
return false;
}
$this->con->flushDb();
return true;
return $this->flushAll();
}
/**

29
DataStorage/Session/ConsoleSession.php → DataStorage/Session/FileSession.php
View File

@ -17,7 +17,7 @@ namespace phpOMS\DataStorage\Session;
use phpOMS\DataStorage\LockException;
/**
* Console session class.
* File session class.
*
* @package phpOMS\DataStorage\Session
* @license OMS License 1.0
@ -26,7 +26,7 @@ use phpOMS\DataStorage\LockException;
*
* @SuppressWarnings(PHPMD.Superglobals)
*/
class ConsoleSession implements SessionInterface
class FileSession implements SessionInterface
{
/**
* Is session locked/already set.
@ -83,12 +83,16 @@ class ConsoleSession implements SessionInterface
$this->inactivityInterval = $inactivityInterval;
if (\session_status() !== \PHP_SESSION_ACTIVE) {
\session_set_cookie_params($liftetime, '/', '', false, true); // @codeCoverageIgnore
\session_start(); // @codeCoverageIgnore
if (\session_status() !== \PHP_SESSION_ACTIVE && !\headers_sent()) {
// @codeCoverageIgnoreStart
\session_set_cookie_params($liftetime, '/', '', false, true);
\session_start();
// @codeCoverageIgnoreEnd
}
if ($this->inactivityInterval > 0 && ($this->inactivityInterval + ($_SESSION['lastActivity'] ?? 0) < \time())) {
if ($this->inactivityInterval > 0
&& ($this->inactivityInterval + ($_SESSION['lastActivity'] ?? 0) < \time())
) {
$this->destroy(); // @codeCoverageIgnore
}
@ -143,12 +147,16 @@ class ConsoleSession implements SessionInterface
/**
* {@inheritdoc}
*/
public function save() : void
public function save() : bool
{
if (!$this->isLocked) {
$_SESSION = $this->sessionData;
\session_write_close();
if ($this->isLocked) {
return false;
}
$_SESSION = $this->sessionData;
\session_write_close();
return true;
}
/**
@ -202,6 +210,7 @@ class ConsoleSession implements SessionInterface
* Destruct session.
*
* @since 1.0.0
* @codeCoverageIgnore
*/
public function __destruct()
{

15
DataStorage/Session/ConsoleSessionHandler.php → DataStorage/Session/FileSessionHandler.php
View File

@ -15,7 +15,7 @@ declare(strict_types=1);
namespace phpOMS\DataStorage\Session;
/**
* Console session handler.
* File session handler.
*
* @package phpOMS\DataStorage\Session
* @license OMS License 1.0
@ -24,7 +24,7 @@ namespace phpOMS\DataStorage\Session;
*
* @SuppressWarnings(PHPMD.Superglobals)
*/
final class ConsoleSessionHandler implements \SessionHandlerInterface, \SessionIdInterface
final class FileSessionHandler implements \SessionHandlerInterface, \SessionIdInterface
{
/**
* File path for session
@ -44,6 +44,10 @@ final class ConsoleSessionHandler implements \SessionHandlerInterface, \SessionI
public function __construct(string $path)
{
$this->savePath = $path;
if (\realpath($path) === false) {
\mkdir($path, 0755, true);
}
}
/**
@ -55,7 +59,7 @@ final class ConsoleSessionHandler implements \SessionHandlerInterface, \SessionI
*/
public function create_sid() : string
{
return \session_create_id('console-');
return \session_create_id('s-');
}
/**
@ -71,11 +75,8 @@ final class ConsoleSessionHandler implements \SessionHandlerInterface, \SessionI
public function open($savePath, $sessionName)
{
$this->savePath = $savePath;
if (!\is_dir($this->savePath)) {
\mkdir($this->savePath, 0755);
}
return true;
return \is_dir($this->savePath);
}
/**

20
DataStorage/Session/HttpSession.php
View File

@ -79,12 +79,13 @@ final class HttpSession implements SessionInterface
}
if ($sid !== '') {
\session_id((string) $sid);
\session_id((string) $sid); // @codeCoverageIgnore
}
$this->inactivityInterval = $inactivityInterval;
if (\session_status() !== \PHP_SESSION_ACTIVE && !\headers_sent()) {
// @codeCoverageIgnoreStart
\session_set_cookie_params([
'lifetime' => $liftetime,
'path' => '/',
@ -92,8 +93,9 @@ final class HttpSession implements SessionInterface
'secure' => false,
'httponly' => true,
'samesite' => 'Strict',
]); // @codeCoverageIgnore
\session_start(); // @codeCoverageIgnore
]);
\session_start();
// @codeCoverageIgnoreEnd
}
if ($this->inactivityInterval > 0 && ($this->inactivityInterval + ($_SESSION['lastActivity'] ?? 0) < \time())) {
@ -172,12 +174,16 @@ final class HttpSession implements SessionInterface
/**
* {@inheritdoc}
*/
public function save() : void
public function save() : bool
{
if (!$this->isLocked) {
$_SESSION = $this->sessionData;
\session_write_close();
if ($this->isLocked) {
return false;
}
$_SESSION = $this->sessionData;
\session_write_close();
return true;
}
/**

4
DataStorage/Session/SessionInterface.php
View File

@ -64,11 +64,11 @@ interface SessionInterface
/**
* Save session.
*
* @return void
* @return bool
*
* @since 1.0.0
*/
public function save() : void;
public function save() : bool;
/**
* @return string

46
Math/Functions/Beta.php
View File

@ -47,23 +47,40 @@ final class Beta
*/
public static function incompleteBeta(float $x, float $p, float $q) : float
{
if ($x < 0.0) {
return 0.0;
} elseif ($x >= 1.0) {
return 1.0;
} elseif ($p <= 0.0 || $q >= 0.0 || $p + $q > 10000000000.0) {
return 0.0;
}
$bGamma = \exp(-self::logBeta($p, $q)) + $p * \log($x) + $q * \log(1.0 - $x);
return $x < ($p + 1.0) / ($p + $q + 2.0)
? $bGamma * self::betaFraction($x, $p, $q) / $p
: 1.0 - $bGamma * self::betaFraction(1 - $x, $q, $p) / $q;
return self::regularizedBeta($x, $p, $q) * self::beta($p, $q);
}
/**
* Fraction of the incomplete beta function
* Incomplete beta function
*
* @param float $x Value
* @param float $p p
* @param float $q q
*
* @return float
*
* @since 1.0.0
*/
public static function regularizedBeta(float $x, float $p, float $q) : float
{
if ($x <= 0.0) {
return 0.0;
} elseif ($x >= 1.0) {
return 1.0;
} elseif ($p <= 0.0 || $q <= 0.0 || $p + $q > 10000000000.0) {
return 0.0;
}
$bGamma = \exp(-self::logBeta($p, $q) + $p * \log($x) + $q * \log(1.0 - $x));
// this uses the symmetry of the beta function
return ($x < ($p + 1.0) / ($p + $q + 2.0)
? $bGamma * self::betaFraction($x, $p, $q) / $p
: 1.0 - $bGamma * self::betaFraction(1.0 - $x, $q, $p) / $q);
}
/**
* Fraction of the beta function
*
* @param float $x Value
* @param float $p p
@ -72,6 +89,7 @@ final class Beta
* @see JSci
* @author Jaco van Kooten
* @license LGPL 2.1
* @since 1.0.0
*/
private static function betaFraction(float $x, float $p, float $q) : float
{

43
Math/Functions/Functions.php
View File

@ -315,4 +315,47 @@ final class Functions
return 1 / \sqrt(\M_PI) * \exp(-$value * $value) * $q2;
}
/**
* Generalized hypergeometric function.
*
* pFq(a1, ..., ap; b1, ..., bq; z)
*
* @param array<int, float|int> $a Array of values
* @param array<int, float|int> $b Array of values
* @param float $z Z
*
* @return float
*
* @since 1.0.0
*/
public static function generalizedHypergeometricFunction(array $a, array $b, float $z) : float
{
$sum = 0.0;
$aProd = \array_fill(0, 20, []);
$bProd = \array_fill(0, 20, []);
for ($n = 0; $n < 20; ++$n) {
foreach ($a as $key => $value) {
if ($n === 0) {
$aProd[$n][$key] = 1;
} else {
$aProd[$n][$key] = $aProd[$n - 1][$key] * ($value + $n - 1);
}
}
foreach ($b as $key => $value) {
if ($n === 0) {
$bProd[$n][$key] = 1;
} else {
$bProd[$n][$key] = $bProd[$n - 1][$key] * ($value + $n - 1);
}
}
$temp = \array_product($aProd[$n]) / \array_product($bProd[$n]);
$sum += $temp * $z ** $n / self::fact($n);
}
return $sum;
}
}

146
Math/Functions/Gamma.php
View File

@ -34,6 +34,20 @@ final class Gamma
{
}
/**
* Gamma function
*
* @param int|float $z Value
*
* @return float
*
* @since 1.0.0
*/
public static function gamma($z) : float
{
return \exp(self::logGamma($z));
}
/**
* approximation values.
*
@ -134,16 +148,15 @@ final class Gamma
];
$y = $z;
$x = $z;
$temp = $x + 5.5 - ($x + 0.5) * \log($x + 5.5);
$temp = $z + 5.5 - ($z + 0.5) * \log($z + 5.5);
$sum = 1.000000000190015;
for ($i = 0; $i < 6; ++$i) {
$sum += $approx[$i] / ++$y;
}
return -$temp + \log(\sqrt(2 * \M_PI * $sum / $x));
return -$temp + \log(\sqrt(2 * \M_PI) * $sum / $z);
}
/**
@ -161,4 +174,131 @@ final class Gamma
{
return Functions::fact($k - 1);
}
/**
* First or lower incomplete gamma function
*
* @param float $a a
* @param float $x Value
*
* @return float
*
* @since 1.0.0
*/
public static function incompleteGammaFirst(float $a, float $x) : float
{
return self::regularizedGamma($a, $x) * \exp(self::logGamma($a));
}
/**
* Second or upper incomplete gamma function
*
* @param float $a a
* @param float $x Value
*
* @return float
*
* @since 1.0.0
*/
public static function incompleteGammaSecond(float $a, float $x) : float
{
return \exp(self::logGamma($a)) - self::regularizedGamma($a, $x) * \exp(self::logGamma($a));
}
/**
* Incomplete gamma function
*
* @param float $a a
* @param float $x Value
*
* @return float
*
* @since 1.0.0
*/
public static function regularizedGamma(float $a, float $x) : float
{
if ($x <= 0.0 || $a <= 0.0 || $a > 10000000000.0) {
return 0.0;
} elseif ($x < $a + 1.0) {
return self::gammaSeriesExpansion($a, $x);
}
return 1.0 - self::gammaFraction($a, $x);
}
/**
* Gamma series expansion
*
* @param float $a a
* @param float $x Value
*
* @return float
*
* @see JSci
* @author Jaco van Kooten
* @license LGPL 2.1
* @since 1.0.0
*/
private static function gammaSeriesExpansion(float $a, float $x) : float
{
$ap = $a;
$del = 1.0 / $a;
$sum = $del;
for ($i = 1; $i < 150; ++$i) {
++$ap;
$del *= $x / $ap;
$sum += $del;
if ($del < $sum * 2.22e-16) {
return $sum * \exp(-$x + $a * \log($x) - self::logGamma($a));
}
}
return 0.0;
}
/**
* Gamma fraction
*
* @param float $a a
* @param float $x Value
*
* @return float
*
* @see JSci
* @author Jaco van Kooten
* @license LGPL 2.1
* @since 1.0.0
*/
private static function gammaFraction(float $a, float $x) : float
{
$b = $x + 1.0 - $a;
$c = 1.0 / 2.23e-308;
$d = 1.0 / $b;
$h = $d;
$del = 0.0;
for ($i = 1; $i < 150 && \abs($del - 1.0) > 2.22e-16; ++$i) {
$an = - $i * ($i - $a);
$b += 2.0;
$d = $an * $d + $b;
$c = $b + $an / $c;
if (\abs($c) < 2.23e-308) {
$c = 2.23e-308;
}
if (\abs($d) < 2.23e-308) {
$d = 2.23e-308;
}
$d = 1.0 / $d;
$del = $d * $c;
$h *= $del;
}
return \exp(-$x + $a * \log($x) - self::logGamma($a)) * $h;
}
}

6
Math/Stochastic/Distribution/BernoulliDistribution.php
View File

@ -32,7 +32,7 @@ final class BernoulliDistribution
*
* @return float
*
* @throws \Exception
* @throws \InvalidArgumentException
*
* @since 1.0.0
*/
@ -44,11 +44,11 @@ final class BernoulliDistribution
return $p;
}
throw new \Exception('wrong parameter');
throw new \InvalidArgumentException('k needs to be 0 or 1');
}
/**
* Get cummulative distribution function.
* Get cumulative distribution function.
*
* @param float $p Value p
* @param float $k Value k

24
Math/Stochastic/Distribution/BetaDistribution.php
View File

@ -139,9 +139,9 @@ final class BetaDistribution
public static function getMgf(float $t, float $alpha, float $beta) : float
{
$sum = 0;
for ($k = 1; $k < 20; ++$k) {
for ($k = 1; $k < 15; ++$k) {
$product = 1;
for ($r = 0; $r < $k - 1; ++$r) {
for ($r = 0; $r < $k; ++$r) {
$product *= ($alpha + $r) / ($alpha + $beta + $r);
}
@ -152,7 +152,23 @@ final class BetaDistribution
}
/**
* Get cummulative distribution function.
* Get prdobability distribution function.
*
* @param float $x Value
* @param float $alpha Alpha
* @param float $beta Beta
*
* @return float
*
* @since 1.0.0
*/
public static function getPdf(float $x, float $alpha, float $beta) : float
{
return \pow($x, $alpha - 1) * \pow(1 - $x, $beta - 1) / Beta::beta($alpha, $beta);
}
/**
* Get cumulative distribution function.
*
* @param float $x Value
* @param float $alpha Alpha
@ -164,6 +180,6 @@ final class BetaDistribution
*/
public static function getCdf(float $x, float $alpha, float $beta) : float
{
return Beta::incompleteBeta($x, $alpha, $beta);
return Beta::regularizedBeta($x, $alpha, $beta);
}
}

19
Math/Stochastic/Distribution/ChiSquaredDistribution.php
View File

@ -14,6 +14,8 @@ declare(strict_types=1);
namespace phpOMS\Math\Stochastic\Distribution;
use phpOMS\Math\Functions\Gamma;
/**
* Chi squared distribution.
*
@ -159,7 +161,22 @@ final class ChiSquaredDistribution
throw new \OutOfBoundsException('Out of bounds');
}
return 0.0;
return 1 / (\pow(2, $df / 2) * Gamma::gamma($df / 2)) * \pow($x, $df / 2 - 1) * \exp(-$x / 2);
}
/**
* Get cumulative density function.
*
* @param float $x Value x
* @param int $df Degreegs of freedom
*
* @return float
*
* @since 1.0.0
*/
public static function getCdf(float $x, int $df) : float
{
return 1 / Gamma::gamma($df / 2) * Gamma::incompleteGammaFirst($df / 2, $x / 2);
}
/**

35
Math/Stochastic/Distribution/FDistribution.php
View File

@ -13,6 +13,8 @@
declare(strict_types=1);
namespace phpOMS\Math\Stochastic\Distribution;
use phpOMS\Math\Functions\Beta;
/**
* F distribution.
*
@ -23,6 +25,39 @@ namespace phpOMS\Math\Stochastic\Distribution;
*/
final class FDistribution
{
/**
* Get probability density function.
*
* @param float $x Value x
* @param int $d1 Degreegs of freedom
* @param int $d2 Degreegs of freedom
*
* @return float
*
* @since 1.0.0
*/
public static function getPdf(float $x, int $d1, int $d2) : float
{
return \sqrt((\pow($d1 * $x, $d1) * ($d2 ** $d2)) / \pow($d1 * $x + $d2, $d1 + $d2))
/ ($x * Beta::beta($d1 / 2, $d2 / 2));
}
/**
* Get cumulative density function.
*
* @param float $x Value x
* @param int $d1 Degreegs of freedom
* @param int $d2 Degreegs of freedom
*
* @return float
*
* @since 1.0.0
*/
public static function getCdf(float $x, int $d1, int $d2) : float
{
return Beta::regularizedBeta($d1 * $x / ($d1 * $x + $d2), $d1 / 2, $d2 / 2);
}
/**
* Get expected value.
*

98
Math/Stochastic/Distribution/GammaDistribution.php
View File

@ -26,7 +26,39 @@ use phpOMS\Math\Functions\Gamma;
final class GammaDistribution
{
/**
* Get probability density function.
* Get probability density function for shape and scale.
*
* @param float $x Value x
* @param float $k k shape
* @param float $theta Theta scale
*
* @return float
*
* @since 1.0.0
*/
public static function getPdfScale(float $x, float $k, float $theta) : float
{
return 1 / (Gamma::gamma($k) * $theta ** $k) * \pow($x, $k - 1) * \exp(-$x / $theta);
}
/**
* Get probability density function for shape and rate.
*
* @param float $x Value x
* @param float $alpha Alpha shape
* @param float $beta Beta rate
*
* @return float
*
* @since 1.0.0
*/
public static function getPdfRate(float $x, float $alpha, float $beta) : float
{
return $beta ** $alpha / Gamma::gamma($alpha) * \pow($x, $alpha - 1) * \exp(-$beta * $x);
}
/**
* Get probability density function for shape and scale.
*
* @param float $x Value x
* @param int $k k shape
@ -36,13 +68,13 @@ final class GammaDistribution
*
* @since 1.0.0
*/
public static function getPdfIntegerK(float $x, int $k, float $theta) : float
public static function getPdfIntegerScale(float $x, int $k, float $theta) : float
{
return 1 / (Gamma::getGammaInteger($k) * $theta ** $k) * \pow($x, $k - 1) * \exp(-$x / $theta);
}
/**
* Get probability density function.
* Get probability density function for shape and rate.
*
* @param float $x Value x
* @param int $alpha Alpha shape
@ -52,11 +84,43 @@ final class GammaDistribution
*
* @since 1.0.0
*/
public static function getPdfIntegerAlphaBeta(float $x, int $alpha, float $beta) : float
public static function getPdfIntegerRate(float $x, int $alpha, float $beta) : float
{
return $beta ** $alpha / Gamma::getGammaInteger($alpha) * \pow($x, $alpha - 1) * \exp(-$beta * $x);
}
/**
* Get cumulative density function for shape and scale.
*
* @param float $x Value x
* @param float $k k shape
* @param float $theta Theta scale
*
* @return float
*
* @since 1.0.0
*/
public static function getCdfScale(float $x, float $k, float $theta) : float
{
return 1 / Gamma::gamma($k) * Gamma::incompleteGammaFirst($k, $x / $theta);
}
/**
* Get cumulative density function for shape and rate.
*
* @param float $x Value x
* @param float $alpha Alpha shape
* @param float $beta Beta rate
*
* @return float
*
* @since 1.0.0
*/
public static function getCdfRate(float $x, float $alpha, float $beta) : float
{
return 1 / Gamma::gamma($alpha) * Gamma::incompleteGammaFirst($alpha, $beta * $x);
}
/**
* Get expected value.
*
@ -67,7 +131,7 @@ final class GammaDistribution
*
* @since 1.0.0
*/
public static function getMeanK(float $k, float $theta) : float
public static function getMeanScale(float $k, float $theta) : float
{
return $k * $theta;
}
@ -82,9 +146,9 @@ final class GammaDistribution
*
* @since 1.0.0
*/
public static function getMeanAlphaBeta(float $alpha, float $beta) : float
public static function getMeanRate(float $alpha, float $beta) : float
{
return $alpha * $beta;
return $alpha / $beta;
}
/**
@ -97,7 +161,7 @@ final class GammaDistribution
*
* @since 1.0.0
*/
public static function getModeK(float $k, float $theta) : float
public static function getModeScale(float $k, float $theta) : float
{
return ($k - 1) * $theta;
}
@ -112,7 +176,7 @@ final class GammaDistribution
*
* @since 1.0.0
*/
public static function getModeAlphaBeta(float $alpha, float $beta) : float
public static function getModeRate(float $alpha, float $beta) : float
{
return ($alpha - 1) / $beta;
}
@ -155,7 +219,7 @@ final class GammaDistribution
*
* @since 1.0.0
*/
public static function getVarianceK(float $k, float $theta) : float
public static function getVarianceScale(float $k, float $theta) : float
{
return $k * $theta ** 2;
}
@ -170,9 +234,9 @@ final class GammaDistribution
*
* @since 1.0.0
*/
public static function getStandardDeviationK(float $k, float $theta) : float
public static function getStandardDeviationScale(float $k, float $theta) : float
{
return \sqrt(self::getVarianceK($k, $theta));
return \sqrt(self::getVarianceScale($k, $theta));
}
/**
@ -185,7 +249,7 @@ final class GammaDistribution
*
* @since 1.0.0
*/
public static function getVarianceAlphaBeta(float $alpha, float $beta) : float
public static function getVarianceRate(float $alpha, float $beta) : float
{
return $alpha / ($beta ** 2);
}
@ -200,9 +264,9 @@ final class GammaDistribution
*
* @since 1.0.0
*/
public static function getStandardDeviationAlphaBeta(float $alpha, float $beta) : float
public static function getStandardDeviationRate(float $alpha, float $beta) : float
{
return \sqrt(self::getVarianceAlphaBeta($alpha, $beta));
return \sqrt(self::getVarianceRate($alpha, $beta));
}
/**
@ -216,7 +280,7 @@ final class GammaDistribution
*
* @since 1.0.0
*/
public static function getMgfK(float $k, float $t, float $theta) : float
public static function getMgfScale(float $k, float $t, float $theta) : float
{
return \pow(1 - $theta * $t, -$k);
}
@ -232,7 +296,7 @@ final class GammaDistribution
*
* @since 1.0.0
*/
public static function getMgfAlphaBeta(float $t, float $alpha, float $beta) : float
public static function getMgfRate(float $t, float $alpha, float $beta) : float
{
return \pow(1 - $t / $beta, -$alpha);
}

4
Math/Stochastic/Distribution/GeometricDistribution.php
View File

@ -134,7 +134,9 @@ final class GeometricDistribution
*/
public static function getMgf(float $p, float $t) : float
{
return $t < -\log(1 - $p) ? $p * \exp($t) / (1 - (1 - $p) * \exp($t)) : $p / (1 - (1 - $p) * \exp($t));
return $t < -\log(1 - $p)
? $p * \exp($t) / (1 - (1 - $p) * \exp($t))
: $p / (1 - (1 - $p) * \exp($t));
}
/**

26
Math/Stochastic/Distribution/HypergeometricDistribution.php
View File

@ -39,7 +39,7 @@ final class HypergeometricDistribution
*/
public static function getPmf(int $K, int $N, int $k, int $n) : float
{
return Functions::fact($K, $k) * Functions::fact($N - $K, $n - $k) / Functions::fact($N, $n);
return Functions::binomialCoefficient($K, $k) * Functions::binomialCoefficient($N - $K, $n - $k) / Functions::binomialCoefficient($N, $n);
}
/**
@ -141,22 +141,26 @@ final class HypergeometricDistribution
}
/**
* Get cummulative distribution function.
* Get cumulative distribution function.
*
* @param int $sampleSuccesses Amount of sample successes
* @param int $samples Sample size
* @param int $populationSuccesses Amount of population successes
* @param int $population Population size
* @param int $K Successful states in the population
* @param int $N Population size
* @param int $k Observed successes
* @param int $n Number of draws
*
* @return float
*
* @since 1.0.0
*/
public static function getCdf(int $sampleSuccesses, int $samples, int $populationSuccesses, int $population) : float
public static function getCdf(int $K, int $N, int $k, int $n) : float
{
// Each multiplication calculates the total amount of possible group combinations based on a total amount of items.
return (int) (\round(Functions::fact($populationSuccesses) / Functions::fact($populationSuccesses - $sampleSuccesses)) / Functions::fact($sampleSuccesses)
* \round(Functions::fact($population - $populationSuccesses) / Functions::fact($population - $populationSuccesses - ($samples - $sampleSuccesses))) / Functions::fact($samples - $sampleSuccesses)
* \round(Functions::fact($population) / Functions::fact($population - $samples)) / Functions::fact($samples));
return 1 - Functions::binomialCoefficient($n, $k + 1)
* Functions::binomialCoefficient($N - $n, $K - $k - 1)
/ Functions::binomialCoefficient($N, $K)
* Functions::generalizedHypergeometricFunction(
[1, $k + 1 - $K, $k + 1 - $n],
[$k + 2, $N + $k + 2 - $K - $n],
1
);
}
}

24
Math/Stochastic/Distribution/LogDistribution.php
View File

@ -13,6 +13,8 @@
declare(strict_types=1);
namespace phpOMS\Math\Stochastic\Distribution;
use phpOMS\Math\Functions\Beta;
/**
* Log distribution.
*
@ -38,6 +40,24 @@ final class LogDistribution
return -1 / \log(1 - $p) * $p ** $k / $k;
}
/**
* Get cumulative distribution function.
*
* @param float $p Value p
* @param int $k Value k
*
* @return float
*
* @since 1.0.0
*/
public static function getCdf(float $p, int $k) : float
{
// This is a workaround!
// Actually 0 should be used instead of 0.0001.
// This is only used because the incomplete beta function doesn't work for p or q = 0
return 1 + Beta::incompleteBeta($p, $k + 1, 0.0001) / \log(1 - $p);
}
/**
* Get expected value.
*
@ -97,13 +117,13 @@ final class LogDistribution
* Get moment generating function.
*
* @param float $p Value p
* @param int $t Value t
* @param float $t Value t
*
* @return float
*
* @since 1.0.0
*/
public static function getMgf(float $p, int $t) : float
public static function getMgf(float $p, float $t) : float
{
return \log(1 - $p * \exp($t)) / \log(1 - $p);
}

8
Math/Stochastic/Distribution/LogNormalDistribution.php
View File

@ -154,9 +154,9 @@ final class LogNormalDistribution
*
* @since 1.0.0
*/
public static function getEntrpoy(float $mu, float $sigma) : float
public static function getEntropy(float $mu, float $sigma) : float
{
return \log($sigma * \exp($mu + 1 / 2) * \sqrt(2 * \M_1_PI), 2);
return \log($sigma * \exp($mu + 1 / 2) * \sqrt(2 * \M_PI), 2);
}
/**
@ -172,12 +172,12 @@ final class LogNormalDistribution
{
return [
[1 / ($sigma ** 2), 0],
[0, 1 / (2 * $sigma ** 2)],
[0, 1 / (2 * $sigma ** 4)],
];
}
/**
* Get cummulative distribution function.
* Get cumulative distribution function.
*
* @param float $x Value
* @param float $mean Mean

2
Math/Stochastic/Distribution/LogisticDistribution.php
View File

@ -41,7 +41,7 @@ final class LogisticDistribution
}
/**
* Get cummulative distribution function.
* Get cumulative distribution function.
*
* @param float $x Value x
* @param float $mu Mean

7
Math/Stochastic/Distribution/NormalDistribution.php
View File

@ -89,7 +89,7 @@ final class NormalDistribution
}
/**
* Get cummulative distribution function.
* Get cumulative distribution function.
*
* @param float $x Value x
* @param float $mu Mean
@ -213,7 +213,10 @@ final class NormalDistribution
*/
public static function getFisherInformation(float $sig) : array
{
return [[1 / $sig ** 2, 0], [0, 1 / (2 * $sig ** 4)]];
return [
[1 / $sig ** 2, 0],
[0, 1 / (2 * $sig ** 4)],
];
}
/**

6
Math/Stochastic/Distribution/TDistribution.php
View File

@ -161,7 +161,7 @@ final class TDistribution
}
/**
* Get cummulative distribution function.
* Get cumulative distribution function.
*
* @param float $x Value
* @param int $degrees Degrees of freedom
@ -171,7 +171,7 @@ final class TDistribution
*
* @since 1.0.0
*/
public static function getCdf(float $x, int $degrees, int $tails = 2) : float
public static function getCdf(float $x, int $degrees, int $tails = 1) : float
{
if ($x < 0.0 || $degrees < 1 || $tails < 1 || $tails > 2) {
return 0.0;
@ -210,6 +210,6 @@ final class TDistribution
$t = 0.5 * (1 + $sum);
return $tails === 1 ? 1 - \abs($t) : 1 - \abs(1 - $t - $t);
return $tails === 1 ? \abs($t) : 1 - \abs(1 - $t - $t);
}
}

3
Math/Stochastic/Distribution/UniformDistributionDiscrete.php
View File

@ -74,7 +74,8 @@ final class UniformDistributionDiscrete
*/
public static function getMgf(int $t, float $a, float $b) : float
{
return (\exp($a * $t) - \exp(($b + 1) * $t)) / (($b - $a + 1) * (1 - \exp($t)));
return (\exp($a * $t) - \exp(($b + 1) * $t))
/ (($b - $a + 1) * (1 - \exp($t)));
}
/**

74
Math/Stochastic/Distribution/WeibullDistribution.php
View File

@ -13,6 +13,8 @@
declare(strict_types=1);
namespace phpOMS\Math\Stochastic\Distribution;
use phpOMS\Math\Functions\Gamma;
/**
* Weibull distribution.
*
@ -36,7 +38,9 @@ final class WeibullDistribution
*/
public static function getPdf(float $x, float $lambda, float $k) : float
{
return $x < 0.0 ? 0.0 : $k / $lambda * \pow($x / $lambda, $k - 1) * \exp(-($x / $lambda) ** $k);
return $x < 0.0
? 0.0
: $k / $lambda * \pow($x / $lambda, $k - 1) * \exp(-($x / $lambda) ** $k);
}
/**
@ -52,7 +56,24 @@ final class WeibullDistribution
*/
public static function getCdf(float $x, float $lambda, float $k) : float
{
return $x < 0.0 ? 0.0 : 1 - \exp(-($x / $lambda) ** $k);
return $x < 0.0
? 0.0
: 1 - \exp(-($x / $lambda) ** $k);
}
/**
* Get mean.
*
* @param float $lambda Scale lambda
* @param float $k Shape k
*
* @return float
*
* @since 1.0.0
*/
public static function getMean(float $lambda, float $k) : float
{
return $lambda * Gamma::gamma(1 + 1 / $k);
}
/**
@ -70,6 +91,36 @@ final class WeibullDistribution
return $lambda * \pow(\log(2), 1 / $k);
}
/**
* Get the variance.
*
* @param float $lambda Scale lambda
* @param float $k Shape k
*
* @return float
*
* @since 1.0.0
*/
public static function getVariance(float $lambda, float $k) : float
{
return $lambda ** 2 * (Gamma::gamma(1 + 2 / $k) - Gamma::gamma(1 + 1 / $k) ** 2);
}
/**
* Get the standard deviation.
*
* @param float $lambda Scale lambda
* @param float $k Shape k
*
* @return float
*
* @since 1.0.0
*/
public static function getStandardDeviation(float $lambda, float $k) : float
{
return \sqrt(self::getVariance($lambda, $k));
}
/**
* Get mode.
*
@ -85,6 +136,25 @@ final class WeibullDistribution
return $lambda * \pow(($k - 1) / $k, 1 / $k);
}
/**
* Get skewness.
*
* @param float $lambda Scale lambda
* @param float $k Shape k
*
* @return float
*
* @since 1.0.0
*/
public static function getSkewness(float $lambda, float $k) : float
{
$mu = self::getMean($lambda, $k);
$sig = self::getStandardDeviation($lambda, $k);
return (Gamma::gamma(1 + 3 / $k) * $lambda ** 3 - 3 * $mu * $sig ** 2 - $mu ** 3)
/ ($sig ** 3);
}
/**
* Get entropy.
*

10
Math/Stochastic/Distribution/ZTest.php → Math/Stochastic/Distribution/ZTesting.php
View File

@ -27,7 +27,7 @@ use phpOMS\Math\Statistic\MeasureOfDispersion;
*
* @internal
*/
final class ZTest
final class ZTesting
{
public const TABLE = [
'2.58' => 0.99,
@ -75,11 +75,11 @@ final class ZTest
*
* @since 1.0.0
*/
public static function zTesting(float $value, array $data, float $sigma = null) : float
public static function zTest(float $value, array $data, float $sigma = null) : float
{
$sigma ??= MeasureOfDispersion::standardDeviationSample($data);
return 1 - NormalDistribution::getCdf((Average::arithmeticMean($data) - $value) / ($sigma / \sqrt(\count($data))), 0.0, 1.0, true);
return 1 - NormalDistribution::getCdf((Average::arithmeticMean($data) - $value) / ($sigma / \sqrt(\count($data))), 0.0, 1.0);
}
/**
@ -94,8 +94,8 @@ final class ZTest
*
* @since 1.0.0
*/
public static function zTestingValues(float $value, float $mean, int $dataSize, float $sigma) : float
public static function zTestValues(float $value, float $mean, int $dataSize, float $sigma) : float
{
return 1 - NormalDistribution::getCdf(($mean - $value) / ($sigma / \sqrt($dataSize)), 0.0, 1.0, true);
return 1 - NormalDistribution::getCdf(($mean - $value) / ($sigma / \sqrt($dataSize)), 0.0, 1.0);
}
}

2
tests/Ai/Ocr/BasicOcrTest.php
View File

@ -14,6 +14,8 @@ declare(strict_types=1);
namespace phpOMS\tests\Ai\Ocr;
use phpOMS\Ai\Ocr\BasicOcr;
/**
* @internal
*/

3
tests/DataStorage/Cache/Connection/FileCacheTest.php
View File

@ -57,6 +57,9 @@ class FileCacheTest extends \PHPUnit\Framework\TestCase
self::assertTrue(\is_dir(__DIR__ . '/Cache'));
self::assertTrue($this->cache->flushAll());
self::assertEquals(50, $this->cache->getThreshold());
self::assertEquals('', $this->cache->getCache());
self::assertEquals('', $this->cache->getHost());
self::assertEquals(0, $this->cache->getPort());
self::assertNull($this->cache->get('test'));
self::assertEquals(
[

17
tests/DataStorage/Cache/Connection/MemCachedTest.php
View File

@ -55,6 +55,9 @@ class MemCachedTest extends \PHPUnit\Framework\TestCase
self::assertTrue($this->cache->flushAll());
self::assertEquals(0, $this->cache->getThreshold());
self::assertNull($this->cache->get('test'));
self::assertEquals('', $this->cache->getCache());
self::assertEquals('127.0.0.1', $this->cache->getHost());
self::assertEquals(11211, $this->cache->getPort());
self::assertEquals(
[
'status' => CacheStatus::OK,
@ -244,6 +247,20 @@ class MemCachedTest extends \PHPUnit\Framework\TestCase
self::assertNull($this->cache->get('key2', 1));
}
/**
* @testdox Cache data can be flushed by expiration date
* @covers phpOMS\DataStorage\Cache\Connection\MemCached<extended>
* @group framework
*/
public function testFlushExpired() : void
{
$this->cache->set('key6', 'testVal6', 1);
\sleep(2);
$this->cache->flush(0);
self::assertNull($this->cache->get('key6', 0));
}
/**
* @testdox A bad cache status will prevent all cache actions
* @covers phpOMS\DataStorage\Cache\Connection\MemCached<extended>

3
tests/DataStorage/Cache/Connection/RedisCacheTest.php
View File

@ -58,6 +58,9 @@ class RedisCacheTest extends \PHPUnit\Framework\TestCase
self::assertEquals(CacheStatus::OK, $this->cache->stats()['status']);
self::assertEquals(0, $this->cache->stats()['count']);
self::assertGreaterThanOrEqual(0, $this->cache->stats()['size']);
self::assertEquals('1', $this->cache->getCache());
self::assertEquals('127.0.0.1', $this->cache->getHost());
self::assertEquals(6379, $this->cache->getPort());
}
/**

130
tests/DataStorage/Session/FileSessionHandlerTest.php Normal file
View File

@ -0,0 +1,130 @@
<?php
/**
* Orange Management
*
* PHP Version 7.4
*
* @package tests
* @copyright Dennis Eichhorn
* @license OMS License 1.0
* @version 1.0.0
* @link https://orange-management.org
*/
declare(strict_types=1);
namespace phpOMS\tests\DataStorage\Session;
use phpOMS\DataStorage\Session\FileSessionHandler;
use phpOMS\System\File\Local\Directory;
/**
* @testdox phpOMS\tests\DataStorage\Session\FileSessionHandlerTest: File session handler
*
* @internal
*/
class FileSessionHandlerTest extends \PHPUnit\Framework\TestCase
{
protected FileSessionHandler $sh;
protected function setUp() : void
{
if (\file_exists(__DIR__ . '/test')) {
Directory::delete(__DIR__ . '/test');
}
$this->sh = new FileSessionHandler(__DIR__ . '/test');
}
protected function tearDown() : void
{
if (\file_exists(__DIR__ . '/test')) {
Directory::delete(__DIR__ . '/test');
}
}
/**
* @testdox A session id can be generated
* @group framework
*/
public function testCreateSid() : void
{
self::assertMatchesRegularExpression('/^s\-[a-z0-9]+/', $this->sh->create_sid());
}
/**
* @testdox The session path can be accessed
* @group framework
*/
public function testSessionPath() : void
{
self::assertTrue($this->sh->open(__DIR__ . '/test', ''));
}
/**
* @testdox A invalid session path cannot be accessed
* @group framework
*/
public function testInvalidSessionPath() : void
{
self::assertFalse($this->sh->open(__DIR__ . '/invalid', ''));
}
/**
* @testdox A session can be closed
* @group framework
*/
public function testSessionClose() : void
{
self::assertTrue($this->sh->close());
}
/**
* @testdox A valid session id can store and return data
* @group framework
*/
public function testSessionInputOutput() : void
{
$id = $this->sh->create_sid();
self::assertTrue($this->sh->write($id, 'test'));
self::assertEquals('test', $this->sh->read($id));
}
/**
* @testdox A invalid session id doesn't return any data
* @group framework
*/
public function testReadInvalidSessionId() : void
{
self::assertEquals('', $this->sh->read('invalid'));
}
/**
* @testdox A session can be destroyed
* @group framework
*/
public function testSessionDestroy() : void
{
$id = $this->sh->create_sid();
self::assertTrue($this->sh->write($id, 'test'));
self::assertEquals('test', $this->sh->read($id));
$this->sh->destroy($id);
self::assertEquals('', $this->sh->read($id));
}
/**
* @testdox Sessions can be removed based on a timeout
* @group framework
*/
public function testSessionTimeoutDestroy() : void
{
$id = $this->sh->create_sid();
self::assertTrue($this->sh->write($id, 'test'));
self::assertEquals('test', $this->sh->read($id));
\sleep(2);
$this->sh->gc(0);
self::assertEquals('', $this->sh->read($id));
}
}

156
tests/DataStorage/Session/FileSessionTest.php Normal file
View File

@ -0,0 +1,156 @@
<?php
/**
* Orange Management
*
* PHP Version 7.4
*
* @package tests
* @copyright Dennis Eichhorn
* @license OMS License 1.0
* @version 1.0.0
* @link https://orange-management.org
*/
declare(strict_types=1);
namespace phpOMS\tests\DataStorage\Session;
use phpOMS\DataStorage\Session\FileSession;
/**
* @testdox phpOMS\tests\DataStorage\Session\FileSessionTest: File session handler
*
* @internal
*/
class FileSessionTest extends \PHPUnit\Framework\TestCase
{
protected FileSession $session;
protected function setUp() : void
{
$this->session = new FileSession();
}
/**
* @testdox The session has the expected default values after initialization
* @group framework
*/
public function testDefault() : void
{
self::assertNull($this->session->get('key'));
self::assertFalse($this->session->isLocked());
}
/**
* @testdox Session data can be set and returned
* @group framework
*/
public function testInputOutput() : void
{
self::assertTrue($this->session->set('test', 'value'));
self::assertEquals('value', $this->session->get('test'));
}
/**
* @testdox Session data cannot be overwritten
* @group framework
*/
public function testInvalidOverwrite() : void
{
$this->session->set('test', 'value');
self::assertFalse($this->session->set('test', 'value2'));
self::assertEquals('value', $this->session->get('test'));
}
/**
* @testdox Session data can be forced to overwrite
* @group framework
*/
public function testOverwrite() : void
{
$this->session->set('test', 'value');
self::assertTrue($this->session->set('test', 'value2', true));
self::assertEquals('value2', $this->session->get('test'));
}
/**
* @testdox Session data can be removed
* @group framework
*/
public function testRemove() : void
{
$this->session->set('test', 'value');
self::assertTrue($this->session->remove('test'));
}
/**
* @testdox None-existing session data cannot be removed
* @group framework
*/
public function testInvalidRemove() : void
{
$this->session->set('test', 'value');
$this->session->remove('test');
self::assertFalse($this->session->remove('test'));
}
/**
* @testdox A session id can be set and returned
* @group framework
*/
public function testSessionIdInputOutput() : void
{
$this->session->setSID('abc');
self::assertEquals('abc', $this->session->getSID());
}
/**
* @testdox A session can be locked
* @group framework
*/
public function testLockInputOutput() : void
{
$this->session->lock();
self::assertTrue($this->session->isLocked());
}
/**
* @testdox Session data can be saved
* @group framework
*/
public function testSave() : void
{
self::assertTrue($this->session->save());
}
/**
* @testdox Locked sessions cannot be saved
* @group framework
*/
public function testInvalidLockSave() : void
{
$this->session->lock();
self::assertFalse($this->session->save());
}
/**
* @testdox A locked session cannot add or change data
* @group framework
*/
public function testLockInvalidSet() : void
{
$this->session->lock();
self::assertFalse($this->session->set('test', 'value'));
}
/**
* @testdox A locked session cannot remove data
* @group framework
*/
public function testLockInvalidRemove() : void
{
self::assertTrue($this->session->set('test', 'value'));
$this->session->lock();
self::assertFalse($this->session->remove('test'));
}
}

80
tests/DataStorage/Session/HttpSessionTest.php
View File

@ -23,6 +23,13 @@ use phpOMS\DataStorage\Session\HttpSession;
*/
class HttpSessionTest extends \PHPUnit\Framework\TestCase
{
protected HttpSession $session;
protected function setUp() : void
{
$this->session = new HttpSession(1, '', 1);
}
/**
* @testdox The session has the expected default values after initialization
* @group framework
@ -40,9 +47,8 @@ class HttpSessionTest extends \PHPUnit\Framework\TestCase
*/
public function testInputOutput() : void
{
$session = new HttpSession(1, '', 1);
self::assertTrue($session->set('test', 'value'));
self::assertEquals('value', $session->get('test'));
self::assertTrue($this->session->set('test', 'value'));
self::assertEquals('value', $this->session->get('test'));
}
/**
@ -51,10 +57,9 @@ class HttpSessionTest extends \PHPUnit\Framework\TestCase
*/
public function testInvalidOverwrite() : void
{
$session = new HttpSession(1, '', 1);
$session->set('test', 'value');
self::assertFalse($session->set('test', 'value2'));
self::assertEquals('value', $session->get('test'));
$this->session->set('test', 'value');
self::assertFalse($this->session->set('test', 'value2'));
self::assertEquals('value', $this->session->get('test'));
}
/**
@ -63,10 +68,9 @@ class HttpSessionTest extends \PHPUnit\Framework\TestCase
*/
public function testOverwrite() : void
{
$session = new HttpSession(1, '', 1);
$session->set('test', 'value');
self::assertTrue($session->set('test', 'value2', true));
self::assertEquals('value2', $session->get('test'));
$this->session->set('test', 'value');
self::assertTrue($this->session->set('test', 'value2', true));
self::assertEquals('value2', $this->session->get('test'));
}
/**
@ -75,9 +79,8 @@ class HttpSessionTest extends \PHPUnit\Framework\TestCase
*/
public function testRemove() : void
{
$session = new HttpSession(1, '', 1);
$session->set('test', 'value');
self::assertTrue($session->remove('test'));
$this->session->set('test', 'value');
self::assertTrue($this->session->remove('test'));
}
/**
@ -86,11 +89,10 @@ class HttpSessionTest extends \PHPUnit\Framework\TestCase
*/
public function testInvalidRemove() : void
{
$session = new HttpSession(1, '', 1);
$session->set('test', 'value');
$session->remove('test');
$this->session->set('test', 'value');
$this->session->remove('test');
self::assertFalse($session->remove('test'));
self::assertFalse($this->session->remove('test'));
}
/**
@ -99,9 +101,8 @@ class HttpSessionTest extends \PHPUnit\Framework\TestCase
*/
public function testSessionIdInputOutput() : void
{
$session = new HttpSession(1, '', 1);
$session->setSID('abc');
self::assertEquals('abc', $session->getSID());
$this->session->setSID('abc');
self::assertEquals('abc', $this->session->getSID());
}
/**
@ -110,10 +111,27 @@ class HttpSessionTest extends \PHPUnit\Framework\TestCase
*/
public function testLockInputOutput() : void
{
$session = new HttpSession(1, '', 1);
$this->session->lock();
self::assertTrue($this->session->isLocked());
}
$session->lock();
self::assertTrue($session->isLocked());
/**
* @testdox Session data can be saved
* @group framework
*/
public function testSave() : void
{
self::assertTrue($this->session->save());
}
/**
* @testdox Locked sessions cannot be saved
* @group framework
*/
public function testInvalidLockSave() : void
{
$this->session->lock();
self::assertFalse($this->session->save());
}
/**
@ -122,10 +140,8 @@ class HttpSessionTest extends \PHPUnit\Framework\TestCase
*/
public function testLockInvalidSet() : void
{
$session = new HttpSession(1, '', 1);
$session->lock();
self::assertFalse($session->set('test', 'value'));
$this->session->lock();
self::assertFalse($this->session->set('test', 'value'));
}
/**
@ -134,10 +150,8 @@ class HttpSessionTest extends \PHPUnit\Framework\TestCase
*/
public function testLockInvalidRemove() : void
{
$session = new HttpSession(1, '', 1);
self::assertTrue($session->set('test', 'value'));
$session->lock();
self::assertFalse($session->remove('test'));
self::assertTrue($this->session->set('test', 'value'));
$this->session->lock();
self::assertFalse($this->session->remove('test'));
}
}

60
tests/Math/Functions/BetaTest.php
View File

@ -23,18 +23,56 @@ use phpOMS\Math\Functions\Beta;
*/
class BetaTest extends \PHPUnit\Framework\TestCase
{
public function testIncompleteBeta() : void
{
self::markTestIncomplete();
}
public function testLogBeta() : void
{
self::markTestIncomplete();
}
/**
* @testdox The beta function can be approximated
* @covers phpOMS\Math\Functions\Beta
* @group framework
*/
public function beta() : void
{
self::markTestIncomplete();
self::assertEqualsWithDelta(1.0, Beta::beta(0, 3), 0.001);
self::assertEqualsWithDelta(4.4776093, Beta::beta(1.5, 0.2), 0.001);
self::assertEqualsWithDelta(0.045648, Beta::beta(2, 4), 0.001);
}
/**
* @testdox The log beta function can be approximated
* @covers phpOMS\Math\Functions\Beta
* @group framework
*/
public function testLogBeta() : void
{
self::assertEqualsWithDelta(0, Beta::logBeta(1, 0), 0.001);
self::assertEqualsWithDelta(\log(4.4776093), Beta::logBeta(1.5, 0.2), 0.001);
self::assertEqualsWithDelta(\log(Beta::beta(2, 4)), Beta::logBeta(2, 4), 0.001);
}
/**
* @testdox The incomplete beta function can be approximated
* @covers phpOMS\Math\Functions\Beta
* @group framework
*/
public function testIncompleteBeta() : void
{
self::assertEqualsWithDelta(0.0, Beta::incompleteBeta(-1, 1, 3), 0.001);
self::assertEqualsWithDelta(0.3333, Beta::incompleteBeta(1.0, 1, 3), 0.001);
self::assertEqualsWithDelta(0.0, Beta::incompleteBeta(0.4, 0, 3), 0.001);
self::assertEqualsWithDelta(0.261333, Beta::incompleteBeta(0.4, 1, 3), 0.001);
self::assertEqualsWithDelta(0.045648, Beta::incompleteBeta(0.6, 2, 4), 0.001);
}
/**
* @testdox The regularized beta function can be approximated
* @covers phpOMS\Math\Functions\Beta
* @group framework
*/
public function testRegularizedBeta() : void
{
self::assertEqualsWithDelta(0.0, Beta::regularizedBeta(-1, 1, 3), 0.001);
self::assertEqualsWithDelta(1.0, Beta::regularizedBeta(1.0, 1, 3), 0.001);
self::assertEqualsWithDelta(0.0, Beta::regularizedBeta(0.4, 0, 3), 0.001);
self::assertEqualsWithDelta(0.784, Beta::regularizedBeta(0.4, 1, 3), 0.001);
self::assertEqualsWithDelta(0.04, Beta::regularizedBeta(0.2, 2, 1), 0.001);
self::assertEqualsWithDelta(0.91296, Beta::regularizedBeta(0.6, 2, 4), 0.001);
}
}

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

@ -109,13 +109,39 @@ class FunctionsTest extends \PHPUnit\Framework\TestCase
self::assertEquals(11, Functions::getRelativeDegree(6, 12, 7));
}
/**
* @testdox The error function can be correctly approximated
* @covers phpOMS\Math\Functions\Functions
* @group framework
*/
public function testErf() : void
{
self::markTestIncomplete();
self::assertEqualsWithDelta(-0.8427, Functions::getErf(-1), 0.001);
self::assertEqualsWithDelta(0.0, Functions::getErf(0), 0.001);
self::assertEqualsWithDelta(0.8427, Functions::getErf(1), 0.001);
self::assertEqualsWithDelta(0.9988, Functions::getErf(2.3), 0.001);
}
/**
* @testdox The complementary error function can be correctly approximated
* @covers phpOMS\Math\Functions\Functions
* @group framework
*/
public function testErfc() : void
{
self::markTestIncomplete();
self::assertEqualsWithDelta(1.8427, Functions::getErfc(-1), 0.001);
self::assertEqualsWithDelta(1, Functions::getErfc(0), 0.001);
self::assertEqualsWithDelta(0.15729920705, Functions::getErfc(1), 0.001);
self::assertEqualsWithDelta(2.0, Functions::getErfc(-5), 0.001);
}
/**
* @testdox The generalized hypergeometric function can be correctly calculated
* @covers phpOMS\Math\Functions\Functions
* @group framework
*/
public function testGeneralizedHypergeometricFunction() : void
{
self::assertEqualsWithDelta(2.7289353, Functions::generalizedHypergeometricFunction([2, 3], [4], 0.5), 0.001);
}
}

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

@ -24,6 +24,17 @@ use phpOMS\Math\Functions\Gamma;
*/
class GammaTest extends \PHPUnit\Framework\TestCase
{
/**
* @testdox The gamma function can be approximated
* @covers phpOMS\Math\Functions\Gamma
* @group framework
*/
public function testGamma() : void
{
self::assertEqualsWithDelta(2.0, Gamma::gamma(3.0), 0.001);
self::assertEqualsWithDelta(11.631728, Gamma::gamma(4.5), 0.001);
}
/**
* @testdox The gamma function can be calculated for integers
* @covers phpOMS\Math\Functions\Gamma
@ -94,8 +105,59 @@ class GammaTest extends \PHPUnit\Framework\TestCase
self::assertTrue(true);
}
/**
* @testdox The log gamma function can be approximated
* @covers phpOMS\Math\Functions\Gamma
* @group framework
*/
public function testLogGamma() : void
{
self::markTestIncomplete();
$gsl = [
0.0, 0.0, 0.693147, 1.791759, 3.178053, 4.787491, 6.57925, 8.52516, 10.604602, 12.801827,
];
for ($i = 1; $i <= 10; ++$i) {
if (!(\abs($gsl[$i - 1] - Gamma::logGamma($i)) < 0.01)) {
self::assertTrue(false);
}
}
self::assertTrue(true);
}
/**
* @testdox The first incomplete gamma function can be approximated
* @covers phpOMS\Math\Functions\Gamma
* @group framework
*/
public function testFirstIncompleteGamma() : void
{
self::assertEqualsWithDelta(0.0, Gamma::incompleteGammaFirst(3.0, 0.0), 0.001);
self::assertEqualsWithDelta(1.523793, Gamma::incompleteGammaFirst(3.0, 4.0), 0.001);
self::assertEqualsWithDelta(2.116608, Gamma::incompleteGammaFirst(4.0, 3.0), 0.001);
}
/**
* @testdox The second incomplete gamma function can be approximated
* @covers phpOMS\Math\Functions\Gamma
* @group framework
*/
public function testSecondIncompleteGamma() : void
{
self::assertEqualsWithDelta(2.0, Gamma::incompleteGammaSecond(3.0, 0.0), 0.001);
self::assertEqualsWithDelta(0.476206, Gamma::incompleteGammaSecond(3.0, 4.0), 0.001);
self::assertEqualsWithDelta(3.883391, Gamma::incompleteGammaSecond(4.0, 3.0), 0.001);
}
/**
* @testdox The regularized incomplete gamma function can be approximated
* @covers phpOMS\Math\Functions\Gamma
* @group framework
*/
public function testRegularizedGamma() : void
{
self::assertEqualsWithDelta(0.0, Gamma::regularizedGamma(3.0, 0.0), 0.001);
self::assertEqualsWithDelta(0.761896, Gamma::regularizedGamma(3.0, 4.0), 0.001);
self::assertEqualsWithDelta(0.352768, Gamma::regularizedGamma(4.0, 3.0), 0.001);
}
}

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

@ -190,6 +190,24 @@ class LUDecompositionTest extends \PHPUnit\Framework\TestCase
);
}
/**
* @testdox The determinat can be calculated
* @covers phpOMS\Math\Matrix\LUDecomposition
* @group framework
*/
public function testDet() : void
{
$B = new Matrix();
$B->setMatrix([
[25, 15, -5],
[15, 17, 0],
[-5, 0, 11],
]);
$lu = new LUDecomposition($B);
self::assertEqualsWithDelta(1775.0, $lu->det(), 0.1);
}
/**
* @testdox A invalid vector throws a InvalidDimensionException
* @covers phpOMS\Math\Matrix\LUDecomposition

22
tests/Math/Numerics/Interpolation/CubicSplineInterpolationTest.php
View File

@ -65,4 +65,26 @@ class CubicSplineInterpolationTest extends \PHPUnit\Framework\TestCase
self::assertEqualsWithDelta(0.915345, $interpolation->interpolate(1.5), 0.1);
}
/**
* @testdox The spline interpolation for out of bounds values uses linear extrapolation
* @covers phpOMS\Math\Numerics\Interpolation\CubicSplineInterpolation
* @group framework
*/
public function testInterpolationUnderOverflow() : void
{
$interpolation = new CubicSplineInterpolation([
['x' => 0.1, 'y' => 0.1],
['x' => 0.4, 'y' => 0.7],
['x' => 1.2, 'y' => 0.6],
['x' => 1.8, 'y' => 1.1],
['x' => 2.0, 'y' => 0.9],
],
0.0, DerivativeType::SECOND,
0.0, DerivativeType::SECOND,
);
self::assertEqualsWithDelta(-0.140528, $interpolation->interpolate(0), 0.001);
self::assertEqualsWithDelta(-0.016007, $interpolation->interpolate(2.5), 0.001);
}
}

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

@ -109,4 +109,10 @@ class BernoulliDistributionTest extends \PHPUnit\Framework\TestCase
self::assertEqualsWithDelta(1 / ($p * $q), BernoulliDistribution::getFisherInformation($p), 0.01);
}
public function testInvalidPmfParameter() : void
{
$this->expectException(\InvalidArgumentException::class);
BernoulliDistribution::getPmf(0.7, 3);
}
}

16
tests/Math/Stochastic/Distribution/BetaDistributionTest.php
View File

@ -55,4 +55,20 @@ class BetaDistributionTest extends \PHPUnit\Framework\TestCase
{
self::assertEqualsWithDelta(-6 / 7, BetaDistribution::getExKurtosis(2.0, 2.0), 0.001);
}
public function testPdf() : void
{
self::assertEqualsWithDelta(0.9375, BetaDistribution::getPdf(0.5, 2, 5), 0.001);
}
public function testCdf() : void
{
self::assertEqualsWithDelta(0.890625, BetaDistribution::getCdf(0.5, 2, 5), 0.001);
}
public function testMgf() : void
{
self::assertEqualsWithDelta(1.0, BetaDistribution::getMgf(0, 2, 5), 0.001);
self::assertEqualsWithDelta(1.869356, BetaDistribution::getMgf(2, 2, 5), 0.001);
}
}

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

@ -103,6 +103,16 @@ class ChiSquaredDistributionTest extends \PHPUnit\Framework\TestCase
self::assertEquals((1 - 2 * $t) ** (-$df / 2), ChiSquaredDistribution::getMgf($df, $t));
}
public function testPdf() : void
{
self::assertEqualsWithDelta(0.20755, ChiSquaredDistribution::getPdf(2, 3), 0.001);
}
public function testCdf() : void
{
self::assertEqualsWithDelta(0.42759, ChiSquaredDistribution::getCdf(2, 3), 0.001);
}
public function testHypothesisSizeException() : void
{
$this->expectException(\Exception::class);

10
tests/Math/Stochastic/Distribution/FDistributionTest.php
View File

@ -53,4 +53,14 @@ class FDistributionTest extends \PHPUnit\Framework\TestCase
self::assertEquals(0.0, FDistribution::getSkewness(1, 6));
self::assertEquals(2 * (2 * 4 + 7 - 2) / (7 - 6) * \sqrt(2 * (7 - 4) / (4 * (7 + 4 - 2))), FDistribution::getSkewness(4, 7));
}
public function testPdf() : void
{
self::assertEqualsWithDelta(0.2788548, FDistribution::getPdf(1, 2, 3), 0.001);
}
public function testCdf() : void
{
self::assertEqualsWithDelta(0.5352419, FDistribution::getCdf(1, 2, 3), 0.001);
}
}

90
tests/Math/Stochastic/Distribution/GammaDistributionTest.php
View File

@ -21,25 +21,71 @@ use phpOMS\Math\Stochastic\Distribution\GammaDistribution;
*/
class GammaDistributionTest extends \PHPUnit\Framework\TestCase
{
public function testPDFIntegerK() : void
public function testPdfScale() : void
{
self::assertEqualsWithDelta(\exp(-1), GammaDistribution::getPdfIntegerK(1, 1, 1), 0.001);
self::assertEqualsWithDelta(3 * \exp(-3 / 4) / 16, GammaDistribution::getPdfIntegerK(3, 2, 4), 0.001);
self::assertEqualsWithDelta(0.0734, GammaDistribution::getPdfScale(10, 4, 3), 0.001);
}
public function testMeanK() : void
public function testPdfAlphaBete() : void
{
self::assertEqualsWithDelta(8, GammaDistribution::getMeanK(2, 4), 0.001);
self::assertEqualsWithDelta(0.180447, GammaDistribution::getPdfRate(2, 4, 1), 0.001);
}
public function testVarianceK() : void
public function testCdfScale() : void
{
self::assertEqualsWithDelta(32, GammaDistribution::getVarianceK(2, 4), 0.001);
self::assertEqualsWithDelta(0.42701, GammaDistribution::getCdfScale(10, 4, 3), 0.001);
}
public function testStandardDeviationK() : void
public function testCdfAlphaBete() : void
{
self::assertEqualsWithDelta(\sqrt(32), GammaDistribution::getStandardDeviationK(2, 4), 0.001);
self::assertEqualsWithDelta(0.142876, GammaDistribution::getCdfRate(2, 4, 1), 0.001);
}
public function testPdfIntegerScale() : void
{
self::assertEqualsWithDelta(\exp(-1), GammaDistribution::getPdfIntegerScale(1, 1, 1), 0.001);
self::assertEqualsWithDelta(3 * \exp(-3 / 4) / 16, GammaDistribution::getPdfIntegerScale(3, 2, 4), 0.001);
}
public function testPdfIntegerRate() : void
{
self::assertEqualsWithDelta(0.180447, GammaDistribution::getPdfIntegerRate(2, 4, 1), 0.001);
}
public function testMeanScale() : void
{
self::assertEqualsWithDelta(8, GammaDistribution::getMeanScale(2, 4), 0.001);
}
public function testMeanRate() : void
{
$alpha = 4;
$beta = 2;
self::assertEquals($alpha / $beta, GammaDistribution::getMeanRate($alpha, $beta));
}
public function testVarianceScale() : void
{
self::assertEqualsWithDelta(32, GammaDistribution::getVarianceScale(2, 4), 0.001);
}
public function testVarianceRate() : void
{
$alpha = 4;
$beta = 2;
self::assertEquals($alpha / \pow($beta, 2), GammaDistribution::getVarianceRate($alpha, $beta));
}
public function testStandardDeviationScale() : void
{
self::assertEqualsWithDelta(\sqrt(32), GammaDistribution::getStandardDeviationScale(2, 4), 0.001);
}
public function testStandardDeviationRate() : void
{
$alpha = 4;
$beta = 2;
self::assertEquals(\sqrt($alpha / \pow($beta, 2)), GammaDistribution::getStandardDeviationRate($alpha, $beta));
}
public function testExKurtosis() : void
@ -51,4 +97,30 @@ class GammaDistributionTest extends \PHPUnit\Framework\TestCase
{
self::assertEqualsWithDelta(\sqrt(2), GammaDistribution::getSkewness(2, 4), 0.001);
}
public function testMgfScale() : void
{
$theta = 2;
$t = 1 / $theta * 0.4;
$k = 3;
self::assertEquals(\pow(1 - $theta * $t, -$k), GammaDistribution::getMgfScale($k, $t, $theta));
}
public function testMgfRate() : void
{
$alpha = 4;
$beta = 3;
$t = 2;
self::assertEquals(\pow(1 - $t / $beta, -$alpha), GammaDistribution::getMgfRate($t, $alpha, $beta));
}
public function testModeScale() : void
{
self::assertEquals((3 - 1) * 2, GammaDistribution::getModeScale(3, 2));
}
public function testModeRate() : void
{
self::assertEquals((3 - 1) / 2, GammaDistribution::getModeRate(3, 2));
}
}

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

@ -83,4 +83,14 @@ class GeometricDistributionTest extends \PHPUnit\Framework\TestCase
self::assertEquals(\ceil(-1 / \log(1 - $p, 2)), GeometricDistribution::getMedian($p));
}
public function testMgf() : void
{
$p = 0.3;
$t1 = 2;
$t2 = -\log(1 - $p) * 0.8;
self::assertEquals($p / (1 - (1 - $p) * \exp($t1)), GeometricDistribution::getMgf($p, $t1));
self::assertEquals($p * \exp($t2) / (1 - (1 - $p) * \exp($t2)), GeometricDistribution::getMgf($p, $t2));
}
}

19
tests/Math/Stochastic/Distribution/HypergeometricDistributionTest.php
View File

@ -45,4 +45,23 @@ class HypergeometricDistributionTest extends \PHPUnit\Framework\TestCase
{
self::assertEqualsWithDelta(-0.247277, HypergeometricDistribution::getExKurtosis(15, 20, 12), 0.001);
}
public function testMode() : void
{
$N = 8;
$n = 4;
$K = 5;
self::assertEquals(3, HypergeometricDistribution::getMode($K, $N, $n));
}
public function testPmf() : void
{
self::assertEqualsWithDelta(0.146284, HypergeometricDistribution::getPmf(7, 20, 5, 10), 0.001);
}
public function testCdf() : void
{
self::assertEqualsWithDelta(0.97136, HypergeometricDistribution::getCdf(7, 20, 5, 10), 0.001);
}
}

49
tests/Math/Stochastic/Distribution/LogDistributionTest.php
View File

@ -14,6 +14,8 @@ declare(strict_types=1);
namespace phpOMS\tests\Math\Stochastic\Distribution;
use phpOMS\Math\Stochastic\Distribution\LogDistribution;
/**
* @internal
*/
@ -21,31 +23,66 @@ class LogDistributionTest extends \PHPUnit\Framework\TestCase
{
public function testPmf() : void
{
self::markTestIncomplete();
$p = 0.3;
$k = 4;
self::assertEquals(
-1 / \log(1 - $p) * $p ** $k / $k,
LogDistribution::getPmf($p, $k)
);
}
public function testCdf() : void
{
$p = 6 / 9;
$k = 2;
self::assertEqualsWithDelta(
0.8091,
LogDistribution::getCdf($p, $k), 0.001
);
}
public function testMean() : void
{
self::markTestIncomplete();
$p = 0.3;
self::assertEquals(-1 / \log(1 - $p) * $p / (1 - $p), LogDistribution::getMean($p));
}
public function testMode() : void
{
self::markTestIncomplete();
self::assertEquals(1, LogDistribution::getMode());
}
public function testVariance() : void
{
self::markTestIncomplete();
$p = 0.3;
self::assertEquals(
-($p ** 2 + $p * \log(1 - $p)) / ((1 - $p) ** 2 * (\log(1 - $p)) ** 2),
LogDistribution::getVariance($p)
);
}
public function testStandardDeviation() : void
{
self::markTestIncomplete();
$p = 0.3;
self::assertEquals(
\sqrt(-($p ** 2 + $p * \log(1 - $p)) / ((1 - $p) ** 2 * (\log(1 - $p)) ** 2)),
LogDistribution::getStandardDeviation($p)
);
}
public function testMgf() : void
{
self::markTestIncomplete();
$p = 0.3;
$t = 0.8;
self::assertEquals(
\log(1 - $p * \exp($t)) / \log(1 - $p),
LogDistribution::getMgf($p, $t)
);
}
}

60
tests/Math/Stochastic/Distribution/LogNormalDistributionTest.php
View File

@ -26,6 +26,11 @@ class LogNormalDistributionTest extends \PHPUnit\Framework\TestCase
self::assertEqualsWithDelta(0.060069054, LogNormalDistribution::getPdf(3, 2, 2), 0.001);
}
public function testCdf() : void
{
self::assertEqualsWithDelta(0.32610510, LogNormalDistribution::getCdf(3, 2, 2), 0.001);
}
public function testMean() : void
{
self::assertEqualsWithDelta(\exp(13 / 2), LogNormalDistribution::getMean(2, 3), 0.001);
@ -33,22 +38,67 @@ class LogNormalDistributionTest extends \PHPUnit\Framework\TestCase
public function testVariance() : void
{
self::assertEqualsWithDelta((\exp(9) - 1) * \exp(13), LogNormalDistribution::getVariance(2, 3), 0.001);
self::assertEqualsWithDelta(
(\exp(9) - 1) * \exp(13),
LogNormalDistribution::getVariance(2, 3), 0.001
);
}
public function testStandardDeviation() : void
{
self::assertEqualsWithDelta(\exp(13 / 2) * \sqrt(\exp(9) - 1), LogNormalDistribution::getStandardDeviation(2, 3), 0.001);
self::assertEqualsWithDelta(\sqrt((\exp(9) - 1) * \exp(13)), LogNormalDistribution::getStandardDeviation(2, 3), 0.001);
self::assertEqualsWithDelta(
\exp(13 / 2) * \sqrt(\exp(9) - 1),
LogNormalDistribution::getStandardDeviation(2, 3), 0.001
);
self::assertEqualsWithDelta(
\sqrt((\exp(9) - 1) * \exp(13)),
LogNormalDistribution::getStandardDeviation(2, 3), 0.001
);
}
public function testSkewness() : void
{
self::assertEqualsWithDelta(\sqrt(\exp(9) - 1) * (\exp(9) + 2), LogNormalDistribution::getSkewness(3), 0.001);
self::assertEqualsWithDelta(
\sqrt(\exp(9) - 1) * (\exp(9) + 2),
LogNormalDistribution::getSkewness(3), 0.001
);
}
public function testExKurtosis() : void
{
self::assertEqualsWithDelta(\exp(16) + 2 * \exp(12) + 3 * \exp(8) - 6, LogNormalDistribution::getExKurtosis(2), 0.001);
self::assertEqualsWithDelta(
\exp(16) + 2 * \exp(12) + 3 * \exp(8) - 6,
LogNormalDistribution::getExKurtosis(2), 0.001
);
}
public function testMedian() : void
{
self::assertEquals(\exp(3), LogNormalDistribution::getMedian(3));
}
public function testMode() : void
{
self::assertEquals(\exp(3 - 4 ** 2), LogNormalDistribution::getMode(3, 4));
}
public function testEntropy() : void
{
self::assertEqualsWithDelta(
\log(4 * \exp(3 + 0.5) * \sqrt(2 * \M_PI), 2),
LogNormalDistribution::getEntropy(3, 4), 0.001
);
}
public function testFisherInformation() : void
{
self::assertEquals(
[
[1 / 3 ** 2, 0],
[0, 1 / (2 * 3 ** 4)],
],
LogNormalDistribution::getFisherInformation(3)
);
}
}

45
tests/Math/Stochastic/Distribution/LogisticDistributionTest.php
View File

@ -14,6 +14,8 @@ declare(strict_types=1);
namespace phpOMS\tests\Math\Stochastic\Distribution;
use phpOMS\Math\Stochastic\Distribution\LogisticDistribution;
/**
* @internal
*/
@ -21,51 +23,74 @@ class LogisticDistributionTest extends \PHPUnit\Framework\TestCase
{
public function testPdf() : void
{
self::markTestIncomplete();
$x = 3;
$mu = 5;
$s = 2;
self::assertEquals(
\exp(-($x - $mu) / $s) / ($s * (1 + \exp(-($x - $mu) / $s)) ** 2),
LogisticDistribution::getPdf($x, $mu, $s)
);
}
public function testCdf() : void
{
self::markTestIncomplete();
$x = 3;
$mu = 5;
$s = 2;
self::assertEquals(
1 / (1 + \exp(-($x - $mu) / $s)),
LogisticDistribution::getCdf($x, $mu, $s)
);
}
public function testMode() : void
{
self::markTestIncomplete();
self::assertEquals(3, LogisticDistribution::getMode(3));
}
public function testMean() : void
{
self::markTestIncomplete();
self::assertEquals(3, LogisticDistribution::getMean(3));
}
public function testMedian() : void
{
self::markTestIncomplete();
self::assertEquals(3, LogisticDistribution::getMedian(3));
}
public function testVariance() : void
{
self::markTestIncomplete();
$s = 3;
self::assertEquals(
$s ** 2 * \M_PI ** 2 / 3,
LogisticDistribution::getVariance($s)
);
}
public function testStandardDeviation() : void
{
self::markTestIncomplete();
$s = 3;
self::assertEquals(
\sqrt($s ** 2 * \M_PI ** 2 / 3),
LogisticDistribution::getStandardDeviation($s)
);
}
public function testSkewness() : void
{
self::markTestIncomplete();
self::assertEquals(0, LogisticDistribution::getSkewness());
}
public function testExKurtosis() : void
{
self::markTestIncomplete();
self::assertEquals(6 / 5, LogisticDistribution::getExKurtosis());
}
public function testEntropy() : void
{
self::markTestIncomplete();
$s = 3;
self::assertEquals(\log($s) + 2, LogisticDistribution::getEntropy($s));
}
}

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

@ -93,4 +93,27 @@ class NormalDistributionTest extends \PHPUnit\Framework\TestCase
{
self::assertEqualsWithDelta(384.16, NormalDistribution::getSampleSizeFromInfinitePopulation(NormalDistribution::TABLE['0.95'], 0.05, 0.5), 0.01);
}
public function testMgf() : void
{
$t = 3;
$mu = 4;
$sigma = 5;
self::assertEquals(
\exp($mu * $t + $sigma ** 2 * $t **2 / 2),
NormalDistribution::getMgf($t, $mu, $sigma)
);
}
public function testFisherInformation() : void
{
self::assertEquals(
[
[1 / 3 ** 2, 0],
[0, 1 / (2 * 3 ** 4)],
],
NormalDistribution::getFisherInformation(3)
);
}
}

29
tests/Math/Stochastic/Distribution/ParetoDistributionTest.php
View File

@ -59,4 +59,33 @@ class ParetoDistributionTest extends \PHPUnit\Framework\TestCase
self::assertEqualsWithDelta(3.810317377662722, ParetoDistribution::getSkewness(6, 5), 0.001);
self::assertEquals(0.0, ParetoDistribution::getSkewness(3));
}
public function testMedian() : void
{
self::assertEquals(3 * \pow(2, 1 / 4), ParetoDistribution::getMedian(3, 4));
}
public function testMode() : void
{
self::assertEquals(3, ParetoDistribution::getMode(3));
}
public function testEntropy() : void
{
self::assertEquals(
\log(3 / 4 * \exp(1 + 1 / 4)),
ParetoDistribution::getEntropy(3, 4)
);
}
public function testFisherInformation() : void
{
self::assertEquals(
[
[4 / (3 ** 2), -1 / 3],
[-1 / 3, 1 / (4 ** 2)],
],
ParetoDistribution::getFisherInformation(3, 4)
);
}
}

8
tests/Math/Stochastic/Distribution/TDistributionTest.php
View File

@ -58,4 +58,12 @@ class TDistributionTest extends \PHPUnit\Framework\TestCase
{
self::assertEquals(0, TDistribution::getSkewness());
}
public function testCdf() : void
{
self::assertEqualsWithDelta(0.0, TDistribution::getCdf(1.25, 5, 0), 0.001);
self::assertEqualsWithDelta(0.86669, TDistribution::getCdf(1.25, 5, 1), 0.001);
self::assertEqualsWithDelta(0.78867, TDistribution::getCdf(1.0, 2, 1), 0.001);
self::assertEqualsWithDelta(0.4226, TDistribution::getCdf(1.0, 2, 2), 0.001);
}
}

9
tests/Math/Stochastic/Distribution/UniformDistributionContinuousTest.php
View File

@ -97,4 +97,13 @@ class UniformDistributionContinuousTest extends \PHPUnit\Framework\TestCase
{
self::assertEquals(-6 / 5, UniformDistributionContinuous::getExKurtosis());
}
public function testMgf() : void
{
self::assertEquals(1, UniformDistributionContinuous::getMgf(0, 2, 3));
self::assertEquals(
(\exp(2 * 4) - \exp(2 *3)) / (2 * (4 - 3)),
UniformDistributionContinuous::getMgf(2, 3, 4)
);
}
}

8
tests/Math/Stochastic/Distribution/UniformDistributionDiscreteTest.php
View File

@ -84,6 +84,14 @@ class UniformDistributionDiscreteTest extends \PHPUnit\Framework\TestCase
self::assertEquals(-(6 * ($n ** 2 + 1)) / (5 * ($n ** 2 - 1)), UniformDistributionDiscrete::getExKurtosis($a, $b));
}
public function testMgf() : void
{
self::assertEquals(
(\exp(3 * 2) - \exp((4 + 1) * 2)) / ((4 - 3 + 1) * (1 - \exp(2))),
UniformDistributionDiscrete::getMgf(2, 3, 4)
);
}
public function testCdfExceptionUpper() : void
{
$this->expectException(\OutOfBoundsException::class);

35
tests/Math/Stochastic/Distribution/WeibullDistributionTest.php
View File

@ -32,4 +32,39 @@ class WeibullDistributionTest extends \PHPUnit\Framework\TestCase
self::assertEqualsWithDelta(0.430217175, WeibullDistribution::getCdf(3, 4, 2), 0.001);
self::assertEqualsWithDelta(0.0, WeibullDistribution::getCdf(-1, 4, 2), 0.001);
}
public function testMean() : void
{
self::assertEqualsWithDelta(3.54490771, WeibullDistribution::getMean(4, 2), 0.001);
}
public function testMedian() : void
{
self::assertEqualsWithDelta(3.33021844, WeibullDistribution::getMedian(4, 2), 0.001);
}
public function testMode() : void
{
self::assertEqualsWithDelta(2.82842712, WeibullDistribution::getMode(4, 2), 0.001);
}
public function testVariance() : void
{
self::assertEqualsWithDelta(3.43362932, WeibullDistribution::getVariance(4, 2), 0.001);
}
public function testStandardDeviation() : void
{
self::assertEqualsWithDelta(\sqrt(3.43362932), WeibullDistribution::getStandardDeviation(4, 2), 0.001);
}
public function testEntropy() : void
{
self::assertEqualsWithDelta(1.981755, WeibullDistribution::getEntropy(4, 2), 0.001);
}
public function testSkewness() : void
{
self::assertEqualsWithDelta(0.631110, WeibullDistribution::getSkewness(4, 2), 0.001);
}
}

22
tests/Math/Stochastic/Distribution/ZTestTest.php
View File

@ -14,12 +14,14 @@ declare(strict_types=1);
namespace phpOMS\tests\Math\Stochastic\Distribution;
use phpOMS\Math\Stochastic\Distribution\ZTest;
use phpOMS\Math\Statistic\Average;
use phpOMS\Math\Statistic\MeasureOfDispersion;
use phpOMS\Math\Stochastic\Distribution\ZTesting;
/**
* @internal
*/
class ZTestTest extends \PHPUnit\Framework\TestCase
class ZTestingTest extends \PHPUnit\Framework\TestCase
{
// http://sphweb.bumc.bu.edu/otlt/MPH-Modules/BS/BS704_HypothesisTesting-ChiSquare/BS704_HypothesisTesting-ChiSquare_print.html
public function testHypothesisFalse() : void
@ -29,14 +31,22 @@ class ZTestTest extends \PHPUnit\Framework\TestCase
$expected = 0.75;
$total = 125; // total count of observed sample size
self::assertFalse(ZTest::testHypothesis($observed, $expected, $total, $a));
self::assertFalse(ZTesting::testHypothesis($observed, $expected, $total, $a));
}
// https://support.microsoft.com/en-us/office/z-test-function-d633d5a3-2031-4614-a016-92180ad82bee?ui=en-us&rs=en-us&ad=us
public function testZTest() : void
{
//self::assertEqualsWithDelta(0.090574, ZTest::zTest(4, [3, 6, 7, 8, 6, 5, 4, 2, 1, 9]), 0.001);
self::markTestIncomplete();
self::assertTrue(true);
self::assertEqualsWithDelta(0.090574, ZTesting::zTest(4, [3, 6, 7, 8, 6, 5, 4, 2, 1, 9]), 0.001);
}
public function testZTestValues() : void
{
$data = [3, 6, 7, 8, 6, 5, 4, 2, 1, 9];
$mean = Average::arithmeticMean($data);
$size = \count($data);
$sig = MeasureOfDispersion::standardDeviationSample($data);
self::assertEqualsWithDelta(0.090574, ZTesting::zTestValues(4, $mean, $size, $sig), 0.001);
}
}