feat: add ndarray/base/kernels/generic/unary-strided2d/strategy

lib/node_modules/@stdlib/ndarray/base/kernels/generic/unary-strided2d/strategy/README.md

@@ -0,0 +1,201 @@
+<!--
+
+@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.
+
+-->
+
+# strategy
+
+> Return an object containing methods for reshaping an ndarray as a two-dimensional strided array view.
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var strategy = require( '@stdlib/ndarray/base/kernels/generic/unary-strided2d/strategy' );
+```
+
+#### strategy( x )
+
+Returns an object containing methods for reshaping an ndarray as a two-dimensional strided array view.
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+var x = {
+    'dtype': 'float64',
+    'data': new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ),
+    'shape': [ 2, 2 ],
+    'strides': [ 2, 1 ],
+    'offset': 0,
+    'order': 'row-major'
+};
+
+var out = strategy( x );
+// returns {...}
+```
+
+The function accepts the following arguments:
+
+-   **x**: ndarray [descriptor][@stdlib/ndarray/base/descriptor].
+
+</section>
+
+<!-- /.usage -->
+
+<section class="notes">
+
+## Notes
+
+-   The function returns an object having the following properties:
+
+    -   **input**: function providing a strategy for reshaping an input ndarray to a two-dimensional input ndarray view **prior** to applying a two-dimensional strided array function.
+    -   **output**: function providing a strategy for reshaping the results of a two-dimensional strided array function to the shape of an input ndarray **after** applying a two-dimensional strided array function. This function should only be invoked for input ndarrays which are written to by the two-dimensional strided array function.
+
+</section>
+
+<!-- /.notes -->
+
+<section class="examples">
+
+## Examples
+
+<!-- eslint-disable max-len -->
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var gtriu = require( '@stdlib/blas/ext/base/ndarray/gtriu' );
+var resolveKernel = require( '@stdlib/ndarray/base/kernels/generic/unary-strided2d/unblocked' );
+var strategy = require( '@stdlib/ndarray/base/kernels/generic/unary-strided2d/strategy' );
+
+// 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( [ 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 ];
+
+// Define the array strides:
+var sx = [ 12, 12, 12, 12, 4, 2, 1 ];
+var sy = [ 12, 12, 12, 12, 4, 2, 1 ];
+
+// Define the index offsets:
+var ox = 0;
+var oy = 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 diagonal below which to ignore:
+var k = {
+    'dtype': 'float64',
+    'data': new Float64Array( [ 0.0 ] ),
+    'shape': [ 1, 1, 1, 1, 3 ],
+    'strides': [ 0, 0, 0, 0, 0 ],
+    'offset': 0,
+    'order': 'row-major'
+};
+
+// Create an output ndarray descriptor:
+var y = {
+    'dtype': 'float64',
+    'data': ybuf,
+    'shape': ysh,
+    'strides': sy,
+    'offset': oy,
+    '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': k.dtype,
+        'data': k.data,
+        'shape': [],
+        'strides': [ 0 ],
+        'offset': k.offset,
+        'order': k.order
+    }
+];
+
+// Resolve input/output strategies when iterating over subarray views:
+var strategyX = strategy( views[ 0 ] );
+var strategyY = strategy( views[ 1 ] );
+
+// Resolve a kernel:
+var kernel = resolveKernel( 5 );
+
+// Apply strided function:
+kernel( gtriu, [ x, y, k ], views, [ 1, 1, 1, 1, 3 ], [ 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 4 ], strategyX, strategyY, {} );
+
+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 ) );
+```
+
+</section>
+
+<!-- /.examples -->
+
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
+
+</section>
+
+<!-- /.related -->
+
+<section class="links">
+
+[@stdlib/ndarray/base/descriptor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/base/descriptor
+
+</section>
+
+<!-- /.links -->

lib/node_modules/@stdlib/ndarray/base/kernels/generic/unary-strided2d/strategy/docs/repl.txt

@@ -0,0 +1,43 @@
+
+{{alias}}( x )
+    Returns an object containing methods for reshaping an ndarray as a two-
+    dimensional strided array view.
+
+    Parameters
+    ----------
+    x: Object
+        Descriptor.
+
+    Returns
+    -------
+    out: Object
+        Object containing an input and output strategy.
+
+    out.input: Function
+        Function providing a strategy for reshaping an input ndarray to a two-
+        dimensional input ndarray view prior to applying a two-dimensional
+        strided array function.
+
+    out.output: Function
+        Function providing a strategy for reshaping the results of a two-
+        dimensional strided array function to the shape of an input ndarray
+        after applying a two-dimensional strided array function. This function
+        should only be invoked for input ndarrays which are written to by the
+        two-dimensional strided array function.
+
+    Examples
+    --------
+    > var x = {
+    ...   'dtype': 'float64',
+    ...   'data': new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 3.0, 4.0 ] ),
+    ...   'shape': [ 2, 2 ],
+    ...   'strides': [ 2, 1 ],
+    ...   'offset': 0,
+    ...   'order': 'row-major'
+    ... };
+    > var o = {{alias}}( x )
+    {...}
+
+    See Also
+    --------
+

lib/node_modules/@stdlib/ndarray/base/kernels/generic/unary-strided2d/strategy/examples/index.js

@@ -0,0 +1,114 @@
+/**
+* @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 gtriu = require( '@stdlib/blas/ext/base/ndarray/gtriu' );
+var resolveKernel = require( '@stdlib/ndarray/base/kernels/generic/unary-strided2d/unblocked' );
+var strategy = 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( [ 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 ];
+
+// Define the array strides:
+var sx = [ 12, 12, 12, 12, 4, 2, 1 ];
+var sy = [ 12, 12, 12, 12, 4, 2, 1 ];
+
+// Define the index offsets:
+var ox = 0;
+var oy = 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 diagonal below which to ignore:
+var k = {
+	'dtype': 'float64',
+	'data': new Float64Array( [ 0.0 ] ),
+	'shape': [ 1, 1, 1, 1, 3 ],
+	'strides': [ 0, 0, 0, 0, 0 ],
+	'offset': 0,
+	'order': 'row-major'
+};
+
+// Create an output ndarray descriptor:
+var y = {
+	'dtype': 'float64',
+	'data': ybuf,
+	'shape': ysh,
+	'strides': sy,
+	'offset': oy,
+	'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': k.dtype,
+		'data': k.data,
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': k.offset,
+		'order': k.order
+	}
+];
+
+// Resolve input/output strategies when iterating over subarray views:
+var strategyX = strategy( views[ 0 ] );
+var strategyY = strategy( views[ 1 ] );
+
+// Resolve a kernel:
+var kernel = resolveKernel( 5 );
+
+// Apply strided function:
+kernel( gtriu, [ x, y, k ], views, [ 1, 1, 1, 1, 3 ], [ 12, 12, 12, 12, 4 ], [ 12, 12, 12, 12, 4 ], strategyX, strategyY, {} );
+
+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 ) );