@stdlib/stats-strided-snanmskrange 0.1.0

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../lib/ndarray.js", "../lib/snanmskrange.js", "../lib/main.js", "../lib/index.js"],
+  "sourcesContent": ["/**\n* @license Apache-2.0\n*\n* Copyright (c) 2020 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar float64ToFloat32 = require( '@stdlib/number-float64-base-to-float32' );\nvar isnanf = require( '@stdlib/math-base-assert-is-nanf' );\n\n\n// MAIN //\n\n/**\n* Computes the range of a single-precision floating-point strided array according to a mask, ignoring `NaN` values.\n*\n* @param {PositiveInteger} N - number of indexed elements\n* @param {Float32Array} x - input array\n* @param {integer} strideX - `x` stride length\n* @param {NonNegativeInteger} offsetX - `x` starting index\n* @param {Uint8Array} mask - mask array\n* @param {integer} strideMask - `mask` stride length\n* @param {NonNegativeInteger} offsetMask - `mask` starting index\n* @returns {number} range\n*\n* @example\n* var Float32Array = require( '@stdlib/array-float32' );\n* var Uint8Array = require( '@stdlib/array-uint8' );\n*\n* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\n* var mask = new Uint8Array( [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 ] );\n*\n* var v = snanmskrange( 5, x, 2, 1, mask, 2, 1 );\n* // returns 6.0\n*/\nfunction snanmskrange( N, x, strideX, offsetX, mask, strideMask, offsetMask ) {\n\tvar max;\n\tvar min;\n\tvar ix;\n\tvar im;\n\tvar v;\n\tvar i;\n\n\tif ( N <= 0 ) {\n\t\treturn NaN;\n\t}\n\tix = offsetX;\n\tim = offsetMask;\n\tfor ( i = 0; i < N; i++ ) {\n\t\tv = x[ ix ];\n\t\tif ( v === v && mask[ im ] === 0 ) {\n\t\t\tbreak;\n\t\t}\n\t\tix += strideX;\n\t\tim += strideMask;\n\t}\n\tif ( i === N ) {\n\t\treturn NaN;\n\t}\n\tmin = v;\n\tmax = min;\n\ti += 1;\n\tfor ( i; i < N; i++ ) {\n\t\tix += strideX;\n\t\tim += strideMask;\n\t\tif ( mask[ im ] ) {\n\t\t\tcontinue;\n\t\t}\n\t\tv = x[ ix ];\n\t\tif ( isnanf( v ) ) {\n\t\t\tcontinue;\n\t\t}\n\t\tif ( v < min ) {\n\t\t\tmin = v;\n\t\t} else if ( v > max ) {\n\t\t\tmax = v;\n\t\t}\n\t}\n\treturn float64ToFloat32( max - min );\n}\n\n\n// EXPORTS //\n\nmodule.exports = snanmskrange;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2020 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar stride2offset = require( '@stdlib/strided-base-stride2offset' );\nvar ndarray = require( './ndarray.js' );\n\n\n// MAIN //\n\n/**\n* Computes the range of a single-precision floating-point strided array according to a mask, ignoring `NaN` values.\n*\n* @param {PositiveInteger} N - number of indexed elements\n* @param {Float32Array} x - input array\n* @param {integer} strideX - `x` stride length\n* @param {Uint8Array} mask - mask array\n* @param {integer} strideMask - `mask` stride length\n* @returns {number} range\n*\n* @example\n* var Float32Array = require( '@stdlib/array-float32' );\n* var Uint8Array = require( '@stdlib/array-uint8' );\n*\n* var x = new Float32Array( [ 1.0, -2.0, 4.0, 2.0, NaN ] );\n* var mask = new Uint8Array( [ 0, 0, 1, 0, 0 ] );\n*\n* var v = snanmskrange( x.length, x, 1, mask, 1 );\n* // returns 4.0\n*/\nfunction snanmskrange( N, x, strideX, mask, strideMask ) {\n\treturn ndarray( N, x, strideX, stride2offset( N, strideX ), mask, strideMask, stride2offset( N, strideMask ) ); // eslint-disable-line max-len\n}\n\n\n// EXPORTS //\n\nmodule.exports = snanmskrange;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2020 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );\nvar snanmskrange = require( './snanmskrange.js' );\nvar ndarray = require( './ndarray.js' );\n\n\n// MAIN //\n\nsetReadOnly( snanmskrange, 'ndarray', ndarray );\n\n\n// EXPORTS //\n\nmodule.exports = snanmskrange;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2020 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n/**\n* Compute the range of a single-precision floating-point strided array according to a mask, ignoring `NaN` values.\n*\n* @module @stdlib/stats-strided-snanmskrange\n*\n* @example\n* var Float32Array = require( '@stdlib/array-float32' );\n* var Uint8Array = require( '@stdlib/array-uint8' );\n* var snanmskrange = require( '@stdlib/stats-strided-snanmskrange' );\n*\n* var x = new Float32Array( [ 1.0, -2.0, 4.0, 2.0, NaN ] );\n* var mask = new Uint8Array( [ 0, 0, 1, 0, 0 ] );\n*\n* var v = snanmskrange( x.length, x, 1, mask, 1 );\n* // returns 4.0\n*\n* @example\n* var Float32Array = require( '@stdlib/array-float32' );\n* var Uint8Array = require( '@stdlib/array-uint8' );\n* var snanmskrange = require( '@stdlib/stats-strided-snanmskrange' );\n*\n* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );\n* var mask = new Uint8Array( [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 ] );\n*\n* var v = snanmskrange.ndarray( 5, x, 2, 1, mask, 2, 1 );\n* // returns 6.0\n*/\n\n// MODULES //\n\nvar join = require( 'path' ).join;\nvar tryRequire = require( '@stdlib/utils-try-require' );\nvar isError = require( '@stdlib/assert-is-error' );\nvar main = require( './main.js' );\n\n\n// MAIN //\n\nvar snanmskrange;\nvar tmp = tryRequire( join( __dirname, './native.js' ) );\nif ( isError( tmp ) ) {\n\tsnanmskrange = main;\n} else {\n\tsnanmskrange = tmp;\n}\n\n\n// EXPORTS //\n\nmodule.exports = snanmskrange;\n\n// exports: { \"ndarray\": \"snanmskrange.ndarray\" }\n"],
+  "mappings": "uGAAA,IAAAA,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAmB,QAAS,wCAAyC,EACrEC,EAAS,QAAS,kCAAmC,EA2BzD,SAASC,EAAcC,EAAGC,EAAGC,EAASC,EAASC,EAAMC,EAAYC,EAAa,CAC7E,IAAIC,EACAC,EACAC,EACAC,EACAC,EACA,EAEJ,GAAKX,GAAK,EACT,MAAO,KAIR,IAFAS,EAAKN,EACLO,EAAKJ,EACC,EAAI,EAAG,EAAIN,IAChBW,EAAIV,EAAGQ,CAAG,EACL,EAAAE,IAAMA,GAAKP,EAAMM,CAAG,IAAM,IAFZ,IAKnBD,GAAMP,EACNQ,GAAML,EAEP,GAAK,IAAML,EACV,MAAO,KAKR,IAHAQ,EAAMG,EACNJ,EAAMC,EACN,GAAK,EACC,EAAG,EAAIR,EAAG,IACfS,GAAMP,EACNQ,GAAML,EACD,CAAAD,EAAMM,CAAG,IAGdC,EAAIV,EAAGQ,CAAG,EACL,CAAAX,EAAQa,CAAE,IAGVA,EAAIH,EACRA,EAAMG,EACKA,EAAIJ,IACfA,EAAMI,KAGR,OAAOd,EAAkBU,EAAMC,CAAI,CACpC,CAKAZ,EAAO,QAAUG,ICnGjB,IAAAa,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAgB,QAAS,oCAAqC,EAC9DC,EAAU,IAyBd,SAASC,EAAcC,EAAGC,EAAGC,EAASC,EAAMC,EAAa,CACxD,OAAON,EAASE,EAAGC,EAAGC,EAASL,EAAeG,EAAGE,CAAQ,EAAGC,EAAMC,EAAYP,EAAeG,EAAGI,CAAW,CAAE,CAC9G,CAKAR,EAAO,QAAUG,ICvDjB,IAAAM,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAc,QAAS,uDAAwD,EAC/EC,EAAe,IACfC,EAAU,IAKdF,EAAaC,EAAc,UAAWC,CAAQ,EAK9CH,EAAO,QAAUE,ICgBjB,IAAIE,EAAO,QAAS,MAAO,EAAE,KACzBC,EAAa,QAAS,2BAA4B,EAClDC,EAAU,QAAS,yBAA0B,EAC7CC,EAAO,IAKPC,EACAC,EAAMJ,EAAYD,EAAM,UAAW,aAAc,CAAE,EAClDE,EAASG,CAAI,EACjBD,EAAeD,EAEfC,EAAeC,EAMhB,OAAO,QAAUD",
+  "names": ["require_ndarray", "__commonJSMin", "exports", "module", "float64ToFloat32", "isnanf", "snanmskrange", "N", "x", "strideX", "offsetX", "mask", "strideMask", "offsetMask", "max", "min", "ix", "im", "v", "require_snanmskrange", "__commonJSMin", "exports", "module", "stride2offset", "ndarray", "snanmskrange", "N", "x", "strideX", "mask", "strideMask", "require_main", "__commonJSMin", "exports", "module", "setReadOnly", "snanmskrange", "ndarray", "join", "tryRequire", "isError", "main", "snanmskrange", "tmp"]
+}

