test: add test for csignumf strided

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

Author: Deepak91168

lib/node_modules/@stdlib/math/base/special/csignumf/test/test.strided.js

@@ -0,0 +1,147 @@
+/**
+* @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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var PINF = require( '@stdlib/constants/float32/pinf' );
+var NINF = require( '@stdlib/constants/float32/ninf' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var EPS = require( '@stdlib/constants/float32/eps' );
+var absf = require( '@stdlib/math/base/special/absf' );
+var isNegativeZerof = require( '@stdlib/math/base/assert/is-negative-zerof' );
+var isPositiveZerof = require( '@stdlib/math/base/assert/is-positive-zerof' );
+var Float32Array = require( '@stdlib/array/float32' );
+var csignumf = require( './../lib' );
+
+
+// FIXTURES //
+
+var data = require( './fixtures/julia/data.json' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof csignumf.strided, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function evaluates the signum function for complex numbers in strided arrays', function test( t ) {
+	var delta;
+	var out;
+	var tol;
+	var ere;
+	var eim;
+	var re;
+	var im;
+	var z;
+	var i;
+
+	re = data.re;
+	im = data.im;
+	ere = data.expected_re;
+	eim = data.expected_im;
+
+	for ( i = 0; i < re.length; i++ ) {
+		z = new Float32Array( 2 );
+		z[ 0 ] = re[ i ];
+		z[ 1 ] = im[ i ];
+
+		out = new Float32Array( 2 );
+		csignumf.strided( z, 1, 0, out, 1, 0 );
+
+		if ( isnanf( ere[ i ] ) || isnanf( eim[ i ] ) ) {
+			t.strictEqual( isnanf( out[ 0 ] ), true, 're is NaN' );
+			t.strictEqual( isnanf( out[ 1 ] ), true, 'im is NaN' );
+			continue;
+		}
+		if ( out[ 0 ] === ere[ i ] && out[ 1 ] === eim[ i ] ) {
+			t.strictEqual( out[ 0 ], ere[ i ], 're: '+re[ i ]+'. Expected: '+ere[ i ] );
+			t.strictEqual( out[ 1 ], eim[ i ], 'im: '+im[ i ]+'. Expected: '+eim[ i ] );
+		} else {
+			delta = absf( out[ 0 ] - ere[ i ] );
+			tol = EPS * absf( ere[ i ] );
+			t.ok(delta <= tol, 'within tolerance. re: '+re[ i ]+'. Expected: '+ere[ i ]+'. Actual: '+out[ 0 ]+'. Δ: '+delta+'. tol: '+tol+'.');
+
+			delta = absf( out[ 1 ] - eim[ i ] );
+			tol = EPS * absf( eim[ i ] );
+			t.ok(delta <= tol, 'within tolerance. im: '+im[ i ]+'. Expected: '+eim[ i ]+'. Actual: '+out[ 1 ]+'. Δ: '+delta+'. tol: '+tol+'.');
+		}
+	}
+	t.end();
+});
+
+tape( 'the function returns +0 if provided +0 +0i', function test( t ) {
+	var out = new Float32Array( 2 );
+	var z = new Float32Array( [ +0.0, +0.0 ] );
+
+	csignumf.strided( z, 1, 0, out, 1, 0 );
+
+	t.strictEqual( isPositiveZerof( out[ 0 ] ), true, 'real is +0' );
+	t.strictEqual( isPositiveZerof( out[ 1 ] ), true, 'imag is +0' );
+
+	t.end();
+});
+
+tape( 'the function returns -0 if provided -0 -0i', function test( t ) {
+	var out = new Float32Array( 2 );
+	var z = new Float32Array( [ -0.0, -0.0 ] );
+
+	csignumf.strided( z, 1, 0, out, 1, 0 );
+
+	t.strictEqual( isNegativeZerof( out[ 0 ] ), true, 'real is -0' );
+	t.strictEqual( isNegativeZerof( out[ 1 ] ), true, 'imag is -0' );
+
+	t.end();
+});
+
+tape( 'the function returns NaNs if provided NaNs', function test( t ) {
+	var out = new Float32Array( 2 );
+	var z = new Float32Array( [ NaN, NaN ] );
+
+	csignumf.strided( z, 1, 0, out, 1, 0 );
+
+	t.strictEqual( isnanf( out[ 0 ] ), true, 'real is NaN' );
+	t.strictEqual( isnanf( out[ 1 ] ), true, 'imag is NaN' );
+
+	t.end();
+});
+
+tape( 'the function returns NaNs if provided infinities', function test( t ) {
+	var out;
+	var z;
+
+	z = new Float32Array( [ PINF, PINF ] );
+	out = new Float32Array( 2 );
+	csignumf.strided( z, 1, 0, out, 1, 0 );
+
+	t.strictEqual( isnanf( out[ 0 ] ), true, 'real is NaN' );
+	t.strictEqual( isnanf( out[ 1 ] ), true, 'imag is NaN' );
+
+	z = new Float32Array( [ NINF, NINF ] );
+	csignumf.strided( z, 1, 0, out, 1, 0 );
+
+	t.strictEqual( isnanf( out[ 0 ] ), true, 'real is NaN' );
+	t.strictEqual( isnanf( out[ 1 ] ), true, 'imag is NaN' );
+
+	t.end();
+});