{{alias}}( fcn, arrays, dims[, options] )
    Performs a reduction over a list of specified dimensions in two input
    ndarrays via a one-dimensional strided array binary 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 is expected to have the same dimensions as the non-
    reduced dimensions of the input ndarrays.

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

    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 ndarrays. For example, if an input ndarrays
    have 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 ndarrays, 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
    ndarrays, the reduction function is provided a one-dimensional subarray as
    an additional ndarray argument.

    Parameters
    ----------
    fcn: Function
        Binary reduction function which will be applied to two one-dimensional
        subarrays and should reduce them to a single scalar value. The function
        should have the following signature:

            fcn( arrays[, options] )

        where

        - arrays: array containing a one-dimensional subarrays for each input
        ndarray and any additional ndarray arguments as subarrays.
        - options: function options.

    arrays: ArrayLikeObject<ndarray>
        Array-like object containing two input ndarrays 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 gdot = require( '@stdlib/blas/base/ndarray/gdot' );
    > var xbuf = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 3.0, 4.0 ] );
    > var ybuf = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 3.0, 4.0 ] );
    > var zbuf = new {{alias:@stdlib/array/float64}}( [ 0.0 ] );
    > var dtype = 'float64';
    > var shx = [ 2, 2 ];
    > var shy = [ 2, 2 ];
    > var shz = [];
    > var sx = [ 2, 1 ];
    > var sy = [ 2, 1 ];
    > var sz = [ 0 ];
    > var ox = 0;
    > var oy = 0;
    > var oz = 0;
    > var order = 'row-major';

    // Create ndarray objects...
    > var x = {
    ...     'dtype': dtype,
    ...     'data': xbuf,
    ...     'shape': shx,
    ...     'strides': sx,
    ...     'offset': ox,
    ...     'order': order
    ... };
    > var y = {
    ...     'dtype': dtype,
    ...     'data': ybuf,
    ...     'shape': shy,
    ...     'strides': sy,
    ...     'offset': oy,
    ...     'order': order
    ... };
    > var z = {
    ...     'dtype': dtype,
    ...     'data': zbuf,
    ...     'shape': shz,
    ...     'strides': sz,
    ...     'offset': oz,
    ...     'order': order
    ... };
    > {{alias}}( gdot, [ x, y, z ], [ 0, 1 ] );
    > z.data
    <Float64Array>[ 30.0 ]

    See Also
    --------