test(math/base/special/boxcoxf): add test fixtures and native tests

---
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: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: missing_dependencies
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: navyansh007

lib/node_modules/@stdlib/math/base/special/boxcoxf/test/fixtures/python/medium_positive.json

@@ -0,0 +1,93 @@
+#!/usr/bin/env python
+#
+# @license Apache-2.0
+#
+# 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.
+# 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.
+
+"""Generate fixtures."""
+
+from os import path
+import json
+from scipy.special import boxcox
+import numpy as np
+
+# Get the file path.
+FILE = path.realpath(__file__)
+
+# Get the file's directory.
+DIR = path.dirname(FILE)
+
+
+def generate(x, y, filename):
+    """Generate fixture data and write to file.
+
+    # Arguments
+
+    * `x`: domain
+    * `y`: domain
+    * `name::str`: filename of the output file
+
+    # Examples
+
+    ```python
+    python> x = np.linspace(1.0, 10.0, 2001).astype(np.float32)
+    python> y = np.linspace(-5.0, 5.0, 2001).astype(np.float32)
+    python> generate(x, y, './data.json')
+    ```
+    """
+    z = []
+    for xi, yi in zip(x, y):
+        z.append(np.float32(boxcox(float(xi), float(yi))))
+    z = np.array(z, dtype=np.float32)
+
+    data = dict(
+        x=x.tolist(),
+        y=y.tolist(),
+        expected=z.tolist()
+    )
+
+    filepath = path.join(DIR, filename)
+
+    with open(filepath, 'w') as out:
+        json.dump(data, out)
+
+
+def main():
+    """Generate fixture data."""
+    # Medium positive values:
+    x = np.linspace(1.0, 10.0, 500).astype(np.float32)
+    lmda = np.linspace(-5.0, 5.0, 500).astype(np.float32)
+    generate(x, lmda, "medium_positive.json")
+
+    # Small positive values:
+    x = np.linspace(np.float32(2.0**-20), 1.0, 500).astype(np.float32)
+    lmda = np.linspace(-5.0, 5.0, 500).astype(np.float32)
+    generate(x, lmda, "small_positive.json")
+
+    # Tiny values:
+    x = np.linspace(
+        np.float32(1.9**-20), np.float32(2.0**-20), 500
+    ).astype(np.float32)
+    lmda = np.linspace(-5.0, 5.0, 500).astype(np.float32)
+    generate(x, lmda, "tiny.json")
+
+    # Tiny lambda:
+    x = np.linspace(1.0, 10.0, 500).astype(np.float32)
+    lmda = np.linspace(-5.0e-15, 5.0e-15, 500).astype(np.float32)
+    generate(x, lmda, "tiny_lambda.json")
+
+
+if __name__ == "__main__":
+    main()

lib/node_modules/@stdlib/math/base/special/boxcoxf/test/fixtures/python/runner.py

