@stdlib/stats
Version:
Standard library statistical functions.
141 lines (130 loc) • 4.25 kB
JavaScript
/**
* @license Apache-2.0
*
* Copyright (c) 2018 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*
* ## Notice
*
* The original C++ code and copyright notice are from the [Boost library]{@link http://www.boost.org/doc/libs/1_64_0/boost/math/special_functions/gamma.hpp}. The implementation has been modified for JavaScript.
*
* ```text
* Copyright John Maddock 2006-7, 2013-14.
* Copyright Paul A. Bristow 2007, 2013-14.
* Copyright Nikhar Agrawal 2013-14.
* Copyright Christopher Kormanyos 2013-14.
*
* Use, modification and distribution are subject to the
* Boost Software License, Version 1.0. (See accompanying file
* LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
* ```
*/
'use strict';
// MODULES //
var lanczosSumExpGScaled = require( '/math/base/special/gamma-lanczos-sum-expg-scaled' );
var gammaln = require( '/math/base/special/gammaln' );
var gamma = require( '/math/base/special/gamma' );
var log1p = require( '/math/base/special/log1p' );
var sqrt = require( '/math/base/special/sqrt' );
var abs = require( '/math/base/special/abs' );
var exp = require( '/math/base/special/exp' );
var pow = require( '/math/base/special/pow' );
var max = require( '/math/base/special/max' );
var min = require( '/math/base/special/min' );
var ln = require( '/math/base/special/ln' );
var MAX_LN = require( '/constants/float64/max-ln' );
var MIN_LN = require( '/constants/float64/min-ln' );
var G = require( '/constants/float64/gamma-lanczos-g' );
var E = require( '/constants/float64/e' );
// MAIN //
/**
* Computes `(z^a)*(e^-z) / gamma(a)`.
*
* @private
* @param {number} a - input value
* @param {number} z - input value
* @returns {number} function value
*/
function regularisedGammaPrefix( a, z ) {
var prefix;
var amza;
var agh;
var alz;
var amz;
var sq;
var d;
agh = a + G - 0.5;
d = ( (z - a) - G + 0.5 ) / agh;
if ( a < 1.0 ) {
// Treat a < 1 as a special case because our Lanczos approximations are optimized against the factorials with a > 1, and for high precision types very small values of `a` can give rather erroneous results for gamma:
if ( z <= MIN_LN ) {
// Use logs, so should be free of cancellation errors:
return exp( ( a * ln(z) ) - z - gammaln( a ) );
}
// No danger of overflow as gamma(a) < 1/a for small a, so direct calculation:
return pow( z, a ) * exp( -z ) / gamma( a );
}
if ( abs(d*d*a) <= 100.0 && a > 150.0 ) {
// Special case for large a and a ~ z:
prefix = ( a * ( log1p( d ) - d ) ) + ( z * ( 0.5-G ) / agh );
prefix = exp( prefix );
}
else {
// General case. Direct computation is most accurate, but use various fallbacks for different parts of the problem domain:
alz = a * ln(z / agh);
amz = a - z;
if (
min(alz, amz) <= MIN_LN ||
max(alz, amz) >= MAX_LN
) {
amza = amz / a;
if (
min(alz, amz)/2.0 > MIN_LN &&
max(alz, amz)/2.0 < MAX_LN
) {
// Compute square root of the result and then square it:
sq = pow( z / agh, a / 2.0 ) * exp( amz / 2.0 );
prefix = sq * sq;
}
else if (
min(alz, amz)/4.0 > MIN_LN &&
max(alz, amz)/4.0 < MAX_LN &&
z > a
) {
// Compute the 4th root of the result then square it twice:
sq = pow( z / agh, a / 4.0 ) * exp( amz / 4.0 );
prefix = sq * sq;
prefix *= prefix;
}
else if (
amza > MIN_LN &&
amza < MAX_LN
) {
prefix = pow( (z * exp(amza)) / agh, a );
}
else {
prefix = exp( alz + amz );
}
}
else
{
prefix = pow( z / agh, a ) * exp( amz );
}
}
prefix *= sqrt( agh / E ) / lanczosSumExpGScaled( a );
return prefix;
}
// EXPORTS //
module.exports = regularisedGammaPrefix;