
{{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 which accepts an
    output struct object 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 is expected to have the same dimensions as the non-
    reduced dimensions of the input ndarray.

    Any additional ndarray arguments are expected to have the same leading
    dimensions as the non-reduced dimensions of the input ndarray.

    When calling the reduction 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 non-
    reduced dimensions in the input ndarray. For example, if an input ndarray
    has three dimensions, the number of reduced dimensions is two, and an
    additional ndarray argument has one dimension, thus matching the number of
    non-reduced dimensions in the input ndarray, the reduction 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 non-reduced dimensions in the input
    ndarray, the reduction function is provided a one-dimensional subarray as an
    additional ndarray argument.

    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
        subarrays.
        - 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
    --------