@@ -24,7 +24,7 @@ var resolve = require( 'path' ).resolve;
 var tape = require( 'tape' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var randu = require( '@stdlib/random/base/randu' );
-var absf = require( '@stdlib/math/base/special/absf' );
+var abs = require( '@stdlib/math/base/special/abs' );
 var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' );
 var NINF = require( '@stdlib/constants/float32/ninf' );
 var EPS = require( '@stdlib/constants/float32/eps' );
@@ -39,6 +39,14 @@ var opts = {
 };
 
 
+// FIXTURES //
+
+var mediumPositive = require( './fixtures/python/medium_positive.json' );
+var smallPositive = require( './fixtures/python/small_positive.json' );
+var tiny = require( './fixtures/python/tiny.json' );
+var tinyLambda = require( './fixtures/python/tiny_lambda.json' );
+
+
 // TESTS //
 
 tape( 'main export is a function', opts, function test( t ) {
@@ -62,16 +70,19 @@ tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns `-Infinity` if lambda is negative and `x` is +0', opts, function test( t ) {
+tape( 'the function returns `-Infinity` if lambda is negative and `x` is +-0', opts, function test( t ) {
 	var lambda;
 	var b;
 	var i;
 
 	for ( i = 0; i < 1e3; i++ ) {
-		lambda = float64ToFloat32( -1.0 * ( ( randu() * 100.0 ) + 1.0 ) );
+		lambda = float64ToFloat32( -1.0 * ( (randu()*100.0) + 1.0 ) );
 
 		b = boxcoxf( +0.0, lambda );
-		t.strictEqual( b, NINF, 'returns -Infinity when lambda is negative and x is positive zero' );
+		t.strictEqual( b, NINF, 'returns -Infinity when lambda is negative and `x` is positive zero' );
+
+		b = boxcoxf( -0.0, lambda );
+		t.strictEqual( b, NINF, 'returns -Infinity when lambda is negative and `x` is negative zero' );
 	}
 	t.end();
 });
@@ -83,15 +94,15 @@ tape( 'the function returns `NaN` if `x` is negative', opts, function test( t )
 	var i;
 
 	for ( i = 0; i < 1e3; i++ ) {
-		x = float64ToFloat32( -1.0 * ( ( randu() * 100.0 ) + 1.0 ) );
+		x = float64ToFloat32( -1.0 * ( (randu()*100.0) + 1.0 ) );
 		y = float64ToFloat32( randu() * 10.0 );
 		b = boxcoxf( x, y );
 		t.strictEqual( isnanf( b ), true, 'returns expected value' );
 	}
 	t.end();
 });
 
-tape( 'the function computes a one-parameter Box-Cox transformation for positive numbers', opts, function test( t ) {
+tape( 'the function computes a one-parameter Box-Cox transformation for positive medium numbers', opts, function test( t ) {
 	var expected;
 	var delta;
 	var tol;
@@ -100,70 +111,92 @@ tape( 'the function computes a one-parameter Box-Cox transformation for positive
 	var b;
 	var i;
 
-	x = [
-		float64ToFloat32( 1.0 ),
-		float64ToFloat32( 4.0 ),
-		float64ToFloat32( 10.0 ),
-		float64ToFloat32( 2.0 ),
-		float64ToFloat32( 5.0 )
-	];
-	y = [
-		float64ToFloat32( 2.5 ),
-		float64ToFloat32( 2.5 ),
-		float64ToFloat32( 2.5 ),
-		float64ToFloat32( 1.0 ),
-		float64ToFloat32( 0.5 )
-	];
-	expected = [
-		float64ToFloat32( 0.0 ),
-		float64ToFloat32( 12.4 ),
-		float64ToFloat32( 126.09114837646484 ),
-		float64ToFloat32( 1.0 ),
-		float64ToFloat32( 2.4721359014511108 )
-	];
+	expected = mediumPositive.expected;
+	x = mediumPositive.x;
+	y = mediumPositive.y;
+	for ( i = 0; i < expected.length; i++ ) {
+		b = boxcoxf( x[ i ], y[ i ] );
+		if ( b === expected[ i ] ) {
+			t.strictEqual( b, expected[ i ], 'returns '+b+' when provided '+x[i]+' and '+y[i]+'.' );
+		} else {
+			delta = abs( expected[ i ] - b );
+			tol = 16.0 * EPS * abs( expected[ i ] );
+			t.ok( delta <= tol, 'within tolerance. returns '+b+' when provided '+x[i]+' and '+y[i]+'. expected: '+expected[i]+'. delta: '+delta+'. tol: ' +tol+'.' );
+		}
+	}
+	t.end();
+});
+
+tape( 'the function computes a one-parameter Box-Cox transformation for positive small numbers', opts, function test( t ) {
+	var expected;
+	var delta;
+	var tol;
+	var x;
+	var y;
+	var b;
+	var i;
 
+	expected = smallPositive.expected;
+	x = smallPositive.x;
+	y = smallPositive.y;
 	for ( i = 0; i < expected.length; i++ ) {
 		b = boxcoxf( x[ i ], y[ i ] );
 		if ( b === expected[ i ] ) {
-			t.strictEqual( b, expected[ i ], 'returns ' + b + ' when provided ' + x[ i ] + ' and ' + y[ i ] + '.' );
+			t.strictEqual( b, expected[ i ], 'returns '+b+' when provided '+x[i]+' and '+y[i]+'.' );
 		} else {
-			delta = absf( expected[ i ] - b );
-			tol = 20.0 * EPS * absf( expected[ i ] );
-			t.ok( delta <= tol, 'within tolerance. returns ' + b + ' when provided ' + x[ i ] + ' and ' + y[ i ] + '. expected: ' + expected[ i ] + '. delta: ' + delta + '. tol: ' + tol + '.' );
+			delta = abs( expected[ i ] - b );
+			tol = 16.0 * EPS * abs( expected[ i ] );
+			t.ok( delta <= tol, 'within tolerance. returns '+b+' when provided '+x[i]+' and '+y[i]+'. expected: '+expected[i]+'. delta: '+delta+'. tol: ' +tol+'.' );
 		}
 	}
 	t.end();
 });
 
-tape( 'the function computes a one-parameter Box-Cox transformation when lambda is zero (returns natural log)', opts, function test( t ) {
+tape( 'the function computes a one-parameter Box-Cox transformation for tiny numbers', opts, function test( t ) {
 	var expected;
 	var delta;
 	var tol;
 	var x;
+	var y;
 	var b;
 	var i;
 
-	x = [
-		float64ToFloat32( 1.0 ),
-		float64ToFloat32( 2.0 ),
-		float64ToFloat32( 4.0 ),
-		float64ToFloat32( 10.0 )
-	];
-	expected = [
-		float64ToFloat32( 0.0 ),
-		float64ToFloat32( 0.6931471805599453 ),
-		float64ToFloat32( 1.3862943611198906 ),
-		float64ToFloat32( 2.302585092994046 )
-	];
+	expected = tiny.expected;
+	x = tiny.x;
+	y = tiny.y;
+	for ( i = 0; i < expected.length; i++ ) {
+		b = boxcoxf( x[ i ], y[ i ] );
+		if ( b === expected[ i ] ) {
+			t.strictEqual( b, expected[ i ], 'returns '+b+' when provided '+x[i]+' and '+y[i]+'.' );
+		} else {
+			delta = abs( expected[ i ] - b );
+			tol = 70.0 * EPS * abs( expected[ i ] );
+			t.ok( delta <= tol, 'within tolerance. returns '+b+' when provided '+x[i]+' and '+y[i]+'. expected: '+expected[i]+'. delta: '+delta+'. tol: ' +tol+'.' );
+		}
+	}
+	t.end();
+});
 
+tape( 'the function computes a one-parameter Box-Cox transformation for tiny lambda', opts, function test( t ) {
+	var expected;
+	var delta;
+	var tol;
+	var x;
+	var y;
+	var b;
+	var i;
+
+	expected = tinyLambda.expected;
+	x = tinyLambda.x;
+	y = tinyLambda.y;
 	for ( i = 0; i < expected.length; i++ ) {
-		b = boxcoxf( x[ i ], 0.0 );
+		b = boxcoxf( x[ i ], y[ i ] );
 		if ( b === expected[ i ] ) {
-			t.strictEqual( b, expected[ i ], 'returns ' + b + ' when provided ' + x[ i ] + ' and lambda=0.' );
+			t.strictEqual( b, expected[ i ], 'returns '+b+' when provided '+x[i]+' and '+y[i]+'.' );
 		} else {
-			delta = absf( expected[ i ] - b );
-			tol = 2.0 * EPS * absf( expected[ i ] );
-			t.ok( delta <= tol, 'within tolerance. returns ' + b + ' when provided ' + x[ i ] + ' and lambda=0. expected: ' + expected[ i ] + '. delta: ' + delta + '. tol: ' + tol + '.' );
+			delta = abs( expected[ i ] - b );
+			tol = 1.0 * EPS * abs( expected[ i ] );
+			t.ok( delta <= tol, 'within tolerance. returns '+b+' when provided '+x[i]+' and '+y[i]+'. expected: '+expected[i]+'. delta: '+delta+'. tol: ' +tol+'.' );
 		}
 	}
 	t.end();