feat: add ndarray/base/mskfilter

lib/node_modules/@stdlib/ndarray/base/mskfilter/lib/1d.js

@@ -46,7 +46,7 @@
 *
 * var x = {
 *     'dtype': 'float64',
-*     'data': new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] ),
+*     'data': new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 ] ),
 *     'shape': shape,
 *     'strides': sx,
 *     'offset': ox,
@@ -64,8 +64,8 @@
 *
 * var y = {
 *     'dtype': 'float64',
-*     'data': new Float64Array( 4 ),
-*     'shape': [ 4 ],
+*     'data': new Float64Array( 3 ),
+*     'shape': [ 3 ],
 *     'strides': sy,
 *     'offset': 0,
 *     'order': 'row-major'
@@ -74,15 +74,12 @@
 * mskfilter1d( x, mask, y );
 *
 * console.log( y.data );
-* // => <Float64Array>[ 2.0, 0.0, 0.0, 0.0 ]
+* // => <Float64Array>[ 2.0, 6.0, 10.0 ]
 */
 function mskfilter1d( x, mask, y ) {
 	var xbuf;
 	var mbuf;
 	var ybuf;
-	var xlen;
-	var mlen;
-	var ylen;
 	var dx0;
 	var dm0;
 	var dy0;
@@ -108,21 +105,13 @@ function mskfilter1d( x, mask, y ) {
 	mbuf = mask.data;
 	ybuf = y.data;
 
-	// Extract the array lengths...
-	xlen = xbuf.length;
-	mlen = mbuf.length;
-	ylen = ybuf.length;
-
 	// Iterate over the ndarray dimensions...
 	for ( i0 = 0; i0 < S0; i0++ ) {
-		if ( ix >= xlen || im >= mlen || iy >= ylen ) {
-			return;
-		}
 		if ( mbuf[ im ] ) {
 			ybuf[ iy ] = xbuf[ ix ];
+			iy += dy0;
 		}
 		ix += dx0;
-		iy += dy0;
 		im += dm0;
 	}
 }

lib/node_modules/@stdlib/ndarray/base/mskfilter/lib/1d_accessors.js

@@ -45,7 +45,7 @@
 * var sy = [ 1 ];
 *
 * // Define the index offset:
-* var ox = 1;
+* var ox = 0;
 * var om = 0;
 *
 * // Define getters and setters:
@@ -93,18 +93,15 @@
 * // returns <Complex64>
 *
 * var re = realf( v );
-* // returns 3.0
+* // returns 1.0
 *
 * var im = imagf( v );
-* // returns 4.0
+* // returns 2.0
 */
 function mskfilter1d( x, mask, y ) {
 	var xbuf;
 	var mbuf;
 	var ybuf;
-	var xlen;
-	var mlen;
-	var ylen;
 	var getm;
 	var getx;
 	var sety;
@@ -133,27 +130,19 @@ function mskfilter1d( x, mask, y ) {
 	mbuf = mask.data;
 	ybuf = y.data;
 
-	// Extract the array lengths...
-	xlen = xbuf.length;
-	mlen = mbuf.length;
-	ylen = ybuf.length;
-
 	// Cache accessors:
 	getx = x.accessors[ 0 ];
 	getm = mask.accessors[ 0 ];
 	sety = y.accessors[ 1 ];
 
 	// Iterate over the ndarray dimensions...
 	for ( i0 = 0; i0 < S0; i0++ ) {
-		if ( ix >= xlen || im >= mlen || iy >= ylen ) {
-			return;
-		}
 		if ( getm( mbuf, im ) ) {
 			sety( ybuf, iy, getx( xbuf, ix ) );
+			iy += dy0;
 		}
 		ix += dx0;
 		im += dm0;
-		iy += dy0;
 	}
 }
 

lib/node_modules/@stdlib/ndarray/base/mskfilter/lib/2d.js

@@ -0,0 +1,150 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 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';
+
+// MAIN //
+
+/**
+* Apply a mask to a provided input ndarray and assign unmasked values to elements in a provided one-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {Object} mask - object containing mask ndarray meta data
+* @param {Object} y - object containing output ndarray meta data
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Define the shape of the array:
+* var shape = [ 2, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 4, 1 ];
+* var sm = [ 2, 1 ];
+* var sy = [ 1 ];
+*
+* // Define the index offset:
+* var ox = 0;
+* var om = 0;
+*
+* var x = {
+*     'dtype': 'float64',
+*     'data': new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ),
+*     'shape': shape,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+*
+* var mask = {
+*     'dtype': 'float64',
+*     'data': new Float64Array( [ 1, 0, 1, 0 ] ),
+*     'shape': shape,
+*     'strides': sm,
+*     'offset': om,
+*     'order': 'row-major'
+* };
+*
+* var y = {
+*     'dtype': 'float64',
+*     'data': new Float64Array( 2 ),
+*     'shape': [ 2 ],
+*     'strides': sy,
+*     'offset': 0,
+*     'order': 'row-major'
+* };
+*
+* mskfilter2d( x, mask, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 1.0, 5.0 ]
+*/
+function mskfilter2d( x, mask, y ) {
+	var xbuf;
+	var mbuf;
+	var ybuf;
+	var dx0;
+	var dx1;
+	var dm0;
+	var dm1;
+	var dy0;
+	var S0;
+	var S1;
+	var sh;
+	var sm;
+	var sx;
+	var ix;
+	var im;
+	var iy;
+	var i0;
+	var i1;
+
+	// Extract loop variables: dimensions and loop offset (pointer) increments...
+	sh = x.shape;
+	sx = x.strides;
+	sm = mask.strides;
+	if ( x.order === 'row-major' ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 1 ];
+		S1 = sh[ 0 ];
+		dx0 = sx[ 1 ];                // offset increment for innermost loop
+		dx1 = sx[ 0 ] - ( S0*sx[1] ); // offset increment for outermost loop
+		dm0 = sm[ 1 ];
+		dm1 = sm[ 0 ] - ( S0*sm[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		dx0 = sx[ 0 ];                // offset increment for innermost loop
+		dx1 = sx[ 1 ] - ( S0*sx[0] ); // offset increment for outermost loop
+		dm0 = sm[ 0 ];
+		dm1 = sm[ 1 ] - ( S0*sm[0] );
+	}
+	dy0 = y.strides[ 0 ];
+
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	im = mask.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	mbuf = mask.data;
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i1 = 0; i1 < S1; i1++ ) {
+		for ( i0 = 0; i0 < S0; i0++ ) {
+			if ( mbuf[ im ] ) {
+				ybuf[ iy ] = xbuf[ ix ];
+				iy += dy0;
+			}
+			ix += dx0;
+			im += dm0;
+		}
+		ix += dx1;
+		im += dm1;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = mskfilter2d;