refactor: add support for ancillary ndarray arguments having trailing dimensions

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: skipped
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: kgryte

lib/node_modules/@stdlib/ndarray/base/unary-strided1d/README.md

@@ -138,7 +138,9 @@ Each provided ndarray should be an object with the following properties:
 
 ## Notes
 
--   Any additional ndarray arguments are expected to have the same dimensions as the loop dimensions of the input ndarray. When calling the strided array function, any additional ndarray arguments are provided as zero-dimensional ndarray-like objects.
+-   Any additional ndarray arguments are expected to have the same leading dimensions as the loop dimensions of the input ndarray.
+
+-   When calling the strided array function, any additional ndarray arguments are provided as k-dimensional subarrays, where `k = M - N` with `M` being the number of dimensions in an ndarray argument and `N` being the number of loop dimensions for the input ndarray. For example, if an input ndarray has three dimensions, the number of loop dimensions is one, and an additional ndarray argument has one dimension, thus matching the number of loop dimensions for the input ndarray, the strided array function is provided a zero-dimensional subarray as an additional ndarray argument. In the same scenario but where an additional ndarray argument has two dimensions, thus exceeding the number of loop dimensions, the strided array function is provided a one-dimensional subarray as an additional ndarray argument.
 
 -   The strided array function is expected to have the following signature:
 
@@ -148,7 +150,7 @@ Each provided ndarray should be an object with the following properties:
 
     where
 
-    -   **arrays**: array containing a one-dimensional subarray of the input ndarray, a one-dimensional subarray of the output ndarray, and any additional ndarray arguments as zero-dimensional ndarrays.
+    -   **arrays**: array containing a one-dimensional subarray of the input ndarray, a one-dimensional subarray of the output ndarray, and any additional ndarray arguments as subarrays.
     -   **options**: function options (_optional_).
 
 -   The function iterates over ndarray elements according to the memory layout of the input ndarray.

lib/node_modules/@stdlib/ndarray/base/unary-strided1d/docs/repl.txt

@@ -14,10 +14,20 @@
     - order: specifies whether an ndarray is row-major (C-style) or column-major
     (Fortran-style).
 
-    Any additional ndarray arguments are expected to have the same dimensions as
-    the loop dimensions of the input ndarray. When calling the strided array
-    function, any additional ndarray arguments are provided as zero-dimensional
-    ndarray-like objects.
+    Any additional ndarray arguments are expected to have the same leading
+    dimensions as the loop dimensions of the input ndarray.
+
+    When calling the strided array function, any additional ndarray arguments
+    are provided as k-dimensional subarrays, where `k = M - N` with `M` being
+    the number of dimensions in an ndarray argument and `N` being the number of
+    loop dimensions for the input ndarray. For example, if an input ndarray has
+    three dimensions, the number of loop dimensions is one, and an additional
+    ndarray argument has one dimension, thus matching the number of loop
+    dimensions for the input ndarray, the strided array function is provided a
+    zero-dimensional subarray as an additional ndarray argument. In the same
+    scenario but where an additional ndarray argument has two dimensions, thus
+    exceeding the number of loop dimensions, the strided array function is
+    provided a one-dimensional subarray as an additional ndarray argument.
 
     Parameters
     ----------
@@ -32,7 +42,7 @@
 
         - arrays: array containing a one-dimensional subarray of the input
         ndarray, a one-dimensional subarray of the output ndarray, and any
-        additional ndarray arguments as zero-dimensional ndarrays.
+        additional ndarray arguments as subarrays.
         - options: function options.
 
     arrays: ArrayLikeObject<ndarray>

lib/node_modules/@stdlib/ndarray/base/unary-strided1d/lib/initialize_array_views.js

@@ -18,10 +18,15 @@
 
 'use strict';
 
+// MODULES //
+
+var slice = require( '@stdlib/array/base/slice' );
+
+
 // MAIN //
 
 /**
-* Initialize ndarray-like objects for representing zero-dimensional sub-array views of ancillary ndarray arguments.
+* Initialize ndarray-like objects for representing sub-array views of ancillary ndarray arguments.
 *
 * ## Notes
 *
@@ -30,20 +35,25 @@
 *
 * @private
 * @param {ArrayLikeObject<Object>} arrays - list of ndarray-like objects
+* @param {NonNegativeInteger} k - number of non-reduced dimensions
 * @param {Array<Object>} out - output array
 * @returns {Array<Object>} output array
 */
-function initializeViews( arrays, out ) {
+function initializeViews( arrays, k, out ) {
+	var sh;
+	var N;
 	var v;
 	var i;
 
 	for ( i = 2; i < arrays.length; i++ ) {
 		v = arrays[ i ];
+		sh = v.shape;
+		N = sh.length;
 		out.push({
 			'dtype': v.dtype,
 			'data': v.data,
-			'shape': [],
-			'strides': [ 0 ],
+			'shape': slice( sh, k, N ),
+			'strides': ( N === k ) ? [ 0 ] : slice( v.strides, k, N ),
 			'offset': v.offset,
 			'order': v.order
 		});

lib/node_modules/@stdlib/ndarray/base/unary-strided1d/lib/main_factory.js

@@ -400,10 +400,12 @@ function factory( options ) {
 		if ( M > ndims ) {
 			throw new RangeError( format( 'invalid argument. Number of specified dimensions cannot exceed the number of dimensions in the input array. Number of dimensions: %d. Value: [%s].', ndims, join( dims, ',' ) ) );
 		}
-		// Verify that provided ancillary ndarrays have the expected number of dimensions...
+		// Compute the number of non-reduced dimensions:
 		K = ndims - M;
+
+		// Verify that any ancillary ndarrays have at least the number of non-reduced dimensions...
 		for ( i = 2; i < N; i++ ) {
-			if ( arr[ i ].shape.length !== K ) {
+			if ( arr[ i ].shape.length < K ) {
 				throw new Error( format( 'invalid argument. Array arguments after the first two arrays must have the same number of loop dimensions. Input array shape: [%s]. Number of loop dimensions: %d. Array shape: [%s] (index: %d).', join( shx, ',' ), K, join( arr[ i ].shape, ',' ), i ) );
 			}
 		}
@@ -472,7 +474,7 @@ function factory( options ) {
 				'order': y.order
 			}
 		];
-		initializeViews( arr, views );
+		initializeViews( arr, K, views );
 
 		// Determine the strategy for marshaling data to and from sub-array views of the input and output arrays before and after performing an operation:
 		strategyX = strategy( views[ 0 ] );

lib/node_modules/@stdlib/ndarray/base/unary-strided1d/lib/strategy.js

@@ -209,7 +209,7 @@ function copyFromWorkspace( workspace ) {
 *
 * @private
 * @param {ndarrayLike} x - input ndarray
-* @param {string} x.dtype - input ndarray data type
+* @param {*} x.dtype - input ndarray data type
 * @param {Collection} x.data - input ndarray data buffer
 * @param {NonNegativeIntegerArray} x.shape - input ndarray shape
 * @param {IntegerArray} x.strides - input ndarray strides