package/docs/types/index.d.ts

@@ -0,0 +1,107 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2020 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.
+*/
+
+// TypeScript Version: 4.1
+
+/**
+* Interface describing `snanmskrange`.
+*/
+interface Routine {
+	/**
+	* Computes the range of a single-precision floating-point strided array according to a mask, ignoring `NaN` values.
+	*
+	* @param N - number of indexed elements
+	* @param x - input array
+	* @param strideX - `x` stride length
+	* @param mask - mask array
+	* @param strideMask - `mask` stride length
+	* @returns range
+	*
+	* @example
+	* var Float32Array = require( '@stdlib/array-float32' );
+	* var Uint8Array = require( '@stdlib/array-uint8' );
+	*
+	* var x = new Float32Array( [ 1.0, -2.0, 4.0, 2.0, NaN ] );
+	* var mask = new Uint8Array( [ 0, 0, 1, 0, 0 ] );
+	*
+	* var v = snanmskrange( x.length, x, 1, mask, 1 );
+	* // returns 4.0
+	*/
+	( N: number, x: Float32Array, strideX: number, mask: Uint8Array, strideMask: number ): number;
+
+	/**
+	* Computes the range of a single-precision floating-point strided array according to a mask, ignoring `NaN` values and using alternative indexing semantics.
+	*
+	* @param N - number of indexed elements
+	* @param x - input array
+	* @param strideX - `x` stride length
+	* @param offsetX - `x` starting index
+	* @param mask - mask array
+	* @param strideMask - `mask` stride length
+	* @param offsetMask - `mask` starting index
+	* @returns range
+	*
+	* @example
+	* var Float32Array = require( '@stdlib/array-float32' );
+	* var Uint8Array = require( '@stdlib/array-uint8' );
+	*
+	* var x = new Float32Array( [ 1.0, -2.0, 4.0, 2.0, NaN ] );
+	* var mask = new Uint8Array( [ 0, 0, 1, 0, 0 ] );
+	*
+	* var v = snanmskrange.ndarray( x.length, x, 1, 0, mask, 1, 0 );
+	* // returns 4.0
+	*/
+	ndarray( N: number, x: Float32Array, strideX: number, offsetX: number, mask: Uint8Array, strideMask: number, offsetMask: number ): number;
+}
+
+/**
+* Computes the range of a single-precision floating-point strided array according to a mask, ignoring `NaN` values.
+*
+* @param N - number of indexed elements
+* @param x - input array
+* @param strideX - `x` stride length
+* @param mask - mask array
+* @param strideMask - `mask` stride length
+* @returns range
+*
+* @example
+* var Float32Array = require( '@stdlib/array-float32' );
+* var Uint8Array = require( '@stdlib/array-uint8' );
+*
+* var x = new Float32Array( [ 1.0, -2.0, 4.0, 2.0, NaN ] );
+* var mask = new Uint8Array( [ 0, 0, 1, 0, 0 ] );
+*
+* var v = snanmskrange( x.length, x, 1, mask, 1 );
+* // returns 4.0
+*
+* @example
+* var Float32Array = require( '@stdlib/array-float32' );
+* var Uint8Array = require( '@stdlib/array-uint8' );
+*
+* var x = new Float32Array( [ 1.0, -2.0, 4.0, 2.0, NaN ] );
+* var mask = new Uint8Array( [ 0, 0, 1, 0, 0 ] );
+*
+* var v = snanmskrange.ndarray( x.length, x, 1, 0, mask, 1, 0 );
+* // returns 4.0
+*/
+declare var snanmskrange: Routine;
+
+
+// EXPORTS //
+
+export = snanmskrange;

