docs: add REPL help

Author: kgryte

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

@@ -0,0 +1,122 @@
+
+{{alias}}( fcn, arrays, dims[, options] )
+    Performs a reduction over a list of specified dimensions in an input ndarray
+    via a one-dimensional strided array reduction function and assigns results
+    to a provided output ndarray.
+
+    Each provided "ndarray" should be an object with the following properties:
+
+    - dtype: data type.
+    - data: data buffer.
+    - shape: dimensions.
+    - strides: stride lengths.
+    - offset: index offset.
+    - order: specifies whether an ndarray is row-major (C-style) or column-major
+    (Fortran-style).
+
+    The output ndarray and any additional ndarray arguments are expected to have
+    the same dimensions as the non-reduced dimensions of the input ndarray. When
+    calling the reduction function, any additional ndarray arguments are
+    provided as zero-dimensional ndarray-like objects.
+
+    Parameters
+    ----------
+    fcn: Function
+        Function which will be applied to a one-dimensional subarray and should
+        store reduction results in an output struct object. The function should
+        have the following signature:
+
+            fcn( arrays[, options] )
+
+        where
+
+        - arrays: array containing a one-dimensional subarray of the input
+        ndarray, a zero-dimensional subarray of the output ndarray containing
+        the output struct object, and any additional ndarray arguments as zero-
+        dimensional ndarrays.
+        - options: function options.
+
+    arrays: ArrayLikeObject<ndarray>
+        Array-like object containing one input ndarray and one output ndarray,
+        followed by any additional ndarray arguments.
+
+    dims: Array<integer>
+        List of dimensions over which to perform a reduction.
+
+    options: Object (optional)
+        Function options.
+
+    Examples
+    --------
+    // Define ndarray data and meta data...
+    > var xbuf = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 3.0, 4.0 ] );
+    > var dtype = 'float64';
+    > var shx = [ 2, 2 ];
+    > var sx = [ 2, 1 ];
+    > var ox = 0;
+    > var order = 'row-major';
+
+    > var F64 = {{alias:@stdlib/stats/base/ztest/one-sample/results/float64}};
+    > var ResultsArray = {{alias:@stdlib/dstructs/struct}}( F64 );
+    > var ybuf = new ResultsArray( 1 );
+    > var shy = [];
+    > var sy = [ 0 ];
+    > var oy = 0;
+
+    // Using minimal ndarray-like objects...
+    > var x = {
+    ...     'dtype': dtype,
+    ...     'data': xbuf,
+    ...     'shape': shx,
+    ...     'strides': sx,
+    ...     'offset': ox,
+    ...     'order': order
+    ... };
+    > var y = {
+    ...     'dtype': F64,
+    ...     'data': ybuf,
+    ...     'shape': shy,
+    ...     'strides': sy,
+    ...     'offset': oy,
+    ...     'order': order
+    ... };
+    > var alt = {
+    ...     'dtype': 'generic',
+    ...     'data': [ 'two-sided' ],
+    ...     'shape': shy,
+    ...     'strides': [ 0 ],
+    ...     'offset': 0,
+    ...     'order': order
+    ... };
+    > var alpha = {
+    ...     'dtype': 'generic',
+    ...     'data': [ 0.05 ],
+    ...     'shape': shy,
+    ...     'strides': [ 0 ],
+    ...     'offset': 0,
+    ...     'order': order
+    ... };
+    > var mu = {
+    ...     'dtype': 'generic',
+    ...     'data': [ 0.0 ],
+    ...     'shape': shy,
+    ...     'strides': [ 0 ],
+    ...     'offset': 0,
+    ...     'order': order
+    ... };
+    > var sigma = {
+    ...     'dtype': 'generic',
+    ...     'data': [ 1.0 ],
+    ...     'shape': shy,
+    ...     'strides': [ 0 ],
+    ...     'offset': 0,
+    ...     'order': order
+    ... };
+    > var f = {{alias:@stdlib/stats/base/ndarray/ztest}};
+    > {{alias}}( f, [ x, y, alt, alpha, mu, sigma ], [ 0, 1 ] );
+    > y.data.get( 0 ).toString()
+    <string>
+
+    See Also
+    --------
+