feat: add assert/is-almost-equal

---
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: passed
  - 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: anandkaranubc

lib/node_modules/@stdlib/assert/is-almost-equal/lib/main.js

@@ -71,10 +71,10 @@ function isAlmostEqual( a, b, maxULP ) {
 		return isAlmostEqualF64( a, b, maxULP );
 	}
 	if ( isComplexLike( a ) && isComplexLike( b ) ) {
-		if ( a.BYTES_PER_ELEMENT === 8 && b.BYTES_PER_ELEMENT === 8 ) {
-        	return isAlmostEqualComplex64( a, b, maxULP );
+		if ( a.BYTES_PER_ELEMENT === 4 && b.BYTES_PER_ELEMENT === 4 ) {
+			return isAlmostEqualComplex64( a, b, maxULP );
 		}
-   		return isAlmostEqualComplex128( a, b, maxULP );
+		return isAlmostEqualComplex128( a, b, maxULP );
 	}
 	return false;
 }

lib/node_modules/@stdlib/assert/is-almost-equal/test/test.js

@@ -25,7 +25,6 @@
 var tape = require( 'tape' );
 var EPS_F64 = require( '@stdlib/constants/float64/eps' );
 var EPS_F32 = require( '@stdlib/constants/float32/eps' );
-var f32 = require( '@stdlib/number/float64/base/to-float32' );
 var Number = require( '@stdlib/number/ctor' );
 var Boolean = require( '@stdlib/boolean/ctor' );
 var Complex128 = require( '@stdlib/complex/float64/ctor' );
@@ -66,7 +65,6 @@ tape( 'the function returns `true` if provided two arguments which are the same
 		new Complex64( 5.0, 2.0 )
 	];
 	for ( i = 0; i < values.length; i++ ) {
-		console.log( values[ i ] );
 		t.strictEqual( isAlmostEqual( values[ i ], values[ i ], 0 ), true, 'returns expected value' );
 		t.strictEqual( isAlmostEqual( values[ i ], values[ i ], 1 ), true, 'returns expected value' );
 	}
@@ -87,7 +85,6 @@ tape( 'the function returns `true` if provided two arguments which are the same
 });
 
 tape( 'the function returns `true` if provided two arguments which are approximately equal within a specified number of ULPs', function test( t ) {
-	t.strictEqual( isAlmostEqual( f32( 1.0 ), f32( f32( 1.0 )+EPS_F32 ), 1 ), true, 'returns expected value' );
 	t.strictEqual( isAlmostEqual( 1.0, 1.0+EPS_F64, 1 ), true, 'returns expected value' );
 	t.strictEqual( isAlmostEqual( 1.0+EPS_F64, 1.0, 1 ), true, 'returns expected value' );
 	t.strictEqual( isAlmostEqual( 1.0, 1.0+EPS_F64+EPS_F64, 2 ), true, 'returns expected value' );
@@ -110,6 +107,7 @@ tape( 'the function returns `false` if provided two arguments which are not appr
 		5,
 		3.14,
 		-3.14,
+		new Number( 5 ),
 		true,
 		false,
 		new Boolean( true ),
@@ -130,6 +128,7 @@ tape( 'the function returns `false` if provided two arguments which are not appr
 		-5,
 		-3.14,
 		3.14,
+		new Number( 5 ),
 		false,
 		true,
 		new Boolean( true ),
@@ -144,8 +143,6 @@ tape( 'the function returns `false` if provided two arguments which are not appr
 		new Complex64( 5.0, -2.0 )
 	];
 	for ( i = 0; i < a.length; i++ ) {
-		console.log( a[ i ], b[ i ] );
-		console.log(isAlmostEqual( a[ i ], b[ i ], 1 ));
 		t.strictEqual( isAlmostEqual( a[ i ], b[ i ], 1 ), false, 'returns expected value' );
 	}
 
@@ -157,3 +154,41 @@ tape( 'the function returns `false` if provided two arguments which are not appr
 
 	t.end();
 });
+
+tape( 'the function returns `false` if either input value is `NaN` or in the case of complex numbers, if either the real or imaginary component is `NaN`', function test( t ) {
+	var a;
+	var b;
+	var i;
+
+	a = [
+		NaN,
+		NaN,
+		new Complex128( NaN, 3.0 ),
+		new Complex64( 5.0, NaN ),
+		new Complex128( NaN, NaN ),
+		new Complex64( NaN, NaN )
+	];
+	b = [
+		NaN,
+		1.0,
+		new Complex128( 1.0, 2.0 ),
+		new Complex64( 3.0, 4.0 ),
+		new Complex128( NaN, NaN ),
+		new Complex64( NaN, NaN )
+	];
+	for ( i = 0; i < a.length; i++ ) {
+		t.strictEqual( isAlmostEqual( a[ i ], b[ i ], 1 ), false, 'returns expected value' );
+	}
+
+	t.end();
+});
+
+tape( 'the function does not distinguish between `-0` and `+0`', function test( t ) {
+	t.strictEqual( isAlmostEqual( -0.0, 0.0, 0 ), true, 'returns expected value' );
+	t.strictEqual( isAlmostEqual( 0.0, -0.0, 0 ), true, 'returns expected value' );
+
+	t.strictEqual( isAlmostEqual( new Complex128( -0.0, 3.0 ), new Complex128( 0.0, 3.0 ), 1 ), true, 'returns expected value' );
+	t.strictEqual( isAlmostEqual( new Complex64( -0.0, 3.0 ), new Complex64( 0.0, 3.0 ), 1 ), true, 'returns expected value' );
+
+	t.end();
+});