function StridedArrayStream( N, buffer, stride, offset, options ) {
	var opts;
	var err;
	var i;
	if ( !( this instanceof StridedArrayStream ) ) {
		if ( arguments.length > 4 ) {
			return new StridedArrayStream( N, buffer, stride, offset, options );
		}
		return new StridedArrayStream( N, buffer, stride, offset );
	}
	if ( !isNonNegativeInteger( N ) ) {
		throw new TypeError( format( 'invalid argument. First argument must be a nonnegative integer. Value: `%s`.', N ) );
	}
	if ( !isCollection( buffer ) ) {
		throw new TypeError( format( 'invalid argument. Second argument must be an array-like object. Value: `%s`.', buffer ) );
	}
	if ( !isInteger( stride ) ) {
		throw new TypeError( format( 'invalid argument. Third argument must be an integer. Value: `%s`.', stride ) );
	}
	if ( !isNonNegativeInteger( offset ) ) {
		throw new TypeError( format( 'invalid argument. Fourth argument must be a nonnegative integer. Value: `%s`.', offset ) );
	}
	if ( N > 0 ) {
		i = offset + ((N-1)*stride);
		if ( offset >= buffer.length || i < 0 || i >= buffer.length ) {
			throw new RangeError( 'invalid arguments. Strided array parameters are incompatible with the provided array-like object. Linear index exceeds array bounds.' );
		}
	}
	opts = assign( {}, DEFAULTS );
	if ( arguments.length > 4 ) {
		err = validate( opts, options );
		if ( err ) {
			throw err;
		}
	}
	// Make the stream a readable stream:
	debug( 'Creating a readable stream configured with the following options: %s.', JSON.stringify( opts ) );
	Readable.call( this, opts );

	// Destruction state:
	setNonEnumerable( this, '_destroyed', false );

	// Cache whether the stream is operating in object mode:
	setNonEnumerableReadOnly( this, '_objectMode', opts.objectMode );

	// Cache the separator:
	setNonEnumerableReadOnly( this, '_sep', opts.sep );

	// Define the serialization function:
	setNonEnumerableReadOnly( this, '_serialize', opts.serialize || JSON.stringify );

	// Cache the data source:
	setNonEnumerableReadOnly( this, '_buffer', buffer );

	// Cache the strided array parameters:
	setNonEnumerableReadOnly( this, '_N', N );
	setNonEnumerableReadOnly( this, '_stride', stride );
	setNonEnumerableReadOnly( this, '_offset', offset );
	setNonEnumerable( this, '_idx', offset );

	// Initialize an iteration counter:
	setNonEnumerable( this, '_i', 0 );

	return this;
}
Stream constructor for generating a readable stream from an array-like object.

@constructor
@param {NonNegativeInteger} N - number of values to stream
@param {Collection} buffer - source value
@param {integer} stride - stride length
@param {NonNegativeInteger} offset - starting index
@param {Options} [options] - stream options
@param {boolean} [options.objectMode=false] - specifies whether the stream should operate in object mode
@param {(string|null)} [options.encoding=null] - specifies how `Buffer` objects should be decoded to strings
@param {NonNegativeNumber} [options.highWaterMark] - specifies the maximum number of bytes to store in an internal buffer before pausing streaming
@param {string} [options.sep='\n'] - separator used to join streamed data
@param {Function} [options.serialize] - custom serialization function
@throws {TypeError} first argument must be a nonnegative integer
@throws {TypeError} second argument must be an array-like object
@throws {TypeError} third argument must be an integer
@throws {TypeError} fourth argument must be a nonnegative integer
@throws {RangeError} linear index cannot exceed array bounds
@throws {TypeError} options argument must be an object
@throws {TypeError} must provide valid options
@returns {StridedArrayStream} Stream instance

@example
var inspectStream = require( '@stdlib/streams/node/inspect-sink' );
var Float64Array = require( '@stdlib/array/float64' );
var randu = require( '@stdlib/random/base/randu' );

function log( chunk ) {
   console.log( chunk.toString() );
}

var arr = new Float64Array( 10 );
var i;
for ( i = 0; i < arr.length; i++ ) {
    arr[ i ] = randu();
}

var stream = new StridedArrayStream( arr.length, arr, 1, 0 );

stream.pipe( inspectStream( log )  );