chore: apply suggestions from review

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: passed
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: passed
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: passed
  - task: lint_c_examples
    status: passed
  - task: lint_c_benchmarks
    status: passed
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: anandkaranubc

lib/node_modules/@stdlib/math/base/special/rising-factorial/README.md

@@ -20,7 +20,7 @@ limitations under the License.
 
 # Rising Factorial
 
-Compute the [rising factorial][rising-and-rising-factorials].
+> Compute the [rising factorial][falling-and-rising-factorials].
 
 <section class="intro">
 
@@ -38,7 +38,7 @@ var risingFactorial = require( '@stdlib/math/base/special/rising-factorial' );
 
 #### risingFactorial( x, n )
 
-Evaluates the [rising factorial][rising-and-rising-factorials] of `x` and `n`.
+Evaluates the [rising factorial][falling-and-rising-factorials] of `x` and `n`.
 
 ```javascript
 var v = risingFactorial( 0.9, 5 );
@@ -128,7 +128,7 @@ for ( i = 0; i < 100; i++ ) {
 
 #### stdlib_base_rising_factorial( x, n )
 
-Evaluates the rising factorial of `x` and `n`.
+Evaluates the [rising factorial][falling-and-rising-factorials] of `x` and `n`.
 
 ```c
 double out = stdlib_base_rising_factorial( 0.9, 5 );
@@ -148,26 +148,37 @@ double stdlib_base_rising_factorial( const double x, const int32_t n );
 ```
 
 </section>
+
 <!-- /.usage -->
+
 <!-- C API usage notes. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
 <section class="notes">
+
 </section>
+
 <!-- /.notes -->
+
 <!-- C API usage examples. -->
+
 <section class="examples">
+
 ### Examples
+
 ```c
 #include "stdlib/math/base/special/rising_factorial.h"
 #include <stdio.h>
 #include <stdint.h>
