feat: add ndarray/base/kernels/generic/nullary-strided1d-by/unblocked

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

@@ -0,0 +1,120 @@
+/**
+* @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 zeros = require( '@stdlib/array/base/zeros' );
+var gfillBy = require( '@stdlib/blas/ext/base/ndarray/gfill-by' );
+var strategy = require( '@stdlib/ndarray/base/kernels/generic/unary-strided1d/strategy' );
+var kernel = require( './../lib' );
+
+function clbk( value, idx ) {
+	return ( idx[ 2 ]*100 ) + ( idx[ 3 ]*10 ) + idx[ 4 ];
+}
+
+// Create a data buffer:
+var xbuf = new Float64Array( 12 );
+
+// Define the array shape:
+var xsh = [ 1, 1, 3, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 12, 12, 4, 2, 1 ];
+
+// Define the index offset:
+var ox = 0;
+
+// Create an input ndarray descriptor:
+var x = {
+	'dtype': 'float64',
+	'data': xbuf,
+	'shape': xsh,
+	'strides': sx,
+	'offset': ox,
+	'order': 'row-major'
+};
+
+// Create an ndarray descriptor for the starting index (inclusive):
+var start = {
+	'dtype': 'float64',
+	'data': new Float64Array( [ 0.0 ] ),
+	'shape': [ 1, 1, 3 ],
+	'strides': [ 0, 0, 0 ],
+	'offset': 0,
+	'order': 'row-major'
+};
+
+// Create an ndarray descriptor for the ending index (exclusive):
+var end = {
+	'dtype': 'float64',
+	'data': new Float64Array( [ 4.0 ] ),
+	'shape': [ 1, 1, 3 ],
+	'strides': [ 0, 0, 0 ],
+	'offset': 0,
+	'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': start.dtype,
+		'data': start.data,
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': start.offset,
+		'order': start.order
+	},
+	{
+		'dtype': end.dtype,
+		'data': end.data,
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': end.offset,
+		'order': end.order
+	}
+];
+
+// Resolve an input strategy when iterating over subarray views:
+var strategyX = strategy( views[ 0 ] );
+
+// Create a workspace array for storing iteration indices:
+var ibuf = zeros( xsh.length );
+
+// Define the loop and core dimensions:
+var ldims = [ 0, 1, 2 ];
+var cdims = [ 3, 4 ];
+
+// Resolve a kernel:
+var f = kernel( 3 );
+
+// Apply strided function:
+f( gfillBy, [ x, start, end ], x, views, [ 1, 1, 3 ], [ 12, 12, 4 ], strategyX, ibuf, ldims, cdims, {}, false, clbk, {} );
+
+console.log( ndarray2array( x.data, x.shape, x.strides, x.offset, x.order ) );

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

@@ -0,0 +1,139 @@
+/**
+* @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, max-params */
+
+'use strict';
+
+// MODULES //
+
+var wrap = require( './callback_wrapper.js' );
+
+
+// MAIN //
+
+/**
+* Applies a one-dimensional strided array function to an input ndarray according to a callback function.
+*
+* ## Notes
+*
+* -   The `views`, `shape`, and `stridesX` 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 {ndarrayLike} ref - original input ndarray provided to a callback function
+* @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 input ndarray
+* @param {Object} strategyX - strategy for marshaling data to and from an input ndarray view
+* @param {NonNegativeIntegerArray} ibuf - workspace for storing iteration indices
+* @param {NonNegativeIntegerArray} ldims - list of loop dimensions
+* @param {NonNegativeIntegerArray} cdims - list of "core" dimensions
+* @param {Options} opts - function options
+* @param {boolean} hasOpts - boolean indicating whether to pass an options argument to a strided array function
+* @param {Function} clbk - callback function
+* @param {*} thisArg - callback execution context
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var zeros = require( '@stdlib/array/base/zeros' );
+* var gfillBy = require( '@stdlib/blas/ext/base/ndarray/gfill-by' );
+* var strategy = require( '@stdlib/ndarray/base/kernels/generic/unary-strided1d/strategy' );
+*
+* function clbk( value, idx ) {
+*     return ( idx[ 0 ]*10 ) + idx[ 1 ];
+* }
+*
+* // Create a data buffer:
+* var xbuf = new Float64Array( 4 );
+*
+* // Define the array shape:
+* var xsh = [ 2, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 2, 1 ];
+*
+* // Define the index offset:
+* var ox = 0;
+*
+* // Create an input ndarray descriptor:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': xsh,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+*
+* // Create an ndarray descriptor for the starting index (inclusive):
+* var start = {
+*     'dtype': 'float64',
+*     'data': new Float64Array( [ 0.0 ] ),
+*     'shape': [],
+*     'strides': [ 0 ],
+*     'offset': 0,
+*     'order': 'row-major'
+* };
+*
+* // Create an ndarray descriptor for the ending index (exclusive):
+* var end = {
+*     'dtype': 'float64',
+*     'data': new Float64Array( [ 4.0 ] ),
+*     'shape': [],
+*     'strides': [ 0 ],
+*     'offset': 0,
+*     'order': 'row-major'
+* };
+*
+* // Resolve an input strategy for the input ndarray:
+* var strategyX = strategy( x );
+*
+* // Create a workspace array for storing iteration indices:
+* var ibuf = zeros( xsh.length );
+*
+* // Define the loop and core dimensions:
+* var ldims = [];
+* var cdims = [ 0, 1 ];
+*
+* // Apply strided function:
+* kernel( gfillBy, [ x, start, end ], x, [], [], [], strategyX, ibuf, ldims, cdims, {}, false, clbk, {} );
+*
+* var arr = ndarray2array( x.data, x.shape, x.strides, x.offset, x.order );
+* // returns [ [ 0.0, 1.0 ], [ 10.0, 11.0 ] ]
+*/
+function kernel( fcn, arrays, ref, views, shape, stridesX, strategyX, ibuf, ldims, cdims, opts, hasOpts, clbk, thisArg ) {
+	var f;
+
+	f = wrap( ref, arrays[ 0 ], ibuf, ldims, [], cdims, clbk, thisArg );
+	arrays[ 0 ] = strategyX.input( arrays[ 0 ] );
+	if ( hasOpts ) {
+		fcn( arrays, opts, f );
+	} else {
+		fcn( arrays, f );
+	}
+	strategyX.output( arrays[ 0 ] );
+}
+
+
+// EXPORTS //
+
+module.exports = kernel;