feat: add 2d accessors implementation

Author: LoayAhmed304

lib/node_modules/@stdlib/ndarray/base/where/lib/2d_accessors.js

@@ -0,0 +1,220 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 //
+
+/**
+* Applies a condition to two two-dimensional input ndarrays according to a two-dimensional boolean ndarray and assigns results to elements in a two-dimensional output ndarray.
+*
+* @private
+* @param {Object} condition - object containing boolean condition ndarray meta data
+* @param {*} condition.dtype - data type
+* @param {Collection} condition.data - data buffer
+* @param {NonNegativeIntegerArray} condition.shape - dimensions
+* @param {IntegerArray} condition.strides - stride lengths
+* @param {NonNegativeInteger} condition.offset - index offset
+* @param {string} condition.order - specifies whether `condition` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing input ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} out - object containing output ndarray meta data
+* @param {*} out.dtype - data type
+* @param {Collection} out.data - data buffer
+* @param {NonNegativeIntegerArray} out.shape - dimensions
+* @param {IntegerArray} out.strides - stride lengths
+* @param {NonNegativeInteger} out.offset - index offset
+* @param {string} out.order - specifies whether `out` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var Uint8Array = require( '@stdlib/array/uint8' );
+*
+* // Create data buffers:
+* var cbuf = new Uint8Array( [ 1, 0, 0, 1 ] );
+* var xbuf = new Float64Array( [  1.0,  2.0,  3.0,  4.0 ] );
+* var ybuf = new Float64Array( [ -1.0, -2.0, -3.0, -4.0 ] );
+* var obuf = new Float64Array( 4 );
+*
+* // Define the shape of the arrays:
+* var shape = [ 2, 2 ];
+*
+* // Define the array strides:
+* var sc = [ 2, 1 ];
+* var sx = [ 2, 1 ];
+* var sy = [ 2, 1 ];
+* var so = [ 2, 1 ];
+*
+* // Define the index offsets:
+* var oc = 0;
+* var ox = 0;
+* var oy = 0;
+* var oo = 0;
+*
+* // Create the ndarray-like objects:
+* var condition = {
+*     'dtype': 'uint8',
+*     'data': cbuf,
+*     'shape': shape,
+*     'strides': sc,
+*     'offset': oc,
+*     'order': 'row-major'
+* };
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': shape,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+* var out = {
+*     'dtype': 'float64',
+*     'data': obuf,
+*     'shape': shape,
+*     'strides': so,
+*     'offset': oo,
+*     'order': 'row-major'
+* };
+*
+* // Apply the condition:
+* where2d( condition, x, y, out, true );
+*
+* console.log( out.data );
+* // => <Float64Array>[ 1.0, -2.0, -3.0, 4.0 ]
+*/
+function where2d( condition, x, y, out, isRowMajor ) {
+	var cbuf;
+	var xbuf;
+	var ybuf;
+	var obuf;
+	var dc0;
+	var dc1;
+	var dx0;
+	var dx1;
+	var dy0;
+	var dy1;
+	var do0;
+	var do1;
+	var sh;
+	var S0;
+	var S1;
+	var sc;
+	var sx;
+	var sy;
+	var so;
+	var ic;
+	var ix;
+	var iy;
+	var io;
+	var i0;
+	var i1;
+
+	// Note on variable naming convention: S#, dc#, dx#, dy#, do#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = condition.shape;
+	sc = condition.strides;
+	sx = x.strides;
+	sy = y.strides;
+	so = out.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 1 ];
+		S1 = sh[ 0 ];
+		dc0 = sc[ 1 ];                 // offset increment for innermost loop
+		dc1 = sc[ 0 ] - ( S0*sc[1] );  // offset increment for outermost loop
+		dx0 = sx[ 1 ];
+		dx1 = sx[ 0 ] - ( S0*sx[1] );
+		dy0 = sy[ 1 ];
+		dy1 = sy[ 0 ] - ( S0*sy[1] );
+		do0 = so[ 1 ];
+		do1 = so[ 0 ] - ( S0*so[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		dc0 = sc[ 0 ];                 // offset increment for innermost loop
+		dc1 = sc[ 1 ] - ( S0*sc[0] );  // offset increment for outermost loop
+		dx0 = sx[ 0 ];
+		dx1 = sx[ 1 ] - ( S0*sx[0] );
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		do0 = so[ 0 ];
+		do1 = so[ 1 ] - ( S0*so[0] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ic = condition.offset;
+	ix = x.offset;
+	iy = y.offset;
+	io = out.offset;
+
+	// Cache references to the ndarray buffers...
+	cbuf = condition.data;
+	xbuf = x.data;
+	ybuf = y.data;
+	obuf = out.data;
+
+    // Cache accessors
+    getx = x.accessors[ 0 ];
+    gety = y.accessors[ 0 ];
+    getc = condition.accessors[ 0 ];
+    seto = out.accessors[ 1 ];
+
+	// Iterate over the ndarray dimensions...
+	for ( i1 = 0; i1 < S1; i1++ ) {
+		for ( i0 = 0; i0 < S0; i0++ ) {
+			seto( obuf, io, ( getc( cbuf, ic ) ) ? getx( xbuf, ix ) : gety( ybuf, iy ) );
+			ic += dc0;
+			ix += dx0;
+			iy += dy0;
+			io += do0;
+		}
+		ic += dc1;
+		ix += dx1;
+		iy += dy1;
+		io += do1;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = where2d;