function risingFactorial( x, n ) {
	var result;
	var inv;

	if ( isnan( x ) || !isInteger( n ) ) {
		return NaN;
	}
	if ( x < 0.0 ) {
		// For `x < 0`, 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:
		if ( n < 0.0 ) {
			x += n;
			n = -n;
			inv = true;
		}
		result = ( (n&1) ? -1.0 : 1.0 ) * fallingFactorial( -x, n );
		if ( inv ) {
			result = 1.0 / result;
		}
		return result;
	}
	if ( n === 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 ) {
		result = gammaDeltaRatio( 1.0-x, -n );
		return ( n&1 ) ? -result : result;
	}
	// We don't optimize this for small `n`, because `gammaDeltaRatio` is already optimized for that use case:
	return 1.0 / gammaDeltaRatio( x, n );
}
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

@example
var v = risingFactorial( 0.9, 5 );
// returns ~94.766

@example
var v = risingFactorial( -9.0, 3 );
// returns -504.0

@example
var v = risingFactorial( 0.0, 2 );
// returns 0.0

@example
var v = risingFactorial( 3.0, -2 );
// returns 0.5