function unary1d( fcn, arrays, strategy, views, ibuf, ldims, cdims, strides, opts, hasOpts, clbk, thisArg ) {
	var ybuf;
	var set;
	var dv0;
	var sh;
	var S0;
	var iv;
	var i0;
	var x;
	var y;
	var v;
	var i;
	var f;

	// Note on variable naming convention: S#, dv#, i# where # corresponds to the loop number, with `0` being the innermost loop...

	// Cache a reference to the input ndarray:
	x = arrays[ 0 ];

	// Resolve the output ndarray and associated shape:
	y = arrays[ 1 ];
	sh = y.shape;

	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
	S0 = sh[ 0 ];
	dv0 = [ strides[0] ];
	for ( i = 1; i < arrays.length; i++ ) {
		dv0.push( arrays[i].strides[0] );
	}
	// Resolve a list of pointers to the first indexed elements in the respective ndarrays:
	iv = offsets( arrays );

	// Shallow copy the list of views to an internal array so that we can update with reshaped views without impacting the original list of views:
	v = copyIndexed( views );

	// Cache a reference to the output ndarray buffer:
	ybuf = y.data;

	// Cache accessors:
	set = y.accessors[ 1 ];

	// Iterate over the non-reduced ndarray dimensions...
	for ( i0 = 0; i0 < S0; i0++ ) {
		setViewOffsets( views, iv );
		v[ 0 ] = strategy( views[ 0 ] );
		f = wrap( x.ref, views[ 0 ], ibuf, ldims, [ i0 ], cdims, clbk, thisArg );
		set( ybuf, iv[1], ( hasOpts ) ? fcn( v, opts, f ): fcn( v, f ) );
		incrementOffsets( iv, dv0 );
	}
}
Performs a reduction over an input ndarray according to callback function and assigns results to a provided output ndarray.

@private
@param {Function} fcn - wrapper for a one-dimensional strided array reduction function
@param {Array<Object>} arrays - ndarrays
@param {Function} strategy - input ndarray reshape strategy
@param {Array<Object>} views - initialized ndarray-like objects representing sub-array views
@param {NonNegativeIntegerArray} ibuf - workspace for storing iteration indices
@param {NonNegativeIntegerArray} ldims - list of loop dimensions
@param {NonNegativeIntegerArray} cdims - list of "core" dimensions
@param {IntegerArray} strides - loop dimension strides for the input ndarray
@param {Options} opts - function options
@param {boolean} hasOpts - boolean indicating whether to pass an options argument to a reduction function
@param {Function} clbk - callback function
@param {*} thisArg - callback exection context
@returns {void}

@example
var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
var accessors = require( '@stdlib/array/base/accessors' );
var Float64Array = require( '@stdlib/array/float64' );
var zeros = require( '@stdlib/array/base/zeros' );
var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
var maxBy = require( '@stdlib/stats/base/ndarray/max-by' );

function clbk( value ) {
    return value * 2.0;
}

// Create data buffers:
var xbuf = toAccessorArray( new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ) );
var ybuf = toAccessorArray( new Float64Array( [ 0.0, 0.0, 0.0 ] ) );

// Define the array shapes:
var xsh = [ 3, 2, 2 ];
var ysh = [ 3 ];

// Define the array strides:
var sx = [ 4, 2, 1 ];
var sy = [ 1 ];

// Define the index offsets:
var ox = 0;
var oy = 0;

// Create an input ndarray-like object:
var x = {
    'dtype': 'float64',
    'data': xbuf,
    'shape': xsh,
    'strides': sx,
    'offset': ox,
    'order': 'row-major',
    'accessors': accessors( xbuf ).accessors
};

// Create an output ndarray-like object:
var y = {
    'dtype': 'float64',
    'data': ybuf,
    'shape': ysh,
    'strides': sy,
    'offset': oy,
    'order': 'row-major',
    'accessors': accessors( ybuf ).accessors
};

// Initialize ndarray-like objects representing sub-array views:
var views = [
    {
        'dtype': x.dtype,
        'data': x.data,
        'shape': [ 2, 2 ],
        'strides': [ 2, 1 ],
        'offset': x.offset,
        'order': x.order
    }
];

// Define a reshape strategy:
function strategy( x ) {
    return {
        'dtype': x.dtype,
        'data': x.data,
        'shape': [ 4 ],
        'strides': [ 1 ],
        'offset': x.offset,
        'order': x.order
    };
}

// 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 ];

// Resolve the loop dimension strides for the input array:
var slx = [ 4 ];

// Perform a reduction:
unary1d( maxBy, [ x, y ], strategy, views, ibuf, ldims, cdims, slx, {}, false, clbk, {} );

var arr = ndarray2array( y.data, y.shape, y.strides, y.offset, y.order );
// returns [ 8.0, 16.0, 24.0 ]