feat: add complete implementation

---
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: passed
  - task: lint_repl_help
    status: passed
  - 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: passed
  - 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: passed
  - task: lint_typescript_tests
    status: passed
  - task: lint_license_headers
    status: passed
---

Author: anandkaranubc

lib/node_modules/@stdlib/math/base/special/factorial2f/README.md

@@ -18,9 +18,9 @@ limitations under the License.
 
 -->
 
-# factorial2
+# factorial2f
 
-> [Double factorial][double-factorial] function.
+> Evaluate the [double factorial][double-factorial] function as a single-precision floating-point number.
 
 <section class="intro">
 
@@ -37,36 +37,48 @@ Thus, for example, `5!!` is `5 * 3 * 1 = 15` and `8!!` is `8 * 6 * 4 * 2 = 384`.
 ## Usage
 
 ```javascript
-var factorial2 = require( '@stdlib/math/base/special/factorial2' );
+var factorial2f = require( '@stdlib/math/base/special/factorial2f' );
 ```
 
-#### factorial2( n )
+#### factorial2f( n )
 
-Evaluates the [double factorial][double-factorial] of `n`.
+Evaluates the [double factorial][double-factorial] of `n` as a single-precision floating-point number.
 
 ```javascript
-var v = factorial2( 2 );
-// returns 2
-
-v = factorial2( 3 );
+v = factorial2f( 3 );
 // returns 3
 
-v = factorial2( 0 );
-// returns 1
-
-v = factorial2( 4 );
+v = factorial2f( 4 );
 // returns 8
 
-v = factorial2( 5 );
-// returns 15
+v = factorial2f( 10 );
+// returns 3840
+```
 
-v = factorial2( NaN );
-// returns NaN
+If `n > 56`, the function returns `NaN`, as larger [double factorial][double-factorial] values cannot be safely represented in [single-precision floating-point format][ieee754].
 
-v = factorial2( 301 );
+```javascript
+var v = factorial2f( 57 );
 // returns Infinity
 ```
 
+If not provided a nonnegative integer value, the function returns `NaN`.
+
+```javascript
+var v = factorial2f( 3.14 );
+// returns NaN
+
+v = factorial2f( -1 );
+// returns NaN
+```
+
+If provided `NaN`, the function returns `NaN`.
+
+```javascript
+var v = factorial2f( NaN );
+// returns NaN
+```
+
 </section>
 
 <!-- /.usage -->
@@ -78,15 +90,15 @@ v = factorial2( 301 );
 <!-- eslint no-undef: "error" -->
 
 ```javascript
-var oneTo = require( '@stdlib/array/base/one-to' );
-var factorial2 = require( '@stdlib/math/base/special/factorial2' );
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var logEachMap = require( '@stdlib/console/log-each-map' );
+var factorial2f = require( '@stdlib/math/base/special/factorial2f' );
 
-var values = oneTo( 300 );
+var x = discreteUniform( 10, 0, 56, {
+    'dtype': 'int32'
+});
 
-var i;
-for ( i = 0; i < values.length; i++ ) {
-    console.log( 'f(%d): %d', values[ i ], factorial2( values[ i ] ) );
-}
+logEachMap( 'factorial2f(%d) = %0.1f', x, factorial2f );
 ```
 
 </section>
