
{{alias}}( fcn, arrays, dims[, options] )
    Applies a one-dimensional strided array function to a list of specified
    dimensions in an 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).

    Any additional ndarray arguments are expected to have the same dimensions as
    the loop dimensions of the first provided ndarray. When calling the strided
    array 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. The
        function should have the following signature:

            fcn( arrays[, options] )

        where

        - arrays: array containing a one-dimensional subarray of the first
        provided ndarray and any additional ndarray arguments as zero-
        dimensional ndarrays.
        - options: function options.

    arrays: ArrayLikeObject<ndarray>
        Array-like object containing an ndarray followed by any additional
        ndarray arguments.

    dims: Array<integer>
        List of dimensions to which to apply a strided array function.

    options: Object (optional)
        Function options.

    Examples
    --------
    // Define ndarray data and meta data...
    > var xbuf = [ 4.0, 3.0, 2.0, 1.0 ];
    > var dtype = 'generic';
    > var shx = [ 2, 2 ];
    > var sx = [ 2, 1 ];
    > var ox = 0;
    > var order = 'row-major';

    // Define a wrapper for an extended BLAS function...
    > var f = {{alias:@stdlib/blas/ext/base/gsorthp}}.ndarray;
    > function fcn( arrays ) {
    ...    var x = arrays[ 0 ];
    ...    var o = arrays[ 1 ];
    ...    var N = x.shape[ 0 ];
    ...    var dx = x.data;
    ...    var sx = x.strides[ 0 ];
    ...    var ox = x.offset;
    ...    var init = o.data[ o.offset ];
    ...    return f( N, init, dx, sx, ox );
    ... };

    // Using minimal ndarray-like objects...
    > var x = {
    ...     'dtype': dtype,
    ...     'data': xbuf,
    ...     'shape': shx,
    ...     'strides': sx,
    ...     'offset': ox,
    ...     'order': order
    ... };
    > var sortOrder = {
    ...     'dtype': dtype,
    ...     'data': [ 1.0 ],
    ...     'shape': [],
    ...     'strides': [ 0 ],
    ...     'offset': 0,
    ...     'order': order
    ... };
    > {{alias}}( fcn, [ x, sortOrder ], [ 0, 1 ] );
    > x.data
    [ 1.0, 2.0, 3.0, 4.0 ]

    See Also
    --------