package/include/stdlib/stats/strided/snanmskrange.h

@@ -0,0 +1,46 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2020 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.
+*/
+
+#ifndef STDLIB_STATS_STRIDED_SNANMSKRANGE_H
+#define STDLIB_STATS_STRIDED_SNANMSKRANGE_H
+
+#include "stdlib/blas/base/shared.h"
+#include <stdint.h>
+
+/*
+* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Computes the range of a single-precision floating-point strided array according to a mask, ignoring `NaN` values.
+*/
+float API_SUFFIX(stdlib_strided_snanmskrange)( const CBLAS_INT N, const float *X, const CBLAS_INT strideX, const uint8_t *Mask, const CBLAS_INT strideMask );
+
+/**
+* Computes the range of a single-precision floating-point strided array according to a mask, ignoring `NaN` values and using alternative indexing semantics.
+*/
+float API_SUFFIX(stdlib_strided_snanmskrange_ndarray)( const CBLAS_INT N, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, const uint8_t *Mask, const CBLAS_INT strideMask, const CBLAS_INT offsetMask );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !STDLIB_STATS_STRIDED_SNANMSKRANGE_H

package/lib/index.js

@@ -0,0 +1,72 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2020 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';
+
+/**
+* Compute the range of a single-precision floating-point strided array according to a mask, ignoring `NaN` values.
+*
+* @module @stdlib/stats-strided-snanmskrange
+*
+* @example
+* var Float32Array = require( '@stdlib/array-float32' );
+* var Uint8Array = require( '@stdlib/array-uint8' );
+* var snanmskrange = require( '@stdlib/stats-strided-snanmskrange' );
+*
+* var x = new Float32Array( [ 1.0, -2.0, 4.0, 2.0, NaN ] );
+* var mask = new Uint8Array( [ 0, 0, 1, 0, 0 ] );
+*
+* var v = snanmskrange( x.length, x, 1, mask, 1 );
+* // returns 4.0
+*
+* @example
+* var Float32Array = require( '@stdlib/array-float32' );
+* var Uint8Array = require( '@stdlib/array-uint8' );
+* var snanmskrange = require( '@stdlib/stats-strided-snanmskrange' );
+*
+* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+* var mask = new Uint8Array( [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 ] );
+*
+* var v = snanmskrange.ndarray( 5, x, 2, 1, mask, 2, 1 );
+* // returns 6.0
+*/
+
+// MODULES //
+
+var join = require( 'path' ).join;
+var tryRequire = require( '@stdlib/utils-try-require' );
+var isError = require( '@stdlib/assert-is-error' );
+var main = require( './main.js' );
+
+
+// MAIN //
+
+var snanmskrange;
+var tmp = tryRequire( join( __dirname, './native.js' ) );
+if ( isError( tmp ) ) {
+	snanmskrange = main;
+} else {
+	snanmskrange = tmp;
+}
+
+
+// EXPORTS //
+
+module.exports = snanmskrange;
+
+// exports: { "ndarray": "snanmskrange.ndarray" }