@@ -116,24 +128,24 @@ for ( i = 0; i < values.length; i++ ) {
 ### Usage
 
 ```c
-#include "stdlib/math/base/special/factorial2.h"
+#include "stdlib/math/base/special/factorial2f.h"
 ```
 
-#### stdlib_base_factorial2( n )
+#### stdlib_base_factorial2f( n )
 
-Evaluates the [double factorial][double-factorial] of `n`.
+Evaluates the [double factorial][double-factorial] of `n` as a single-precision floating-point number.
 
 ```c
-double out = stdlib_base_factorial2( 3 );
-// returns 3
+float out = stdlib_base_factorial2f( 3 );
+// returns 3.0f
 ```
 
 The function accepts the following arguments:
 
 -   **n**: `[in] int32_t` input value.
 
 ```c
-double stdlib_base_factorial2( const int32_t n );
+float stdlib_base_factorial2f( const int32_t n );
 ```
 
 </section>
@@ -155,18 +167,18 @@ double stdlib_base_factorial2( const int32_t n );
 ### Examples
 
 ```c
-#include "stdlib/math/base/special/factorial2.h"
+#include "stdlib/math/base/special/factorial2f.h"
 #include <stdio.h>
 #include <stdint.h>
 
 int main( void ) {
-    const int32_t x[] = { 1, 10, 1, 301, 302 };
+    const int32_t x[] = { 1, 10, 50, 56, 57 };
 
-    double b;
+    float b;
     int i;
-    for ( i = 0; i < 5; i++ ){
-        b = stdlib_base_factorial2( x[ i ] );
-        printf ( "factorial2(%d) = %lf\n", x[ i ], b );
+    for ( i = 0; i < 5; i++ ) {
+        b = stdlib_base_factorial2f( x[ i ] );
+        printf ( "factorial2f(%d) = %f\n", x[ i ], b );
     }
 }
 ```
@@ -183,12 +195,6 @@ int main( void ) {
 
 <section class="related">
 
-* * *
-
-## See Also
-
--   <span class="package-name">[`@stdlib/math/base/special/factorial`][@stdlib/math/base/special/factorial]</span><span class="delimiter">: </span><span class="description">evaluate a factorial.</span>
-
 </section>
 
 <!-- /.related -->
@@ -199,9 +205,9 @@ int main( void ) {
 
 [double-factorial]: https://en.wikipedia.org/wiki/Double_factorial
 
-<!-- <related-links> -->
+[ieee754]: https://en.wikipedia.org/wiki/IEEE_754-1985
 
-[@stdlib/math/base/special/factorial]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/math/base/special/factorial
+<!-- <related-links> -->
 
 <!-- </related-links> -->
 

lib/node_modules/@stdlib/math/base/special/factorial2f/benchmark/benchmark.js

@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2023 The Stdlib Authors.
+* Copyright (c) 2025 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.
@@ -21,26 +21,32 @@
 // MODULES //
 
 var bench = require( '@stdlib/bench' );
-var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
 var pkg = require( './../package.json' ).name;
-var factorial2 = require( './../lib' );
+var factorial2f = require( './../lib' );
 
 
 // MAIN //
 
 bench( pkg, function benchmark( b ) {
+	var x;
 	var y;
 	var i;
 
+	x = discreteUniform( 100, 0, 56, {
+		'dtype': 'int32'
+	});
+
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
-		y = factorial2( i%301 );
-		if ( isnan( y ) ) {
+		y = factorial2f( x[ i%x.length ] );
+		if ( isnanf( y ) ) {
 			b.fail( 'should not return NaN' );
 		}
 	}
 	b.toc();
-	if ( isnan( y ) ) {
+	if ( isnanf( y ) ) {
 		b.fail( 'should not return NaN' );
 	}
 	b.pass( 'benchmark finished' );

lib/node_modules/@stdlib/math/base/special/factorial2f/benchmark/benchmark.native.js

@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2024 The Stdlib Authors.
+* Copyright (c) 2025 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.
@@ -22,34 +22,40 @@
 
 var resolve = require( 'path' ).resolve;
 var bench = require( '@stdlib/bench' );
-var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 var pkg = require( './../package.json' ).name;
 
 
 // VARIABLES //
 
-var factorial2 = tryRequire( resolve( __dirname, './../lib/native.js' ) );
+var factorial2f = tryRequire( resolve( __dirname, './../lib/native.js' ) );
 var opts = {
-	'skip': ( factorial2 instanceof Error )
+	'skip': ( factorial2f instanceof Error )
 };
 
 
 // MAIN //
 
 bench( pkg+'::native', opts, function benchmark( b ) {
+	var x;
 	var y;
 	var i;
 
+	x = discreteUniform( 100, 0, 56, {
+		'dtype': 'int32'
+	});
+
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
-		y = factorial2( i % 301 );
-		if ( isnan( y ) ) {
+		y = factorial2f( x[ i%x.length ] );
+		if ( isnanf( y ) ) {
 			b.fail( 'should not return NaN' );
 		}
 	}
 	b.toc();
-	if ( isnan( y ) ) {
+	if ( isnanf( y ) ) {
 		b.fail( 'should not return NaN' );
 	}
 	b.pass( 'benchmark finished' );

lib/node_modules/@stdlib/math/base/special/factorial2f/benchmark/c/native/benchmark.c

@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2024 The Stdlib Authors.
+* Copyright (c) 2025 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.
@@ -16,15 +16,15 @@
 * limitations under the License.
 */
 
-#include "stdlib/math/base/special/factorial2.h"
+#include "stdlib/math/base/special/factorial2f.h"
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <math.h>
 #include <time.h>
 #include <sys/time.h>
 
-#define NAME "factorial2"
+#define NAME "factorial2f"
 #define ITERATIONS 1000000
 #define REPEATS 3
 
@@ -80,9 +80,9 @@ static double tic( void ) {
 *
 * @return random number
 */
-static double rand_double( void ) {
+static float rand_float( void ) {
 	int r = rand();
-	return (double)r / ( (double)RAND_MAX + 1.0 );
+	return (float)r / ( (float)RAND_MAX + 1.0f );
 }
 
 /**
@@ -91,16 +91,19 @@ static double rand_double( void ) {
 * @return elapsed time in seconds
 */
 static double benchmark( void ) {
+	int32_t x[ 100 ];
 	double elapsed;
-	int32_t x;
-	double y;
 	double t;
+	float y;
 	int i;
 
+	for ( i = 0; i < 100; i++ ) {
+		x[ i ] = (int32_t)( 56*rand_float() );
+	}
+
 	t = tic();
 	for ( i = 0; i < ITERATIONS; i++ ) {
-		x = (int32_t)(rand_double() * 301);
-		y = stdlib_base_factorial2( x );
+		y = stdlib_base_factorial2f( x[ i%100 ] );
 		if ( y != y ) {
 			printf( "should not return NaN\n" );
 			break;