11    private const EPS = 2.22e-16;
 
   15    private const SQRT2PI = 2.5066282746310005024157652848110452530069867406099;
 
   25        return (1 / ($b ** $a * self::gammaValue($a))) * $value ** ($a - 1) * exp(0 - ($value / $b));
 
   28    protected static function calculateInverse(
float $probability, 
float $alpha, 
float $beta)
 
   31        $xHi = $alpha * $beta * 5;
 
   40            $error = 
$result - $probability;
 
   44            } elseif ($error < 0.0) {
 
   60            if (($xNew < $xLo) || ($xNew > $xHi) || (
$pdf == 0.0)) {
 
   61                $xNew = ($xLo + $xHi) / 2;
 
   67        if (
$i === self::MAX_ITERATIONS) {
 
   81        for (
$n = 0; 
$n <= $max; ++
$n) {
 
   84                $divisor *= ($a + 
$i);
 
   86            $summer += (
$x ** 
$n / $divisor);
 
   89        return $x ** $a * exp(0 - 
$x) * $summer;
 
  101        static $p0 = 1.000000000190015;
 
  103            1 => 76.18009172947146,
 
  104            2 => -86.50532032941677,
 
  105            3 => 24.01409824083091,
 
  106            4 => -1.231739572450155,
 
  107            5 => 1.208650973866179e-3,
 
  108            6 => -5.395239384953e-6,
 
  113        $tmp -= (
$x + 0.5) * log($tmp);
 
  116        for ($j = 1; $j <= 6; ++$j) {
 
  117            $summer += ($p[$j] / ++
$y);
 
  120        return exp(0 - $tmp + log(self::SQRT2PI * $summer / 
$x));
 
  169    private const  LG_D1 = -0.5772156649015328605195174;
 
  171    private const LG_D2 = 0.4227843350984671393993777;
 
  173    private const LG_D4 = 1.791759469228055000094023;
 
  176        4.945235359296727046734888,
 
  177        201.8112620856775083915565,
 
  178        2290.838373831346393026739,
 
  179        11319.67205903380828685045,
 
  180        28557.24635671635335736389,
 
  181        38484.96228443793359990269,
 
  182        26377.48787624195437963534,
 
  183        7225.813979700288197698961,
 
  187        4.974607845568932035012064,
 
  188        542.4138599891070494101986,
 
  189        15506.93864978364947665077,
 
  190        184793.2904445632425417223,
 
  191        1088204.76946882876749847,
 
  192        3338152.967987029735917223,
 
  193        5106661.678927352456275255,
 
  194        3074109.054850539556250927,
 
  198        14745.02166059939948905062,
 
  199        2426813.369486704502836312,
 
  200        121475557.4045093227939592,
 
  201        2663432449.630976949898078,
 
  202        29403789566.34553899906876,
 
  203        170266573776.5398868392998,
 
  204        492612579337.743088758812,
 
  205        560625185622.3951465078242,
 
  209        67.48212550303777196073036,
 
  210        1113.332393857199323513008,
 
  211        7738.757056935398733233834,
 
  212        27639.87074403340708898585,
 
  213        54993.10206226157329794414,
 
  214        61611.22180066002127833352,
 
  215        36351.27591501940507276287,
 
  216        8785.536302431013170870835,
 
  220        183.0328399370592604055942,
 
  221        7765.049321445005871323047,
 
  222        133190.3827966074194402448,
 
  223        1136705.821321969608938755,
 
  224        5267964.117437946917577538,
 
  225        13467014.54311101692290052,
 
  226        17827365.30353274213975932,
 
  227        9533095.591844353613395747,
 
  231        2690.530175870899333379843,
 
  232        639388.5654300092398984238,
 
  233        41355999.30241388052042842,
 
  234        1120872109.61614794137657,
 
  235        14886137286.78813811542398,
 
  236        101680358627.2438228077304,
 
  237        341747634550.7377132798597,
 
  238        446315818741.9713286462081,
 
  244        -5.952379913043012e-4,
 
  245        7.93650793500350248e-4,
 
  246        -0.002777777777777681622553,
 
  247        0.08333333333333333331554247,
 
  263        if (
$x == self::$logGammaCacheX) {
 
  268        if (
$y > 0.0 && 
$y <= self::LOG_GAMMA_X_MAX_VALUE) {
 
  269            if (
$y <= self::EPS) {
 
  271            } elseif (
$y <= 1.5) {
 
  273            } elseif (
$y <= 4.0) {
 
  275            } elseif (
$y <= 12.0) {
 
  290        self::$logGammaCacheX = 
$x;
 
  291        self::$logGammaCacheResult = 
$res;
 
  301        if (
$y < self::PNT68) {
 
  311        if ($y <= 0.5 || $y >= self::PNT68) {
 
  312            for (
$i = 0; 
$i < 8; ++
$i) {
 
  313                $xnum = $xnum * $xm1 + self::LG_P1[
$i];
 
  314                $xden = $xden * $xm1 + self::LG_Q1[
$i];
 
  317            return $corr + $xm1 * (self::LG_D1 + $xm1 * ($xnum / $xden));
 
  321        for (
$i = 0; 
$i < 8; ++
$i) {
 
  322            $xnum = $xnum * $xm2 + self::LG_P2[
$i];
 
  323            $xden = $xden * $xm2 + self::LG_Q2[
$i];
 
  326        return $corr + $xm2 * (self::LG_D2 + $xm2 * ($xnum / $xden));
 
  337        for (
$i = 0; 
$i < 8; ++
$i) {
 
  338            $xnum = $xnum * $xm2 + self::LG_P2[
$i];
 
  339            $xden = $xden * $xm2 + self::LG_Q2[
$i];
 
  342        return $xm2 * (self::LG_D2 + $xm2 * ($xnum / $xden));
 
  353        for (
$i = 0; 
$i < 8; ++
$i) {
 
  354            $xnum = $xnum * $xm4 + self::LG_P4[
$i];
 
  355            $xden = $xden * $xm4 + self::LG_Q4[
$i];
 
  358        return self::LG_D4 + $xm4 * ($xnum / $xden);
 
  367        if (
$y <= self::LG_FRTBIG) {
 
  368            $res = self::LG_C[6];
 
  370            for (
$i = 0; 
$i < 6; ++
$i) {
 
  375            $res = 
$res + log(self::SQRT2PI) - 0.5 * $corr;
 
  376            $res += 
$y * ($corr - 1.0);
 
An exception for terminatinating execution or to throw for unit testing.
const LOG_GAMMA_X_MAX_VALUE
static logGamma4(float $y)
static logGamma(float $x)
static calculateDistribution(float $value, float $a, float $b, bool $cumulative)
static gammaValue(float $value)
static $logGammaCacheResult
const LG_D1
logGamma function.
static incompleteGamma(float $a, float $x)
static logGamma1(float $y)
static logGamma3(float $y)
static logGamma2(float $y)
static calculateInverse(float $probability, float $alpha, float $beta)
foreach($_POST as $key=> $value) $res