diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/nullary-strided1d-by/unblocked/README.md b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/nullary-strided1d-by/unblocked/README.md
new file mode 100644
index 000000000000..c7fdd0ecdb89
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/nullary-strided1d-by/unblocked/README.md
@@ -0,0 +1,1682 @@
+
+
+# kernel
+
+> Return a kernel for applying a one-dimensional strided array function to an input ndarray according to a callback function.
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var kernel = require( '@stdlib/ndarray/base/kernels/generic/nullary-strided1d-by/unblocked' );
+```
+
+#### kernel( ndims )
+
+Returns a kernel for applying a one-dimensional strided array function to an input ndarray according to a callback function.
+
+
+
+```javascript
+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[ 1 ]*100 ) + ( idx[ 2 ]*10 ) + idx[ 3 ];
+}
+
+// Create a data buffer:
+var xbuf = new Float64Array( 12 );
+
+// Define the array shape:
+var xsh = [ 1, 3, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 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, 3 ],
+ 'strides': [ 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, 3 ],
+ 'strides': [ 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 ];
+var cdims = [ 2, 3 ];
+
+// Resolve a kernel:
+var f = kernel( 2 );
+
+// Apply strided function:
+f( gfillBy, [ x, start, end ], x, views, [ 1, 3 ], [ 12, 4 ], 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 ] ], [ [ 100.0, 101.0 ], [ 110.0, 111.0 ] ], [ [ 200.0, 201.0 ], [ 210.0, 211.0 ] ] ] ]
+```
+
+The function accepts the following arguments:
+
+- **ndims**: number of loop dimensions.
+
+If the function is provided an `ndims` value greater than the maximum number of supported loop dimensions, the function returns `null`.
+
+```javascript
+var f = kernel( 100000 );
+// returns null
+```
+
+The returned function accepts the following arguments:
+
+- **fcn**: function which will be applied to a one-dimensional input subarray according to a callback function.
+- **arrays**: array containing an input ndarray [descriptor][@stdlib/ndarray/base/descriptor], followed by any additional ndarray arguments.
+- **ref**: original input ndarray provided to a callback function.
+- **views**: initialized ndarray [descriptors][@stdlib/ndarray/base/descriptor] representing subarray views.
+- **shape**: loop dimensions.
+- **stridesX**: loop dimension strides for the input ndarray.
+- **strategyX**: strategy for marshaling data to and from an input ndarray view.
+- **ibuf**: workspace for storing iteration indices.
+- **ldims**: list of loop dimensions.
+- **cdims**: list of "core" dimensions.
+- **options**: function options which are passed through to `fcn`.
+- **hasOpts**: boolean indicating whether to pass an options argument to a strided array function.
+- **clbk**: callback function.
+- **thisArg**: callback execution context.
+
+The returned function iterates over ndarray elements according to the memory layout of the input ndarray.
+
+
+
+#### kernel.kernel0d( fcn, arrays, ref, views, shape, stridesX, strategyX, ibuf, ldims, cdims, options, hasOpts, clbk, thisArg )
+
+
+
+Applies a one-dimensional strided array function to an input ndarray according to a callback function.
+
+
+
+```javascript
+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.kernel0d( 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 ] ]
+```
+
+The function has the following parameters:
+
+- **fcn**: function which will be applied to a one-dimensional input subarray according to a callback function.
+- **arrays**: array containing an input ndarray [descriptor][@stdlib/ndarray/base/descriptor], followed by any additional ndarray arguments.
+- **ref**: original input ndarray provided to a callback function.
+- **views**: initialized ndarray [descriptors][@stdlib/ndarray/base/descriptor] representing subarray views.
+- **shape**: loop dimensions. Should have zero elements.
+- **stridesX**: loop dimension strides for the input ndarray.
+- **strategyX**: strategy for marshaling data to and from an input ndarray view.
+- **ibuf**: workspace for storing iteration indices.
+- **ldims**: list of loop dimensions.
+- **cdims**: list of "core" dimensions.
+- **options**: function options which are passed through to `fcn`.
+- **hasOpts**: boolean indicating whether to pass an options argument to a strided array function.
+- **clbk**: callback function.
+- **thisArg**: callback execution context.
+
+The `views`, `shape`, and `stridesX` parameters are unused. Providing empty arrays for these parameters is recommended in order to ensure a monomorphic API.
+
+
+
+#### kernel.kernel1d( fcn, arrays, ref, views, shape, stridesX, strategyX, ibuf, ldims, cdims, options, hasOpts, clbk, thisArg )
+
+
+
+Applies a one-dimensional strided array function to an input ndarray according to a callback function.
+
+
+
+```javascript
+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 ]*100 ) + ( idx[ 1 ]*10 ) + idx[ 2 ];
+}
+
+// Create a data buffer:
+var xbuf = new Float64Array( 12 );
+
+// Define the array shape:
+var xsh = [ 3, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 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': [ 3 ],
+ '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': [ 3 ],
+ 'strides': [ 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 ];
+var cdims = [ 1, 2 ];
+
+// Apply strided function:
+kernel.kernel1d( gfillBy, [ x, start, end ], x, views, [ 3 ], [ 4 ], 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 ] ], [ [ 100.0, 101.0 ], [ 110.0, 111.0 ] ], [ [ 200.0, 201.0 ], [ 210.0, 211.0 ] ] ]
+```
+
+The function has the following parameters:
+
+- **fcn**: function which will be applied to a one-dimensional input subarray according to a callback function.
+- **arrays**: array containing an input ndarray [descriptor][@stdlib/ndarray/base/descriptor], followed by any additional ndarray arguments.
+- **ref**: original input ndarray provided to a callback function.
+- **views**: initialized ndarray [descriptors][@stdlib/ndarray/base/descriptor] representing subarray views.
+- **shape**: loop dimensions. Should have one element.
+- **stridesX**: loop dimension strides for the input ndarray.
+- **strategyX**: strategy for marshaling data to and from an input ndarray view.
+- **ibuf**: workspace for storing iteration indices.
+- **ldims**: list of loop dimensions.
+- **cdims**: list of "core" dimensions.
+- **options**: function options which are passed through to `fcn`.
+- **hasOpts**: boolean indicating whether to pass an options argument to a strided array function.
+- **clbk**: callback function.
+- **thisArg**: callback execution context.
+
+
+
+#### kernel.kernel2d( fcn, arrays, ref, views, shape, stridesX, strategyX, ibuf, ldims, cdims, options, hasOpts, clbk, thisArg )
+
+
+
+Applies a one-dimensional strided array function to an input ndarray according to a callback function.
+
+
+
+```javascript
+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[ 1 ]*100 ) + ( idx[ 2 ]*10 ) + idx[ 3 ];
+}
+
+// Create a data buffer:
+var xbuf = new Float64Array( 12 );
+
+// Define the array shape:
+var xsh = [ 1, 3, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 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, 3 ],
+ 'strides': [ 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, 3 ],
+ 'strides': [ 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 ];
+var cdims = [ 2, 3 ];
+
+// Apply strided function:
+kernel.kernel2d( gfillBy, [ x, start, end ], x, views, [ 1, 3 ], [ 12, 4 ], 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 ] ], [ [ 100.0, 101.0 ], [ 110.0, 111.0 ] ], [ [ 200.0, 201.0 ], [ 210.0, 211.0 ] ] ] ]
+```
+
+The function has the following parameters:
+
+- **fcn**: function which will be applied to a one-dimensional input subarray according to a callback function.
+- **arrays**: array containing an input ndarray [descriptor][@stdlib/ndarray/base/descriptor], followed by any additional ndarray arguments.
+- **ref**: original input ndarray provided to a callback function.
+- **views**: initialized ndarray [descriptors][@stdlib/ndarray/base/descriptor] representing subarray views.
+- **shape**: loop dimensions. Should have two elements.
+- **stridesX**: loop dimension strides for the input ndarray.
+- **strategyX**: strategy for marshaling data to and from an input ndarray view.
+- **ibuf**: workspace for storing iteration indices.
+- **ldims**: list of loop dimensions.
+- **cdims**: list of "core" dimensions.
+- **options**: function options which are passed through to `fcn`.
+- **hasOpts**: boolean indicating whether to pass an options argument to a strided array function.
+- **clbk**: callback function.
+- **thisArg**: callback execution context.
+
+
+
+#### kernel.kernel3d( fcn, arrays, ref, views, shape, stridesX, strategyX, ibuf, ldims, cdims, options, hasOpts, clbk, thisArg )
+
+
+
+Applies a one-dimensional strided array function to an input ndarray according to a callback function.
+
+
+
+```javascript
+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[ 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 ];
+
+// Apply strided function:
+kernel.kernel3d( gfillBy, [ x, start, end ], x, views, [ 1, 1, 3 ], [ 12, 12, 4 ], 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 ] ], [ [ 100.0, 101.0 ], [ 110.0, 111.0 ] ], [ [ 200.0, 201.0 ], [ 210.0, 211.0 ] ] ] ] ]
+```
+
+The function has the following parameters:
+
+- **fcn**: function which will be applied to a one-dimensional input subarray according to a callback function.
+- **arrays**: array containing an input ndarray [descriptor][@stdlib/ndarray/base/descriptor], followed by any additional ndarray arguments.
+- **ref**: original input ndarray provided to a callback function.
+- **views**: initialized ndarray [descriptors][@stdlib/ndarray/base/descriptor] representing subarray views.
+- **shape**: loop dimensions. Should have three elements.
+- **stridesX**: loop dimension strides for the input ndarray.
+- **strategyX**: strategy for marshaling data to and from an input ndarray view.
+- **ibuf**: workspace for storing iteration indices.
+- **ldims**: list of loop dimensions.
+- **cdims**: list of "core" dimensions.
+- **options**: function options which are passed through to `fcn`.
+- **hasOpts**: boolean indicating whether to pass an options argument to a strided array function.
+- **clbk**: callback function.
+- **thisArg**: callback execution context.
+
+
+
+#### kernel.kernel4d( fcn, arrays, ref, views, shape, stridesX, strategyX, ibuf, ldims, cdims, options, hasOpts, clbk, thisArg )
+
+
+
+Applies a one-dimensional strided array function to an input ndarray according to a callback function.
+
+
+
+```javascript
+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[ 3 ]*100 ) + ( idx[ 4 ]*10 ) + idx[ 5 ];
+}
+
+// Create a data buffer:
+var xbuf = new Float64Array( 12 );
+
+// Define the array shape:
+var xsh = [ 1, 1, 1, 3, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 12, 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, 1, 3 ],
+ 'strides': [ 0, 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, 1, 3 ],
+ 'strides': [ 0, 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, 3 ];
+var cdims = [ 4, 5 ];
+
+// Apply strided function:
+kernel.kernel4d( gfillBy, [ x, start, end ], x, views, [ 1, 1, 1, 3 ], [ 12, 12, 12, 4 ], 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 ] ], [ [ 100.0, 101.0 ], [ 110.0, 111.0 ] ], [ [ 200.0, 201.0 ], [ 210.0, 211.0 ] ] ] ] ] ]
+```
+
+The function has the following parameters:
+
+- **fcn**: function which will be applied to a one-dimensional input subarray according to a callback function.
+- **arrays**: array containing an input ndarray [descriptor][@stdlib/ndarray/base/descriptor], followed by any additional ndarray arguments.
+- **ref**: original input ndarray provided to a callback function.
+- **views**: initialized ndarray [descriptors][@stdlib/ndarray/base/descriptor] representing subarray views.
+- **shape**: loop dimensions. Should have four elements.
+- **stridesX**: loop dimension strides for the input ndarray.
+- **strategyX**: strategy for marshaling data to and from an input ndarray view.
+- **ibuf**: workspace for storing iteration indices.
+- **ldims**: list of loop dimensions.
+- **cdims**: list of "core" dimensions.
+- **options**: function options which are passed through to `fcn`.
+- **hasOpts**: boolean indicating whether to pass an options argument to a strided array function.
+- **clbk**: callback function.
+- **thisArg**: callback execution context.
+
+
+
+#### kernel.kernel5d( fcn, arrays, ref, views, shape, stridesX, strategyX, ibuf, ldims, cdims, options, hasOpts, clbk, thisArg )
+
+
+
+Applies a one-dimensional strided array function to an input ndarray according to a callback function.
+
+
+
+```javascript
+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[ 4 ]*100 ) + ( idx[ 5 ]*10 ) + idx[ 6 ];
+}
+
+// Create a data buffer:
+var xbuf = new Float64Array( 12 );
+
+// Define the array shape:
+var xsh = [ 1, 1, 1, 1, 3, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 12, 12, 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, 1, 1, 3 ],
+ 'strides': [ 0, 0, 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, 1, 1, 3 ],
+ 'strides': [ 0, 0, 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, 3, 4 ];
+var cdims = [ 5, 6 ];
+
+// Apply strided function:
+kernel.kernel5d( gfillBy, [ x, start, end ], x, views, [ 1, 1, 1, 1, 3 ], [ 12, 12, 12, 12, 4 ], 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 ] ], [ [ 100.0, 101.0 ], [ 110.0, 111.0 ] ], [ [ 200.0, 201.0 ], [ 210.0, 211.0 ] ] ] ] ] ] ]
+```
+
+The function has the following parameters:
+
+- **fcn**: function which will be applied to a one-dimensional input subarray according to a callback function.
+- **arrays**: array containing an input ndarray [descriptor][@stdlib/ndarray/base/descriptor], followed by any additional ndarray arguments.
+- **ref**: original input ndarray provided to a callback function.
+- **views**: initialized ndarray [descriptors][@stdlib/ndarray/base/descriptor] representing subarray views.
+- **shape**: loop dimensions. Should have five elements.
+- **stridesX**: loop dimension strides for the input ndarray.
+- **strategyX**: strategy for marshaling data to and from an input ndarray view.
+- **ibuf**: workspace for storing iteration indices.
+- **ldims**: list of loop dimensions.
+- **cdims**: list of "core" dimensions.
+- **options**: function options which are passed through to `fcn`.
+- **hasOpts**: boolean indicating whether to pass an options argument to a strided array function.
+- **clbk**: callback function.
+- **thisArg**: callback execution context.
+
+
+
+#### kernel.kernel6d( fcn, arrays, ref, views, shape, stridesX, strategyX, ibuf, ldims, cdims, options, hasOpts, clbk, thisArg )
+
+
+
+Applies a one-dimensional strided array function to an input ndarray according to a callback function.
+
+
+
+```javascript
+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[ 5 ]*100 ) + ( idx[ 6 ]*10 ) + idx[ 7 ];
+}
+
+// Create a data buffer:
+var xbuf = new Float64Array( 12 );
+
+// Define the array shape:
+var xsh = [ 1, 1, 1, 1, 1, 3, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 12, 12, 12, 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, 1, 1, 1, 3 ],
+ 'strides': [ 0, 0, 0, 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, 1, 1, 1, 3 ],
+ 'strides': [ 0, 0, 0, 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, 3, 4, 5 ];
+var cdims = [ 6, 7 ];
+
+// Apply strided function:
+kernel.kernel6d( gfillBy, [ x, start, end ], x, views, [ 1, 1, 1, 1, 1, 3 ], [ 12, 12, 12, 12, 12, 4 ], 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 ] ], [ [ 100.0, 101.0 ], [ 110.0, 111.0 ] ], [ [ 200.0, 201.0 ], [ 210.0, 211.0 ] ] ] ] ] ] ] ]
+```
+
+The function has the following parameters:
+
+- **fcn**: function which will be applied to a one-dimensional input subarray according to a callback function.
+- **arrays**: array containing an input ndarray [descriptor][@stdlib/ndarray/base/descriptor], followed by any additional ndarray arguments.
+- **ref**: original input ndarray provided to a callback function.
+- **views**: initialized ndarray [descriptors][@stdlib/ndarray/base/descriptor] representing subarray views.
+- **shape**: loop dimensions. Should have six elements.
+- **stridesX**: loop dimension strides for the input ndarray.
+- **strategyX**: strategy for marshaling data to and from an input ndarray view.
+- **ibuf**: workspace for storing iteration indices.
+- **ldims**: list of loop dimensions.
+- **cdims**: list of "core" dimensions.
+- **options**: function options which are passed through to `fcn`.
+- **hasOpts**: boolean indicating whether to pass an options argument to a strided array function.
+- **clbk**: callback function.
+- **thisArg**: callback execution context.
+
+
+
+#### kernel.kernel7d( fcn, arrays, ref, views, shape, stridesX, strategyX, ibuf, ldims, cdims, options, hasOpts, clbk, thisArg )
+
+
+
+Applies a one-dimensional strided array function to an input ndarray according to a callback function.
+
+
+
+```javascript
+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[ 6 ]*100 ) + ( idx[ 7 ]*10 ) + idx[ 8 ];
+}
+
+// Create a data buffer:
+var xbuf = new Float64Array( 12 );
+
+// Define the array shape:
+var xsh = [ 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 12, 12, 12, 12, 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, 1, 1, 1, 1, 3 ],
+ 'strides': [ 0, 0, 0, 0, 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, 1, 1, 1, 1, 3 ],
+ 'strides': [ 0, 0, 0, 0, 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, 3, 4, 5, 6 ];
+var cdims = [ 7, 8 ];
+
+// Apply strided function:
+kernel.kernel7d( gfillBy, [ x, start, end ], x, views, [ 1, 1, 1, 1, 1, 1, 3 ], [ 12, 12, 12, 12, 12, 12, 4 ], 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 ] ], [ [ 100.0, 101.0 ], [ 110.0, 111.0 ] ], [ [ 200.0, 201.0 ], [ 210.0, 211.0 ] ] ] ] ] ] ] ] ]
+```
+
+The function has the following parameters:
+
+- **fcn**: function which will be applied to a one-dimensional input subarray according to a callback function.
+- **arrays**: array containing an input ndarray [descriptor][@stdlib/ndarray/base/descriptor], followed by any additional ndarray arguments.
+- **ref**: original input ndarray provided to a callback function.
+- **views**: initialized ndarray [descriptors][@stdlib/ndarray/base/descriptor] representing subarray views.
+- **shape**: loop dimensions. Should have seven elements.
+- **stridesX**: loop dimension strides for the input ndarray.
+- **strategyX**: strategy for marshaling data to and from an input ndarray view.
+- **ibuf**: workspace for storing iteration indices.
+- **ldims**: list of loop dimensions.
+- **cdims**: list of "core" dimensions.
+- **options**: function options which are passed through to `fcn`.
+- **hasOpts**: boolean indicating whether to pass an options argument to a strided array function.
+- **clbk**: callback function.
+- **thisArg**: callback execution context.
+
+
+
+#### kernel.kernel8d( fcn, arrays, ref, views, shape, stridesX, strategyX, ibuf, ldims, cdims, options, hasOpts, clbk, thisArg )
+
+
+
+Applies a one-dimensional strided array function to an input ndarray according to a callback function.
+
+
+
+```javascript
+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[ 7 ]*100 ) + ( idx[ 8 ]*10 ) + idx[ 9 ];
+}
+
+// Create a data buffer:
+var xbuf = new Float64Array( 12 );
+
+// Define the array shape:
+var xsh = [ 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 12, 12, 12, 12, 12, 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, 1, 1, 1, 1, 1, 3 ],
+ 'strides': [ 0, 0, 0, 0, 0, 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, 1, 1, 1, 1, 1, 3 ],
+ 'strides': [ 0, 0, 0, 0, 0, 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, 3, 4, 5, 6, 7 ];
+var cdims = [ 8, 9 ];
+
+// Apply strided function:
+kernel.kernel8d( gfillBy, [ x, start, end ], x, views, [ 1, 1, 1, 1, 1, 1, 1, 3 ], [ 12, 12, 12, 12, 12, 12, 12, 4 ], 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 ] ], [ [ 100.0, 101.0 ], [ 110.0, 111.0 ] ], [ [ 200.0, 201.0 ], [ 210.0, 211.0 ] ] ] ] ] ] ] ] ] ]
+```
+
+The function has the following parameters:
+
+- **fcn**: function which will be applied to a one-dimensional input subarray according to a callback function.
+- **arrays**: array containing an input ndarray [descriptor][@stdlib/ndarray/base/descriptor], followed by any additional ndarray arguments.
+- **ref**: original input ndarray provided to a callback function.
+- **views**: initialized ndarray [descriptors][@stdlib/ndarray/base/descriptor] representing subarray views.
+- **shape**: loop dimensions. Should have eight elements.
+- **stridesX**: loop dimension strides for the input ndarray.
+- **strategyX**: strategy for marshaling data to and from an input ndarray view.
+- **ibuf**: workspace for storing iteration indices.
+- **ldims**: list of loop dimensions.
+- **cdims**: list of "core" dimensions.
+- **options**: function options which are passed through to `fcn`.
+- **hasOpts**: boolean indicating whether to pass an options argument to a strided array function.
+- **clbk**: callback function.
+- **thisArg**: callback execution context.
+
+
+
+#### kernel.kernel9d( fcn, arrays, ref, views, shape, stridesX, strategyX, ibuf, ldims, cdims, options, hasOpts, clbk, thisArg )
+
+
+
+Applies a one-dimensional strided array function to an input ndarray according to a callback function.
+
+
+
+```javascript
+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[ 8 ]*100 ) + ( idx[ 9 ]*10 ) + idx[ 10 ];
+}
+
+// Create a data buffer:
+var xbuf = new Float64Array( 12 );
+
+// Define the array shape:
+var xsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 12, 12, 12, 12, 12, 12, 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, 1, 1, 1, 1, 1, 1, 3 ],
+ 'strides': [ 0, 0, 0, 0, 0, 0, 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, 1, 1, 1, 1, 1, 1, 3 ],
+ 'strides': [ 0, 0, 0, 0, 0, 0, 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, 3, 4, 5, 6, 7, 8 ];
+var cdims = [ 9, 10 ];
+
+// Apply strided function:
+kernel.kernel9d( gfillBy, [ x, start, end ], x, views, [ 1, 1, 1, 1, 1, 1, 1, 1, 3 ], [ 12, 12, 12, 12, 12, 12, 12, 12, 4 ], 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 ] ], [ [ 100.0, 101.0 ], [ 110.0, 111.0 ] ], [ [ 200.0, 201.0 ], [ 210.0, 211.0 ] ] ] ] ] ] ] ] ] ] ]
+```
+
+The function has the following parameters:
+
+- **fcn**: function which will be applied to a one-dimensional input subarray according to a callback function.
+- **arrays**: array containing an input ndarray [descriptor][@stdlib/ndarray/base/descriptor], followed by any additional ndarray arguments.
+- **ref**: original input ndarray provided to a callback function.
+- **views**: initialized ndarray [descriptors][@stdlib/ndarray/base/descriptor] representing subarray views.
+- **shape**: loop dimensions. Should have nine elements.
+- **stridesX**: loop dimension strides for the input ndarray.
+- **strategyX**: strategy for marshaling data to and from an input ndarray view.
+- **ibuf**: workspace for storing iteration indices.
+- **ldims**: list of loop dimensions.
+- **cdims**: list of "core" dimensions.
+- **options**: function options which are passed through to `fcn`.
+- **hasOpts**: boolean indicating whether to pass an options argument to a strided array function.
+- **clbk**: callback function.
+- **thisArg**: callback execution context.
+
+
+
+#### kernel.kernel10d( fcn, arrays, ref, views, shape, stridesX, strategyX, ibuf, ldims, cdims, options, hasOpts, clbk, thisArg )
+
+
+
+Applies a one-dimensional strided array function to an input ndarray according to a callback function.
+
+
+
+```javascript
+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[ 9 ]*100 ) + ( idx[ 10 ]*10 ) + idx[ 11 ];
+}
+
+// Create a data buffer:
+var xbuf = new Float64Array( 12 );
+
+// Define the array shape:
+var xsh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 12, 12, 12, 12, 12, 12, 12, 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, 1, 1, 1, 1, 1, 1, 1, 3 ],
+ 'strides': [ 0, 0, 0, 0, 0, 0, 0, 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, 1, 1, 1, 1, 1, 1, 1, 3 ],
+ 'strides': [ 0, 0, 0, 0, 0, 0, 0, 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, 3, 4, 5, 6, 7, 8, 9 ];
+var cdims = [ 10, 11 ];
+
+// Apply strided function:
+kernel.kernel10d( gfillBy, [ x, start, end ], x, views, [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 3 ], [ 12, 12, 12, 12, 12, 12, 12, 12, 12, 4 ], 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 ] ], [ [ 100.0, 101.0 ], [ 110.0, 111.0 ] ], [ [ 200.0, 201.0 ], [ 210.0, 211.0 ] ] ] ] ] ] ] ] ] ] ] ]
+```
+
+The function has the following parameters:
+
+- **fcn**: function which will be applied to a one-dimensional input subarray according to a callback function.
+- **arrays**: array containing an input ndarray [descriptor][@stdlib/ndarray/base/descriptor], followed by any additional ndarray arguments.
+- **ref**: original input ndarray provided to a callback function.
+- **views**: initialized ndarray [descriptors][@stdlib/ndarray/base/descriptor] representing subarray views.
+- **shape**: loop dimensions. Should have ten elements.
+- **stridesX**: loop dimension strides for the input ndarray.
+- **strategyX**: strategy for marshaling data to and from an input ndarray view.
+- **ibuf**: workspace for storing iteration indices.
+- **ldims**: list of loop dimensions.
+- **cdims**: list of "core" dimensions.
+- **options**: function options which are passed through to `fcn`.
+- **hasOpts**: boolean indicating whether to pass an options argument to a strided array function.
+- **clbk**: callback function.
+- **thisArg**: callback execution context.
+
+
+
+
+
+
+
+## Notes
+
+- The strided array function is expected to have the following signature:
+
+ ```text
+ fcn( arrays[, options], clbk )
+ ```
+
+ where
+
+ - **arrays**: array containing a one-dimensional subarray of the input ndarray and any additional ndarray arguments as subarrays.
+ - **options**: function options (_optional_).
+ - **clbk**: callback function.
+
+- The callback function is provided the following arguments:
+
+ - **value**: current array element.
+ - **idx**: current array element indices.
+ - **arr**: the original input ndarray.
+
+
+
+
+
+
+
+## Examples
+
+
+
+
+
+```javascript
+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( '@stdlib/ndarray/base/kernels/generic/nullary-strided1d-by/unblocked' );
+
+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 ) );
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+[@stdlib/ndarray/base/descriptor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/base/descriptor
+
+
+
+
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/nullary-strided1d-by/unblocked/docs/repl.txt b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/nullary-strided1d-by/unblocked/docs/repl.txt
new file mode 100644
index 000000000000..c3a5a5658d58
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/nullary-strided1d-by/unblocked/docs/repl.txt
@@ -0,0 +1,609 @@
+
+{{alias}}( ndims )
+ Returns a kernel for applying a one-dimensional strided array function to an
+ input ndarray according to a callback function.
+
+ The returned function has the following parameters:
+
+ - fcn: function which will be applied to a one-dimensional input subarray
+ according to a callback function.
+ - arrays: array containing an input ndarray descriptor, followed by any
+ additional ndarray arguments.
+ - ref: original input ndarray provided to a callback function.
+ - views: initialized ndarray descriptors representing subarray views.
+ - shape: loop dimensions.
+ - stridesX: loop dimension strides for the input ndarray.
+ - strategyX: strategy for marshaling data to and from an input ndarray view.
+ - ibuf: workspace for storing iteration indices.
+ - ldims: list of loop dimensions.
+ - cdims: list of "core" dimensions.
+ - options: function options which are passed through to `fcn`.
+ - hasOpts: boolean indicating whether to pass an options argument to a
+ strided array function.
+ - clbk: callback function.
+ - thisArg: callback execution context.
+
+ If `ndims` is greater than the maximum supported number of loop dimensions,
+ the function returns `null`.
+
+ Parameters
+ ----------
+ ndims: integer
+ Number of loop dimensions.
+
+ Returns
+ -------
+ fcn: Function|null
+ Kernel function.
+
+ Examples
+ --------
+ > var f = {{alias}}( 2 )
+
+
+
+{{alias}}.kernel0d( fcn, arr, ref, v, sh, sx, st, ib, ld, cd, o, po, cb, ctx )
+ Applies a one-dimensional strided array function to an input ndarray
+ according to a callback function.
+
+ The `v`, `sh`, and `sx` parameters are unused. Providing empty arrays for
+ these parameters is recommended in order to ensure a monomorphic API.
+
+ Parameters
+ ----------
+ fcn: Function
+ Wrapper for a one-dimensional strided array function.
+
+ arr: Array