+
 int main( void ) {
     const double x[] = { -10.0, -7.78, -5.56, -3.33, -1.11, 1.11, 3.33, 5.56, 7.78, 10.0 };
     const int32_t n[] = { 5, 4, 3, 2, 1, 0, -1, -2, -3, -4 };
+
     double v;
     int i;
     for ( i = 0; i < 10; i++ ) {
         v = stdlib_base_rising_factorial( x[ i ], n[ i ] );
-        printf( "x: %lf, n: %d, rising_factorial(x,n): %lf\n", x[ i ], n[ i ], v );
+        printf( "risingFactorial(%lf, %d) = %lf\n", x[ i ], n[ i ], v );
     }
 }
 ```
@@ -188,7 +199,7 @@ int main( void ) {
 
 ## See Also
 
--   <span class="package-name">[`@stdlib/math/base/special/rising-factorial`][@stdlib/math/base/special/rising-factorial]</span><span class="delimiter">: </span><span class="description">compute the rising factorial.</span>
+-   <span class="package-name">[`@stdlib/math/base/special/falling-factorial`][@stdlib/math/base/special/falling-factorial]</span><span class="delimiter">: </span><span class="description">compute the falling factorial.</span>
 
 </section>
 
@@ -198,11 +209,11 @@ int main( void ) {
 
 <section class="links">
 
-[rising-and-rising-factorials]: https://en.wikipedia.org/wiki/rising_and_rising_factorials
+[falling-and-rising-factorials]: https://en.wikipedia.org/wiki/Falling_and_rising_factorials
 
 <!-- <related-links> -->
 
-[@stdlib/math/base/special/rising-factorial]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/math/base/special/rising-factorial
+[@stdlib/math/base/special/falling-factorial]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/math/base/special/falling-factorial
 
 <!-- </related-links> -->
 

lib/node_modules/@stdlib/math/base/special/rising-factorial/benchmark/benchmark.native.js

@@ -22,7 +22,7 @@
 
 var resolve = require( 'path' ).resolve;
 var bench = require( '@stdlib/bench' );
-var randu = require( '@stdlib/random/array/uniform' );
+var uniform = require( '@stdlib/random/array/uniform' );
 var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var tryRequire = require( '@stdlib/utils/try-require' );
@@ -39,18 +39,18 @@ var opts = {
 
 // MAIN //
 
-bench( pkg, opts, function benchmark( b ) {
+bench( pkg+'::native', opts, function benchmark( b ) {
 	var x;
 	var n;
 	var y;
 	var i;
 
-	x = randu( 100, 1.0, 41.0 );
-	n = discreteUniform( 100, 0, 40 );
+	x = uniform( 100, -50.0, 50.0 );
+	n = discreteUniform( 100, -50, 50 );
 
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
-		y = risingFactorial( x[ i % x.length ], n[ i % n.length ] );
+		y = risingFactorial( x[ i%x.length ], n[ i%n.length ] );
 		if ( isnan( y ) ) {
 			b.fail( 'should not return NaN' );
 		}

lib/node_modules/@stdlib/math/base/special/rising-factorial/benchmark/c/native/benchmark.c

@@ -18,6 +18,7 @@
 
 #include "stdlib/math/base/special/rising_factorial.h"
 #include <stdlib.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 #include <time.h>
@@ -98,13 +99,13 @@ static double benchmark( void ) {
 	int i;
 
 	for ( i = 0; i < 100; i++ ) {
-		x[ i ] = ( 40.0 * rand_double() ) + 1.0;
-		n[ i ] = (int32_t)( 41.0 * rand_double() );
+		x[ i ] = ( 100.0*rand_double() ) - 50.0;
+		n[ i ] = (int32_t)( 50.0*rand_double() );
 	}
 
 	t = tic();
 	for ( i = 0; i < ITERATIONS; i++ ) {
-		y = stdlib_base_rising_factorial( x[ i % 100 ], n[ i % 100 ] );
+		y = stdlib_base_rising_factorial( x[ i%100 ], n[ i%100 ] );
 		if ( y != y ) {
 			printf( "should return a nonnegative integer\n" );
 			break;

lib/node_modules/@stdlib/math/base/special/rising-factorial/examples/c/example.c

@@ -28,6 +28,6 @@ int main( void ) {
 	int i;
 	for ( i = 0; i < 10; i++ ) {
 		v = stdlib_base_rising_factorial( x[ i ], n[ i ] );
-		printf( "x: %lf, n: %d, rising_factorial(x,n): %lf\n", x[ i ], n[ i ], v );
+		printf( "risingFactorial(%lf, %d) = %lf\n", x[ i ], n[ i ], v );
 	}
 }

lib/node_modules/@stdlib/math/base/special/rising-factorial/examples/index.js

@@ -18,17 +18,15 @@
 
 'use strict';
 
-var randu = require( '@stdlib/random/array/uniform' );
+var uniform = require( '@stdlib/random/array/uniform' );
 var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var logEachMap = require( '@stdlib/console/log-each-map' );
 var risingFactorial = require( './../lib' );
 
-var n;
-var x;
-var i;
+var opts = {
+	'dtype': 'float64'
+};
+var x = uniform( 100, -20.0, 20.0, opts );
+var n = discreteUniform( 100, -20, 20, opts );
 
-x = randu( 100, -20.0, 20.0 );
-n = discreteUniform( 100, 0, 20 );
-
-for ( i = 0; i < 100; i++ ) {
-	console.log( 'risingFactorial(%d,%d) = %d', x[ i ], n[ i ], risingFactorial( x[ i ], n[ i ] ) );
-}
+logEachMap( 'risingFactorial(%0.4f, %d) = %0.4f', x, n, risingFactorial );

lib/node_modules/@stdlib/math/base/special/rising-factorial/lib/native.js

@@ -14,19 +14,6 @@
 * 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/factorials.hpp}. The implementation has been modified for JavaScript.
-*
-* ```text
-* (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)
-* ```
 */
 
 'use strict';
@@ -41,20 +28,7 @@ var addon = require( './../src/addon.node' );
 /**
 * 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

lib/node_modules/@stdlib/math/base/special/rising-factorial/manifest.json

@@ -37,7 +37,6 @@
       "libpath": [],
       "dependencies": [
         "@stdlib/math/base/napi/binary",
-        "@stdlib/math/base/assert/is-integer",
         "@stdlib/math/base/assert/is-nan",
         "@stdlib/math/base/special/gamma-delta-ratio",
         "@stdlib/math/base/special/falling-factorial"
@@ -54,7 +53,6 @@
       "libraries": [],
       "libpath": [],
       "dependencies": [
-        "@stdlib/math/base/assert/is-integer",
         "@stdlib/math/base/assert/is-nan",
         "@stdlib/math/base/special/gamma-delta-ratio",
         "@stdlib/math/base/special/falling-factorial"
@@ -71,7 +69,6 @@
       "libraries": [],
       "libpath": [],
       "dependencies": [
-        "@stdlib/math/base/assert/is-integer",
         "@stdlib/math/base/assert/is-nan",
         "@stdlib/math/base/special/gamma-delta-ratio",
         "@stdlib/math/base/special/falling-factorial"

lib/node_modules/@stdlib/math/base/special/rising-factorial/src/addon.c

@@ -19,5 +19,4 @@
 #include "stdlib/math/base/special/rising_factorial.h"
 #include "stdlib/math/base/napi/binary.h"
 
-// cppcheck-suppress shadowFunction
 STDLIB_MATH_BASE_NAPI_MODULE_DI_D( stdlib_base_rising_factorial )

lib/node_modules/@stdlib/math/base/special/rising-factorial/src/main.c

@@ -18,7 +18,7 @@
 *
 * ## 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/factorials.hpp}. The implementation has been modified according to project conventions.
+* 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/factorials.hpp}. The implementation has been modified according to stdlib conventions.
 *
 * ```text
 * (C) Copyright John Maddock 2006, 2010.