package/lib/main.js

@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2020 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 setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );
+var snanmskrange = require( './snanmskrange.js' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+setReadOnly( snanmskrange, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = snanmskrange;

package/lib/native.js

@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2020 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 setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );
+var snanmskrange = require( './snanmskrange.native.js' );
+var ndarray = require( './ndarray.native.js' );
+
+
+// MAIN //
+
+setReadOnly( snanmskrange, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = snanmskrange;

package/lib/ndarray.js

@@ -0,0 +1,100 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2020 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 float64ToFloat32 = require( '@stdlib/number-float64-base-to-float32' );
+var isnanf = require( '@stdlib/math-base-assert-is-nanf' );
+
+
+// MAIN //
+
+/**
+* Computes the range of a single-precision floating-point strided array according to a mask, ignoring `NaN` values.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {Float32Array} x - input array
+* @param {integer} strideX - `x` stride length
+* @param {NonNegativeInteger} offsetX - `x` starting index
+* @param {Uint8Array} mask - mask array
+* @param {integer} strideMask - `mask` stride length
+* @param {NonNegativeInteger} offsetMask - `mask` starting index
+* @returns {number} range
+*
+* @example
+* var Float32Array = require( '@stdlib/array-float32' );
+* var Uint8Array = require( '@stdlib/array-uint8' );
+*
+* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+* var mask = new Uint8Array( [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 ] );
+*
+* var v = snanmskrange( 5, x, 2, 1, mask, 2, 1 );
+* // returns 6.0
+*/
+function snanmskrange( N, x, strideX, offsetX, mask, strideMask, offsetMask ) {
+	var max;
+	var min;
+	var ix;
+	var im;
+	var v;
+	var i;
+
+	if ( N <= 0 ) {
+		return NaN;
+	}
+	ix = offsetX;
+	im = offsetMask;
+	for ( i = 0; i < N; i++ ) {
+		v = x[ ix ];
+		if ( v === v && mask[ im ] === 0 ) {
+			break;
+		}
+		ix += strideX;
+		im += strideMask;
+	}
+	if ( i === N ) {
+		return NaN;
+	}
+	min = v;
+	max = min;
+	i += 1;
+	for ( i; i < N; i++ ) {
+		ix += strideX;
+		im += strideMask;
+		if ( mask[ im ] ) {
+			continue;
+		}
+		v = x[ ix ];
+		if ( isnanf( v ) ) {
+			continue;
+		}
+		if ( v < min ) {
+			min = v;
+		} else if ( v > max ) {
+			max = v;
+		}
+	}
+	return float64ToFloat32( max - min );
+}
+
+
+// EXPORTS //
+
+module.exports = snanmskrange;

package/lib/ndarray.native.js

@@ -0,0 +1,57 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2020 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 addon = require( './../src/addon.node' );
+
+
+// MAIN //
+
+/**
+* Computes the range of a single-precision floating-point strided array according to a mask, ignoring `NaN` values.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {Float32Array} x - input array
+* @param {integer} strideX - `x` stride length
+* @param {NonNegativeInteger} offsetX - `x` starting index
+* @param {Uint8Array} mask - mask array
+* @param {integer} strideMask - `mask` stride length
+* @param {NonNegativeInteger} offsetMask - `mask` starting index
+* @returns {number} range
+*
+* @example
+* var Float32Array = require( '@stdlib/array-float32' );
+* var Uint8Array = require( '@stdlib/array-uint8' );
+*
+* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+* var mask = new Uint8Array( [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 ] );
+*
+* var v = snanmskrange( 5, x, 2, 1, mask, 2, 1 );
+* // returns 6.0
+*/
+function snanmskrange( N, x, strideX, offsetX, mask, strideMask, offsetMask ) {
+	return addon.ndarray( N, x, strideX, offsetX, mask, strideMask, offsetMask ); // eslint-disable-line max-len
+}
+
+
+// EXPORTS //
+
+module.exports = snanmskrange;

package/lib/snanmskrange.js

@@ -0,0 +1,56 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2020 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 stride2offset = require( '@stdlib/strided-base-stride2offset' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+/**
+* Computes the range of a single-precision floating-point strided array according to a mask, ignoring `NaN` values.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {Float32Array} x - input array
+* @param {integer} strideX - `x` stride length
+* @param {Uint8Array} mask - mask array
+* @param {integer} strideMask - `mask` stride length
+* @returns {number} range
+*
+* @example
+* var Float32Array = require( '@stdlib/array-float32' );
+* var Uint8Array = require( '@stdlib/array-uint8' );
+*
+* var x = new Float32Array( [ 1.0, -2.0, 4.0, 2.0, NaN ] );
+* var mask = new Uint8Array( [ 0, 0, 1, 0, 0 ] );
+*
+* var v = snanmskrange( x.length, x, 1, mask, 1 );
+* // returns 4.0
+*/
+function snanmskrange( N, x, strideX, mask, strideMask ) {
+	return ndarray( N, x, strideX, stride2offset( N, strideX ), mask, strideMask, stride2offset( N, strideMask ) ); // eslint-disable-line max-len
+}
+
+
+// EXPORTS //
+
+module.exports = snanmskrange;

package/lib/snanmskrange.native.js

@@ -0,0 +1,55 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2020 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 addon = require( './../src/addon.node' );
+
+
+// MAIN //
+
+/**
+* Computes the range of a single-precision floating-point strided array according to a mask, ignoring `NaN` values.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {Float32Array} x - input array
+* @param {integer} strideX - `x` stride length
+* @param {Uint8Array} mask - mask array
+* @param {integer} strideMask - `mask` stride length
+* @returns {number} range
+*
+* @example
+* var Float32Array = require( '@stdlib/array-float32' );
+* var Uint8Array = require( '@stdlib/array-uint8' );
+*
+* var x = new Float32Array( [ 1.0, -2.0, 4.0, 2.0, NaN ] );
+* var mask = new Uint8Array( [ 0, 0, 1, 0, 0 ] );
+*
+* var v = snanmskrange( x.length, x, 1, mask, 1 );
+* // returns 4.0
+*/
+function snanmskrange( N, x, strideX, mask, strideMask ) {
+	return addon( N, x, strideX, mask, strideMask );
+}
+
+
+// EXPORTS //
+
+module.exports = snanmskrange;