feat: add ndarray/base/kernels/generic/binary-strided1d/unblocked

lib/node_modules/@stdlib/ndarray/base/kernels/generic/binary-strided1d/unblocked/examples/index.js

@@ -0,0 +1,119 @@
+/**
+* @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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var gwxpy = require( '@stdlib/blas/ext/base/ndarray/gwxpy' );
+var strategy = require( '@stdlib/ndarray/base/kernels/generic/unary-strided1d/strategy' );
+var kernel = require( './../lib' );
+
+// Create data buffers:
+var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+var ybuf = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0 ] );
+var zbuf = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+// Define the array shapes:
+var xsh = [ 1, 1, 1, 1, 3, 2, 2 ];
+var ysh = [ 1, 1, 1, 1, 3, 2, 2 ];
+var zsh = [ 1, 1, 1, 1, 3, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 12, 12, 12, 12, 4, 2, 1 ];
+var sy = [ 12, 12, 12, 12, 4, 2, 1 ];
+var sz = [ 12, 12, 12, 12, 4, 2, 1 ];
+
+// Define the index offsets:
+var ox = 0;
+var oy = 0;
+var oz = 0;
+
+// Create the input ndarray descriptors:
+var x = {
+	'dtype': 'float64',
+	'data': xbuf,
+	'shape': xsh,
+	'strides': sx,
+	'offset': ox,
+	'order': 'row-major'
+};
+
+var y = {
+	'dtype': 'float64',
+	'data': ybuf,
+	'shape': ysh,
+	'strides': sy,
+	'offset': oy,
+	'order': 'row-major'
+};
+
+// Create an output ndarray descriptor:
+var z = {
+	'dtype': 'float64',
+	'data': zbuf,
+	'shape': zsh,
+	'strides': sz,
+	'offset': oz,
+	'order': 'row-major'
+};
+
+// Initialize ndarray descriptors representing subarray views:
+var views = [
+	{
+		'dtype': x.dtype,
+		'data': x.data,
+		'shape': [ 2, 2 ],
+		'strides': [ 2, 1 ],
+		'offset': x.offset,
+		'order': x.order
+	},
+	{
+		'dtype': y.dtype,
+		'data': y.data,
+		'shape': [ 2, 2 ],
+		'strides': [ 2, 1 ],
+		'offset': y.offset,
+		'order': y.order
+	},
+	{
+		'dtype': z.dtype,
+		'data': z.data,
+		'shape': [ 2, 2 ],
+		'strides': [ 2, 1 ],
+		'offset': z.offset,
+		'order': z.order
+	}
+];
+
+// Resolve input/output strategies when iterating over subarray views:
+var strategyX = strategy( views[ 0 ] );
+var strategyY = strategy( views[ 1 ] );
+var strategyZ = strategy( views[ 2 ] );
+
+// Resolve a kernel:
+var f = kernel( 5 );
+
+// Apply strided function:
+f( gwxpy, [ x, y, z ], views, [ 1, 1, 1, 1, 3 ], [ 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 4 ], strategyX, strategyY, strategyZ, {} );
+
+console.log( ndarray2array( x.data, x.shape, x.strides, x.offset, x.order ) );
+console.log( ndarray2array( y.data, y.shape, y.strides, y.offset, y.order ) );
+console.log( ndarray2array( z.data, z.shape, z.strides, z.offset, z.order ) );

lib/node_modules/@stdlib/ndarray/base/kernels/generic/binary-strided1d/unblocked/lib/0d.js

@@ -0,0 +1,137 @@
+/**
+* @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 one-dimensional strided array function to a list of specified dimensions in two input ndarrays and assigns results to a provided output ndarray.
+*
+* ## Notes
+*
+* -   The `views`, `shape`, `stridesX`, `stridesY`, and `stridesZ` parameters are unused. Providing empty arrays for these parameters is recommended in order to ensure a monomorphic API.
+*
+* @private
+* @param {Function} fcn - wrapper for a one-dimensional strided array function
+* @param {Array<Object>} arrays - ndarray descriptors
+* @param {Array<Object>} views - initialized ndarray descriptors representing subarray views
+* @param {Array<integer>} shape - loop dimensions
+* @param {Array<integer>} stridesX - loop dimension strides for the first input ndarray
+* @param {Array<integer>} stridesY - loop dimension strides for the second input ndarray
+* @param {Array<integer>} stridesZ - loop dimension strides for the output ndarray
+* @param {Object} strategyX - strategy for marshaling data to and from a first input ndarray view
+* @param {Object} strategyY - strategy for marshaling data to and from a second input ndarray view
+* @param {Object} strategyZ - strategy for marshaling data to and from an output ndarray view
+* @param {Options} opts - function options
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var gwxpy = require( '@stdlib/blas/ext/base/ndarray/gwxpy' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+* var ybuf = new Float64Array( [ 2.0, 3.0, 4.0, 5.0 ] );
+* var zbuf = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] );
+*
+* // Define the array shapes:
+* var xsh = [ 2, 2 ];
+* var ysh = [ 2, 2 ];
+* var zsh = [ 2, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 2, 1 ];
+* var sy = [ 2, 1 ];
+* var sz = [ 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+*
+* // Create the input ndarray descriptors:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+*
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': ysh,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Create an output ndarray descriptor:
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': zsh,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+*
+* // Define an input strategy:
+* function inputStrategy( x ) {
+*     return {
+*         'dtype': x.dtype,
+*         'data': x.data,
+*         'shape': [ 4 ],
+*         'strides': [ 1 ],
+*         'offset': x.offset,
+*         'order': x.order
+*     };
+* }
+*
+* // Define an output strategy:
+* function outputStrategy( x ) {
+*     return x;
+* }
+*
+* var strategy = {
+*     'input': inputStrategy,
+*     'output': outputStrategy
+* };
+*
+* // Apply strided function:
+* kernel( gwxpy, [ x, y, z ], [], [], [], [], [], strategy, strategy, strategy, {} );
+*
+* var v = z.data;
+* // returns <Float64Array>[ 3.0, 5.0, 7.0, 9.0 ]
+*/
+function kernel( fcn, arrays, views, shape, stridesX, stridesY, stridesZ, strategyX, strategyY, strategyZ, opts ) { // eslint-disable-line max-len, max-params
+	arrays[ 0 ] = strategyX.input( arrays[ 0 ] );
+	arrays[ 1 ] = strategyY.input( arrays[ 1 ] );
+	arrays[ 2 ] = strategyZ.input( arrays[ 2 ] );
+	fcn( arrays, opts );
+	strategyZ.output( arrays[ 2 ] );
+}
+
+
+// EXPORTS //
+
+module.exports = kernel;