@@ -33,6 +33,8 @@
 #include "stdlib/math/base/assert/is_nan.h"
 #include "stdlib/math/base/special/gamma_delta_ratio.h"
 #include "stdlib/math/base/special/falling_factorial.h"
+#include <stdint.h>
+#include <stdbool.h>
 
 /**
 * Computes the rising factorial of `x` and `n`.
@@ -51,9 +53,9 @@
 *     \operatorname{stdlib_base_rising_factorial}(x, n) = \frac{ \Gamma(x + n) }{ \Gamma(x) };
 *     ```
 *
-* @param {number} x - first function parameter
-* @param {integer} n - second function parameter
-* @returns {number} function value
+* @param x     first function parameter
+* @param n     second function parameter
+* @return      function value
 *
 * @example
 * double v = stdlib_base_rising_factorial( 0.9, 5 );
@@ -77,19 +79,20 @@ double stdlib_base_rising_factorial( const double x, const int32_t n ) {
 	double xc;
 	bool inv;
 
-	if ( stdlib_base_is_nan( x ) || !stdlib_base_is_integer( n ) ) {
+	if ( stdlib_base_is_nan( x ) ) {
 		return 0.0 / 0.0; // NaN
 	}
 	nc = n;
 	xc = x;
 	inv = false;
 	if ( xc < 0.0 ) {
-		if ( nc < 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 ( nc < 0 ) {
 			xc += nc;
 			nc = -nc;
 			inv = true;
 		}
-		result = ( ( nc & 1 ) ? -1.0 : 1.0 ) * stdlib_base_falling_factorial( -xc, nc );
+		result = ( (nc&1) ? -1.0 : 1.0 ) * stdlib_base_falling_factorial( -xc, nc );
 		if ( inv ) {
 			result = 1.0 / result;
 		}
@@ -104,11 +107,10 @@ double stdlib_base_rising_factorial( const double x, const int32_t n ) {
 		}
 		return 0.0;
 	}
-	if ( ( xc < 1.0 ) && ( xc + nc < 0.0 ) ) {
+	if ( ( xc < 1.0 ) && ( xc+nc < 0.0 ) ) {
 		result = stdlib_base_gamma_delta_ratio( 1.0 - xc, -nc );
-		return ( nc & 1 ) ? -result : result;
+		return ( nc&1 ) ? -result : result;
 	}
-
 	// We don't optimize this for small `nc`, because `stdlib_base_gamma_delta_ratio` is already optimized for that use case:
 	return 1.0 / stdlib_base_gamma_delta_ratio( xc, nc );
 }

lib/node_modules/@stdlib/math/base/special/rising-factorial/test/test.js

@@ -21,6 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var abs = require( '@stdlib/math/base/special/abs' );
 var EPS = require( '@stdlib/constants/float64/eps' );
 var risingFactorial = require( './../lib' );