Usage

`javascript
var Float64ArrayFE = require( '@stdlib/array-fixed-endian-float64' );
`

#### Float64ArrayFE( endianness )

A typed array constructor which returns a typed array representing an array of double-precision floating-point numbers in a specified byte order.

`javascript
var arr = new Float64ArrayFE( 'little-endian' );
// returns
`

#### Float64ArrayFE( endianness, length )

Returns a typed array having a specified length and byte order.

`javascript
var arr = new Float64ArrayFE( 'little-endian', 5 );
// returns
`

#### Float64ArrayFE( endianness, typedarray )

Creates a typed array from another typed array.

`javascript
var Float32Array = require( '@stdlib/array-float32' );

var arr1 = new Float32Array( [ 0.5, 0.5, 0.5 ] );
var arr2 = new Float64ArrayFE( 'little-endian', arr1 );
// returns

var v = arr2.get( 0 );
// returns 0.5
`

#### Float64ArrayFE( endianness, obj )

Creates a typed array from an array-like object or iterable.

`javascript
var arr = new Float64ArrayFE( 'little-endian', [ 0.5, 0.5, 0.5 ] );
// returns

var v = arr.get( 0 );
// returns 0.5
`

#### Float64ArrayFE( endianness, buffer\[, byteOffset\[, length]] )

Returns a typed array view of an [ArrayBuffer][@stdlib/array/buffer].

`javascript
var ArrayBuffer = require( '@stdlib/array-buffer' );

var buf = new ArrayBuffer( 32 );
var arr = new Float64ArrayFE( 'little-endian', buf, 0, 4 );
// returns
`

*

$3

#### Float64ArrayFE.BYTES_PER_ELEMENT

Number of bytes per view element.

`javascript
var nbytes = Float64ArrayFE.BYTES_PER_ELEMENT;
// returns 8
`

#### Float64ArrayFE.name

Typed array constructor name.

`javascript
var str = Float64ArrayFE.name;
// returns 'Float64ArrayFE'
`

#### Float64ArrayFE.prototype.buffer

Read-only property which returns the [ArrayBuffer][@stdlib/array/buffer] referenced by the typed array.

`javascript
var arr = new Float64ArrayFE( 'little-endian', 5 );
var buf = arr.buffer;
// returns
`

#### Float64ArrayFE.prototype.byteLength

Read-only property which returns the length (in bytes) of the typed array.

`javascript
var arr = new Float64ArrayFE( 'little-endian', 5 );
var byteLength = arr.byteLength;
// returns 40
`

#### Float64ArrayFE.prototype.byteOffset

Read-only property which returns the offset (in bytes) of the typed array from the start of its [ArrayBuffer][@stdlib/array/buffer].

`javascript
var arr = new Float64ArrayFE( 'little-endian', 5 );
var byteOffset = arr.byteOffset;
// returns 0
`

#### Float64ArrayFE.prototype.BYTES_PER_ELEMENT

Number of bytes per view element.

`javascript
var arr = new Float64ArrayFE( 'little-endian', 5 );
var nbytes = arr.BYTES_PER_ELEMENT;
// returns 8
`

#### Float64ArrayFE.prototype.length

Read-only property which returns the number of view elements.

`javascript
var arr = new Float64ArrayFE( 'little-endian', 5 );
var len = arr.length;
// returns 5
`

*

$3

#### Float64ArrayFE.from( endianness, src\[, map\[, thisArg]] )

Creates a new typed array from an array-like object or an iterable.

`javascript
var arr = Float64ArrayFE.from( 'little-endian', [ 1.0, -1.0 ] );
// returns

var v = arr.get( 0 );
// returns 1.0
`

To invoke a function for each src value, provide a callback function.

`javascript
function mapFcn( v ) {
return v * 2.0;
}

var arr = Float64ArrayFE.from( 'little-endian', [ 1.0, -1.0 ], mapFcn );
// returns

var v = arr.get( 0 );
// returns 2.0
`

A callback function is provided two arguments:

- value: source value.
- index: source index.

To set the callback execution context, provide a thisArg.

`javascript
function mapFcn( v ) {
this.count += 1;
return v * 2.0;
}

var ctx = {
'count': 0
};

var arr = Float64ArrayFE.from( 'little-endian', [ 1.0, -1.0 ], mapFcn, ctx );
// returns

var v = arr.get( 0 );
// returns 2.0

var n = ctx.count;
// returns 2
`

#### Float64ArrayFE.of( endianness, element0\[, element1\[, ...elementN]] )

Creates a new typed array from a variable number of arguments.

`javascript
var arr = Float64ArrayFE.of( 'little-endian', 1.0, -1.0 );
// returns

var v = arr.get( 0 );
// returns 1.0
`

#### Float64ArrayFE.prototype.get( i )

Returns an array element located at a nonnegative integer position (index) i.

`javascript
var arr = new Float64ArrayFE( 'little-endian', 10 );

// Set the first element:
arr.set( 1.0, 0 );

// Get the first element:
var v = arr.get( 0 );
// returns 1.0
`

If provided an out-of-bounds index, the method returns undefined.

`javascript
var arr = new Float64ArrayFE( 'little-endian', 10 );

var v = arr.get( 100 );
// returns undefined
`

#### Float64ArrayFE.prototype.set( arr\[, offset] )

Sets array elements.

`javascript
var arr = new Float64ArrayFE( 'little-endian', [ 1.0, 2.0, 3.0 ] );
// returns

var v = arr.get( 0 );
// returns 1.0

v = arr.get( 1 );
// returns 2.0

// Set the first two array elements:
arr.set( [ 4.0, 5.0 ] );

v = arr.get( 0 );
// returns 4.0

v = arr.get( 1 );
// returns 5.0
`

By default, the method starts writing values at the first array index. To specify an alternative index, provide an index offset.

`javascript
var arr = new Float64ArrayFE( 'little-endian', [ 1.0, 2.0, 3.0 ] );
// returns

// Set the last two array elements:
arr.set( [ 4.0, 5.0 ], 1 );

var v = arr.get( 1 );
// returns 4.0

v = arr.get( 2 );
// returns 5.0
`

A few notes:

- If i is out-of-bounds, the method throws an error.
- If a target array cannot accommodate all values (i.e., the length of source array plus i exceeds the target array length), the method throws an error.
- If provided a typed array which shares an [ArrayBuffer][@stdlib/array/buffer] with the target array, the method will intelligently copy the source range to the destination range.

#### Float64ArrayFE.prototype.toString()

Serializes an array as a string.

`javascript
var arr = new Float64ArrayFE( 'little-endian', [ 1.0, 2.0, 3.0 ] );

var str = arr.toString();
// returns '1,2,3'
`