'use strict';

/*
* The original C++ code and copyright notice is from the [Boost library]{@link http://www.boost.org/doc/libs/1_64_0/boost/math/special_functions/factorials.hpp}.
*
* The implementation has been modified for JavaScript.
*/

/*
* (C) Copyright John Maddock 2006, 2010.
* 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)
*/

// MODULES //

var isNonNegativeInteger = require( '@stdlib/math/base/assert/is-nonnegative-integer' );
var isInteger = require( '@stdlib/math/base/assert/is-integer' );
var isnan = require( '@stdlib/math/base/assert/is-nan' );
var floor = require( '@stdlib/math/base/special/floor' );
var abs = require( '@stdlib/math/base/special/abs' );
var FLOAT64_MAX = require( '@stdlib/math/constants/float64-max' );
var PINF = require( '@stdlib/math/constants/float64-pinf' );
var gammaDeltaRatio = require( './tgamma_delta_ratio.js' );


// VARIABLES //

var MAX_FACTORIAL = 170;


// FUNCTIONS //

/**
* Computes the rising factorial of x and n.
*
* ## Notes
*
* * The rising factorial is defined as
*
*   ``` tex
*   \operatorname{risingFactorial}(x, n) = x (x-1) (x-2) (x-3) \ldots (x-n+1)
*   ```
*
*   or equivalently
*
*   ``` tex
*   \operatorname{risingFactorial}(x, n) = \frac{ \Gamma(x + n) }{ \Gamma(x) };
*   ```
*
* @private
* @param {number} x - first function parameter
* @param {integer} n - second function parameter
* @returns {number} function value
*/
function risingFactorial( x, n ) {
	var result;
	var inv;
	var val;

	if ( isnan( x ) || !isInteger( n ) ) {
		return NaN;
	}
	if ( x < 0.0 ) {
		// For x less than zero, we really have a falling factorial, modulo a possible change of sign. Note that the falling factorial isn't defined for negative n, so we'll get rid of that case first:
		inv = false;
		if ( n < 0.0 ) {
			x += n;
			n = -n;
			inv = true;
		}
		result = ( (n&1) ? -1 : 1 ) * fallingFactorial( -x, n );
		if ( inv ) {
			result = 1.0 / result;
		}
		return result;
	}
	if ( n === 0.0 ) {
		return 1.0;
	}
	if ( x === 0.0 ) {
		if ( n < 0 ) {
			return -gammaDeltaRatio( x + 1.0, -n );
		}
		return 0.0;
	}
	if ( x < 1.0 && x + n < 0.0 ) {
		val = gammaDeltaRatio( 1.0 - x, -n );
		return ( n & 1 ) ? -val : val;
	}
	// We don't optimise this for small n, because gammaDeltaRatio is already optimized for that use case:
	return 1.0 / gammaDeltaRatio( x, n );
} // end FUNCTION risingFactorial()


// MAIN //

/**
* Computes the falling factorial of x and n.
*
* ## Notes
*
* * The falling factorial is defined as
*
*   ``` tex
*   \operatorname{fallingFactorial}(x, n) = x (x-1) (x-2) (x-3) \ldots (x-n+1)
*   ```
*
* @param {number} x - first function parameter
* @param {PositiveInteger} n - second function parameter
* @returns {number} function value
*
* @example
* var v = fallingFactorial( 0.9, 5 );
* // returns ~0.644
*
* @example
* var v = fallingFactorial( -9.0, 3 );
* // returns -990
*
* @example
* var v = fallingFactorial( 0.0, 2 );
* // returns 0.0
*
* @example
* var v = fallingFactorial( 3.0, -2 );
* // returns NaN
*/
function fallingFactorial( x, n ) {
	var result;
	var xp1;
	var n2;
	var t1;
	var t2;

	if ( isnan( x ) || !isNonNegativeInteger( n ) ) {
		return NaN;
	}
	if ( x === 0.0 ) {
		return 0.0;
	}
	if ( x < 0 ) {
		// For x < 0 we really have a rising factorial modulo a possible change of sign:
		return ( n&1 ? -1 : 1 ) * risingFactorial( -x, n );
	}
	if ( n === 0 ) {
		return 1.0;
	}
	if ( x < 0.5 ) {
		// 1 + x below will throw away digits, so split up calculation:
		if ( n > MAX_FACTORIAL - 2 ) {
			// If the two end of the range are far apart we have a ratio of two very large numbers, split the calculation up into two blocks:
			t1 = x * fallingFactorial( x - 1, MAX_FACTORIAL - 2 );
			t2 = fallingFactorial( x-MAX_FACTORIAL+1, n-MAX_FACTORIAL+1 );
			if ( FLOAT64_MAX / abs(t1) < abs(t2) ) {
				return PINF;
			}
			return t1 * t2;
		}
		return x * fallingFactorial( x - 1.0, n - 1.0 );
	}
	if ( x <= n - 1.0 ) {
		// `x+1-n` will be negative and gammaDeltaRatio won't handle it, split the product up into three parts:
		xp1 = x + 1.0;
		n2 = abs( floor( xp1 ) );
		if ( n2 === xp1 ) {
			return 0.0;
		}
		result = gammaDeltaRatio( xp1, -n2 );
		x -= n2;
		result *= x;
		n2 += 1.0;
		if ( n2 < n ) {
			result *= fallingFactorial( x - 1.0, n - n2 );
		}
		return result;
	}
	// Simple case: just the ratio of two (positive argument) gamma functions. Note that we don't optimise this for small n, because gammaDeltaRatio is already optimized for that use case:
	return gammaDeltaRatio( x + 1.0, -n );
} // end FUNCTION fallingFactorial()


// EXPORTS //

module.exports = fallingFactorial;

@@ -2320,33 +2320,33 @@
  We don't optimi
-s
+z
 e this for small
@@ -2770,12 +2770,15 @@
 am %7B
-Posi
+NonNega
 tive
@@ -4519,17 +4519,17 @@
 t optimi
-s
+z
 e this f

Fix JSDoc annotation and wording