From 8840d3b3045fe1e776e24013d450992956c62423 Mon Sep 17 00:00:00 2001 From: stdlib-bot Date: Sun, 28 Jan 2024 08:06:22 +0000 Subject: [PATCH] Auto-generated commit --- docs/types/index.d.ts | 220 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 220 insertions(+) diff --git a/docs/types/index.d.ts b/docs/types/index.d.ts index 7410fca9..dd16ba0d 100644 --- a/docs/types/index.d.ts +++ b/docs/types/index.d.ts @@ -255,6 +255,13 @@ import isRelativePath = require( './../../is-relative-path' ); import isRelativeURI = require( './../../is-relative-uri' ); import isSafeInteger = require( './../../is-safe-integer' ); import isSafeIntegerArray = require( './../../is-safe-integer-array' ); +import isSameArray = require( './../../is-same-array' ); +import isSameComplex64 = require( './../../is-same-complex64' ); +import isSameComplex64Array = require( './../../is-same-complex64array' ); +import isSameComplex128 = require( './../../is-same-complex128' ); +import isSameComplex128Array = require( './../../is-same-complex128array' ); +import isSameFloat32Array = require( './../../is-same-float32array' ); +import isSameFloat64Array = require( './../../is-same-float64array' ); import isSameNativeClass = require( './../../is-same-native-class' ); import isSameType = require( './../../is-same-type' ); import isSameValue = require( './../../is-same-value' ); @@ -5655,6 +5662,219 @@ interface Namespace { */ isSafeIntegerArray: typeof isSafeIntegerArray; + /** + * Tests if two arguments are both generic arrays and have the same values. + * + * ## Notes + * + * - The function differs from the `===` operator in that the function treats `-0` and `+0` as distinct and `NaNs` as the same. + * + * @param v1 - first input value + * @param v2 - second input value + * @returns boolean indicating whether two arguments are the same + * + * @example + * var x = [ 1.0, 2.0, 3.0 ]; + * var y = [ 1.0, 2.0, 3.0 ]; + * + * var out = ns.isSameArray( x, y ); + * // returns true + * + * @example + * var x = [ 1.0, 2.0, 3.0 ]; + * var y = [ 1.0, 2.0, 4.0 ]; + * + * var out = ns.isSameArray( x, y ); + * // returns false + */ + isSameArray: typeof isSameArray; + + /** + * Tests if two arguments are both single-precision complex floating-point numbers and have the same value. + * + * ## Notes + * + * - The function differs from the `===` operator in that the function treats `-0` and `+0` as distinct and `NaNs` as the same. + * + * @param v1 - first input value + * @param v2 - second input value + * @returns boolean indicating whether two arguments are the same + * + * @example + * var Complex64 = require( '@stdlib/complex/float32' ); + * + * var x = new Complex64( 1.0, 2.0 ); + * var y = new Complex64( 1.0, 2.0 ); + * + * var out = ns.isSameComplex64( x, y ); + * // returns true + * + * @example + * var Complex64 = require( '@stdlib/complex/float32' ); + * + * var x = new Complex64( 1.0, 2.0 ); + * var y = new Complex64( -1.0, -2.0 ); + * + * var out = ns.isSameComplex64( x, y ); + * // returns false + */ + isSameComplex64: typeof isSameComplex64; + + /** + * Tests if two arguments are both Complex64Arrays and have the same values. + * + * ## Notes + * + * - The function differs from the `===` operator in that the function treats `-0` and `+0` as distinct and `NaNs` as the same. + * + * @param v1 - first input value + * @param v2 - second input value + * @returns boolean indicating whether two arguments are the same + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * + * var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var y = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * + * var out = ns.isSameComplex64Array( x, y ); + * // returns true + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * + * var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var y = new Complex64Array( [ 1.0, 2.0, 4.0, 4.0 ] ); + * + * var out = ns.isSameComplex64Array( x, y ); + * // returns false + */ + isSameComplex64Array: typeof isSameComplex64Array; + + /** + * Tests if two arguments are both double-precision complex floating-point numbers and have the same value. + * + * ## Notes + * + * - The function differs from the `===` operator in that the function treats `-0` and `+0` as distinct and `NaNs` as the same. + * + * @param v1 - first input value + * @param v2 - second input value + * @returns boolean indicating whether two arguments are the same + * + * @example + * var Complex128 = require( '@stdlib/complex/float64' ); + * + * var x = new Complex128( 1.0, 2.0 ); + * var y = new Complex128( 1.0, 2.0 ); + * + * var out = ns.isSameComplex128( x, y ); + * // returns true + * + * @example + * var Complex128 = require( '@stdlib/complex/float64' ); + * + * var x = new Complex128( 1.0, 2.0 ); + * var y = new Complex128( -1.0, -2.0 ); + * + * var out = ns.isSameComplex128( x, y ); + * // returns false + */ + isSameComplex128: typeof isSameComplex128; + + /** + * Tests if two arguments are both Complex128Arrays and have the same values. + * + * ## Notes + * + * - The function differs from the `===` operator in that the function treats `-0` and `+0` as distinct and `NaNs` as the same. + * + * @param v1 - first input value + * @param v2 - second input value + * @returns boolean indicating whether two arguments are the same + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var y = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * + * var out = ns.isSameComplex128Array( x, y ); + * // returns true + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * + * var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + * var y = new Complex128Array( [ 1.0, 2.0, 4.0, 4.0 ] ); + * + * var out = ns.isSameComplex128Array( x, y ); + * // returns false + */ + isSameComplex128Array: typeof isSameComplex128Array; + + /** + * Tests if two arguments are both Float32Arrays and have the same values. + * + * ## Notes + * + * - The function differs from the `===` operator in that the function treats `-0` and `+0` as distinct and `NaNs` as the same. + * + * @param v1 - first input value + * @param v2 - second input value + * @returns boolean indicating whether two arguments are the same + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 2.0, 3.0 ] ); + * var y = new Float32Array( [ 1.0, 2.0, 3.0 ] ); + * + * var out = ns.isSameFloat32Array( x, y ); + * // returns true + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, 2.0, 3.0 ] ); + * var y = new Float32Array( [ 1.0, 2.0, 4.0 ] ); + * + * var out = ns.isSameFloat32Array( x, y ); + * // returns false + */ + isSameFloat32Array: typeof isSameFloat32Array; + + /** + * Tests if two arguments are both Float64Arrays and have the same values. + * + * ## Notes + * + * - The function differs from the `===` operator in that the function treats `-0` and `+0` as distinct and `NaNs` as the same. + * + * @param v1 - first input value + * @param v2 - second input value + * @returns boolean indicating whether two arguments are the same + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0 ] ); + * var y = new Float64Array( [ 1.0, 2.0, 3.0 ] ); + * + * var out = ns.isSameFloat64Array( x, y ); + * // returns true + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, 2.0, 3.0 ] ); + * var y = new Float64Array( [ 1.0, 2.0, 4.0 ] ); + * + * var out = ns.isSameFloat64Array( x, y ); + * // returns false + */ + isSameFloat64Array: typeof isSameFloat64Array; + /** * Tests if two arguments have the same native class. *