Complex128Array

128-bit complex number array.

Usage

var Complex128Array = require( '@stdlib/array/complex128' );

Complex128Array()

Creates a 128-bit complex number array.

var arr = new Complex128Array();
// returns <Complex128Array>

Complex128Array( length )

Creates a 128-bit complex number array having a specified length.

var arr = new Complex128Array( 10 );
// returns <Complex128Array>

var len = arr.length;
// returns 10

Complex128Array( complexarray )

Creates a 128-bit complex number array from another complex number array.

var arr1 = new Complex128Array( [ 1.0, -1.0, 2.0, -2.0 ] ); // [ re, im, re, im ]
// returns <Complex128Array>

var arr2 = new Complex128Array( arr1 );
// returns <Complex128Array>

var len = arr2.length;
// returns 2

Complex128Array( typedarray )

Creates a 128-bit complex number array from a typed array containing interleaved real and imaginary components.

var Float64Array = require( '@stdlib/array/float64' );

var buf = new Float64Array( [ 1.0, -1.0, 2.0, -2.0 ] ); // [ re, im, re, im ]
// returns <Float64Array>[ 1.0, -1.0, 2.0, -2.0 ]

var arr = new Complex128Array( buf );
// returns <Complex128Array>

var len = arr.length;
// returns 2

Complex128Array( obj )

Creates a 128-bit complex number array from an array-like object or iterable.

var Complex128 = require( '@stdlib/complex/float64' );

// From an array of interleaved real and imaginary components:
var arr1 = new Complex128Array( [ 1.0, -1.0, 2.0, -2.0 ] );
// returns <Complex128Array>

var len = arr1.length;
// returns 2

// From an array containing complex numbers:
var buf = [ new Complex128( 1.0, -1.0 ), new Complex128( 2.0, -2.0 ) ];
var arr2 = new Complex128Array( buf );

len = arr2.length;
// returns 2

Complex128Array( buffer[, byteOffset[, length]] )

Returns a 128-bit complex number array view of an ArrayBuffer.

var ArrayBuffer = require( '@stdlib/array/buffer' );
var buf = new ArrayBuffer( 480 );

var arr1 = new Complex128Array( buf );
// returns <Complex128Array>

var len = arr1.length;
// returns 30

var arr2 = new Complex128Array( buf, 16 );
// returns <Complex128Array>

len = arr2.length;
// returns 29

var arr3 = new Complex128Array( buf, 16, 20 );
// returns <Complex128Array>

len = arr3.length;
// returns 20

---

Properties

Complex128Array.BYTES_PER_ELEMENT

Static property returning the size (in bytes) of each array element.

var nbytes = Complex128Array.BYTES_PER_ELEMENT;
// returns 16

Complex128Array.name

Static property returning the constructor name.

var str = Complex128Array.name;
// returns 'Complex128Array'

Complex128Array.prototype.buffer

Pointer to the underlying data buffer.

var arr = new Complex128Array( 2 );
// returns <Complex128Array>

var buf = arr.buffer;
// returns <ArrayBuffer>

Complex128Array.prototype.byteLength

Size (in bytes) of the array.

var arr = new Complex128Array( 10 );
// returns <Complex128Array>

var nbytes = arr.byteLength;
// returns 160

Complex128Array.prototype.byteOffset

Offset (in bytes) of the array from the start of its underlying ArrayBuffer.

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

var arr = new Complex128Array( 10 );
// returns <Complex128Array>

var offset = arr.byteOffset;
// returns 0

var buf = new ArrayBuffer( 480 );
arr = new Complex128Array( buf, 128 );
// returns <Complex128Array>

offset = arr.byteOffset;
// returns 128

Complex128Array.prototype.BYTES_PER_ELEMENT

Size (in bytes) of each array element.

var arr = new Complex128Array( 10 );
// returns <Complex128Array>

var nbytes = arr.BYTES_PER_ELEMENT;
// returns 16

Complex128Array.prototype.length

Number of array elements.

var arr = new Complex128Array( 10 );
// returns <Complex128Array>

var len = arr.length;
// returns 10

---

Methods

Complex128Array.from( src[, clbk[, thisArg]] )

Creates a new 128-bit complex number array from an array-like object or an iterable.

var Complex128 = require( '@stdlib/complex/float64' );

// Create an array from interleaved real and imaginary components:
var arr = Complex128Array.from( [ 1.0, -1.0 ] );
// returns <Complex128Array>

var len = arr.length;
// returns 1

// Create an array from an array of complex numbers:
arr = Complex128Array.from( [ new Complex128( 1.0, -1.0 ) ] );
// returns <Complex128Array>

len = arr.length;
// returns 1

The iterator returned by an iterable must return either a complex number or an array-like object containing a real and imaginary component.

var ITERATOR_SYMBOL = require( '@stdlib/symbol/iterator' );
var Float64Array = require( '@stdlib/array/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var iter;
var arr;
var len;
var re;
var im;
var z;

// Define a function which returns an iterator protocol-compliant object...
function iterable() {
    var buf = new Float64Array( 2 );
    var i = 0;
    return {
        'next': next
    };

    function next() {
        i += 1;
        if ( i < 3 ) {
            // Reuse allocated memory...
            buf[ 0 ] = i;
            buf[ 1 ] = -i;
            return {
                'value': buf
            };
        }
        return {
            'done': true
        };
    }
}

if ( ITERATOR_SYMBOL === null ) {
    console.error( 'Environment does not support iterables.' );
} else {
    // Create an iterable:
    iter = {};
    iter[ ITERATOR_SYMBOL ] = iterable;

    // Generate a complex number array:
    arr = Complex128Array.from( iter );
    // returns <Complex128Array>

    len = arr.length;
    // returns 2

    z = arr.get( 0 );
    // returns <Complex128>

    re = real( z );
    // returns 1.0

    im = imag( z );
    // returns -1.0
}

To invoke a function for each src value, provide a callback function. If src is an iterable or an array-like object containing complex numbers, the callback must return either a complex number

var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function map( z ) {
    return new Complex128( real(z)*2.0, imag(z)*2.0 );
}

// Create a source array:
var src = [ new Complex128( 1.0, -1.0 ) ];

// Create a new complex number array by scaling the source array:
var arr = Complex128Array.from( src, map );
// returns <Complex128Array>

var len = arr.length;
// returns 1

var z = arr.get( 0 );
// returns <Complex128>

var re = real( z );
// returns 2.0

var im = imag( z );
// returns -2.0

or an array-like object containing real and imaginary components

var Float64Array = require( '@stdlib/array/float64' );
var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

// Return a callback which reuses allocated memory...
function mapFcn() {
    var buf = new Float64Array( 2 );
    return map;

    function map( z ) {
        buf[ 0 ] = real( z ) * 2.0;
        buf[ 1 ] = imag( z ) * 2.0;
        return buf;
    }
}

// Create a source array:
var src = [ new Complex128( 1.0, -1.0 ), new Complex128( 2.0, -2.0 ) ];

// Create a new complex number array by scaling the source array:
var arr = Complex128Array.from( src, mapFcn() );
// returns <Complex128Array>

var len = arr.length;
// returns 2

var z = arr.get( 0 );
// returns <Complex128>

var re = real( z );
// returns 2.0

var im = imag( z );
// returns -2.0

z = arr.get( 1 );
// returns <Complex128>

re = real( z );
// returns 4.0

im = imag( z );
// returns -4.0

If src is an array-like object containing interleaved real and imaginary components, the callback is invoked for each component and should return the transformed component value.

var Float64Array = require( '@stdlib/array/float64' );
var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function map( v ) {
    return v * 2.0;
}

// Create a source array:
var src = new Float64Array( [ 1.0, -1.0 ] );

// Create a new complex number array by scaling the source array:
var arr = Complex128Array.from( src, map );
// returns <Complex128Array>

var len = arr.length;
// returns 1

var z = arr.get( 0 );
// returns <Complex128>

var re = real( z );
// returns 2.0

var im = imag( z );
// 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.

var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function map( z ) {
    this.count += 1;
    return new Complex128( real(z)*2.0, imag(z)*2.0 );
}

// Create a source array:
var src = [ new Complex128( 1.0, -1.0 ), new Complex128( 1.0, -1.0 ) ];

// Define an execution context:
var ctx = {
    'count': 0
};

// Create a new complex number array by scaling the source array:
var arr = Complex128Array.from( src, map, ctx );
// returns <Complex128Array>

var len = arr.length;
// returns 2

var n = ctx.count;
// returns 2

Complex128Array.of( element0[, element1[, ...elementN]] )

Creates a new 128-bit complex number array from a variable number of arguments.

var Complex128 = require( '@stdlib/complex/float64' );

var arr = Complex128Array.of( 1.0, -1.0, 2.0, -2.0 );
// returns <Complex128Array>

var len = arr.length;
// returns 2

var z1 = new Complex128( 1.0, -1.0 );
var z2 = new Complex128( 2.0, -2.0 );

arr = Complex128Array.of( z1, z2 );
// returns <Complex128Array>

len = arr.length;
// returns 2

Complex128Array.prototype.at( i )

Returns an array element located at integer position (index) i, with support for both nonnegative and negative integer positions.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var arr = new Complex128Array( 10 );

// Set the first, second, and last elements:
arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, -2.0 ], 1 );
arr.set( [ 9.0, -9.0 ], 9 );

// Get the first element:
var z = arr.at( 0 );
// returns <Complex128>

var re = real( z );
// returns 1.0

var im = imag( z );
// returns -1.0

// Get the last element:
z = arr.at( -1 );
// returns <Complex128>

re = real( z );
// returns 9.0

im = imag( z );
// returns -9.0

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

var arr = new Complex128Array( 10 );

var z = arr.at( 100 );
// returns undefined

z = arr.at( -100 );
// returns undefined

Complex128Array.prototype.copyWithin( target, start[, end] )

Copies a sequence of elements within the array starting at start and ending at end (non-inclusive) to the position starting at target.

var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var arr = new Complex128Array( 4 );

// Set the array elements:
arr.set( new Complex128( 1.0, -1.0 ), 0 );
arr.set( new Complex128( 2.0, -2.0 ), 1 );
arr.set( new Complex128( 3.0, -3.0 ), 2 );
arr.set( new Complex128( 4.0, -4.0 ), 3 );

// Get the first array element:
var z = arr.get( 0 );
// returns <Complex128>

var re = real( z );
// returns 1.0

var im = imag( z );
// returns -1.0

// Get the second array element:
z = arr.get( 1 );
// returns <Complex128>

re = real( z );
// returns 2.0

im = imag( z );
// returns -2.0

// Copy the last two elements to the first two elements:
arr.copyWithin( 0, 2 );

// Get the first array element:
z = arr.get( 0 );
// returns <Complex128>

re = real( z );
// returns 3.0

im = imag( z );
// returns -3.0

// Get the second array element:
z = arr.get( 1 );
// returns <Complex128>

re = real( z );
// returns 4.0

im = imag( z );
// returns -4.0

By default, end equals the number of array elements (i.e., one more than the last array index). To limit the sequence length, provide an end argument.

var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var arr = new Complex128Array( 4 );

// Set the array elements:
arr.set( new Complex128( 1.0, -1.0 ), 0 );
arr.set( new Complex128( 2.0, -2.0 ), 1 );
arr.set( new Complex128( 3.0, -3.0 ), 2 );
arr.set( new Complex128( 4.0, -4.0 ), 3 );

// Get the third array element:
var z = arr.get( 2 );
// returns <Complex128>

var re = real( z );
// returns 3.0

var im = imag( z );
// returns -3.0

// Get the last array element:
z = arr.get( 3 );
// returns <Complex128>

re = real( z );
// returns 4.0

im = imag( z );
// returns -4.0

// Copy the first two elements to the last two elements:
arr.copyWithin( 2, 0, 2 );

// Get the third array element:
z = arr.get( 2 );
// returns <Complex128>

re = real( z );
// returns 1.0

im = imag( z );
// returns -1.0

// Get the last array element:
z = arr.get( 3 );
// returns <Complex128>

re = real( z );
// returns 2.0

im = imag( z );
// returns -2.0

When a target, start, and/or end index is negative, the respective index is determined relative to the last array element. The following example achieves the same behavior as the previous example:

var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var arr = new Complex128Array( 4 );

// Set the array elements:
arr.set( new Complex128( 1.0, -1.0 ), 0 );
arr.set( new Complex128( 2.0, -2.0 ), 1 );
arr.set( new Complex128( 3.0, -3.0 ), 2 );
arr.set( new Complex128( 4.0, -4.0 ), 3 );

// Get the third array element:
var z = arr.get( 2 );
// returns <Complex128>

var re = real( z );
// returns 3.0

var im = imag( z );
// returns -3.0

// Get the last array element:
z = arr.get( 3 );
// returns <Complex128>

re = real( z );
// returns 4.0

im = imag( z );
// returns -4.0

// Copy the first two elements to the last two elements using negative indices:
arr.copyWithin( -2, -4, -2 );

// Get the third array element:
z = arr.get( 2 );
// returns <Complex128>

re = real( z );
// returns 1.0

im = imag( z );
// returns -1.0

// Get the last array element:
z = arr.get( 3 );
// returns <Complex128>

re = real( z );
// returns 2.0

im = imag( z );
// returns -2.0

Complex128Array.prototype.entries()

Returns an iterator for iterating over array key-value pairs.

var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var arr = [
    new Complex128( 1.0, -1.0 ),
    new Complex128( 2.0, -2.0 ),
    new Complex128( 3.0, -3.0 )
];
arr = new Complex128Array( arr );

// Create an iterator:
var it = arr.entries();

// Iterate over the key-value pairs...
var v = it.next().value;
// returns [ 0, <Complex128> ]

var re = real( v[ 1 ] );
// returns 1.0

var im = imag( v[ 1 ] );
// returns -1.0

v = it.next().value;
// returns [ 1, <Complex128> ]

re = real( v[ 1 ] );
// returns 2.0

im = imag( v[ 1 ] );
// returns -2.0

v = it.next().value;
// returns [ 2, <Complex128> ]

re = real( v[ 1 ] );
// returns 3.0

im = imag( v[ 1 ] );
// returns -3.0

var bool = it.next().done;
// returns true

Complex128Array.prototype.every( predicate[, thisArg] )

Returns a boolean indicating whether all elements pass a test.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function predicate( v ) {
    return ( real( v ) === imag( v ) );
}

var arr = new Complex128Array( 3 );

// Set the first three elements:
arr.set( [ 1.0, 1.0 ], 0 );
arr.set( [ 2.0, 2.0 ], 1 );
arr.set( [ 3.0, 3.0 ], 2 );

// Check whether all elements pass a test:
var bool = arr.every( predicate );
// returns true

The predicate function is provided three arguments:

• value: current array element.
• index: current array element index.
• arr: the array on which this method was called.

To set the function execution context, provide a thisArg.

function predicate( v, i ) {
    this.count += 1;
    return ( i >= 0 );
}

var arr = new Complex128Array( 3 );

var context = {
    'count': 0
};

// Set the first three elements:
arr.set( [ 1.0, 1.0 ], 0 );
arr.set( [ 2.0, 2.0 ], 1 );
arr.set( [ 3.0, 3.0 ], 2 );

var bool = arr.every( predicate, context );
// returns true

var count = context.count;
// returns 3

Complex128Array.prototype.fill( value[, start[, end]] )

Returns a modified typed array filled with a fill value.

var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var arr = new Complex128Array( 3 );

// Set all elements to the same value:
arr.fill( new Complex128( 1.0, 1.0 ) );

var z = arr.get( 0 );
// returns <Complex128>

var re = real( z );
// returns 1.0

var im = imag( z );
// returns 1.0

z = arr.get( 2 );
// returns <Complex128>

re = real( z );
// returns 1.0

im = imag( z );
// returns 1.0

// Fill all elements starting from the second element:
arr.fill( new Complex128( 2.0, 2.0 ), 1 );

z = arr.get( 1 );
// returns <Complex128>

re = real( z );
// returns 2.0

im = imag( z );
// returns 2.0

z = arr.get( 2 );
// returns <Complex128>

re = real( z );
// returns 2.0

im = imag( z );
// returns 2.0

// Fill all elements from first element until the second-to-last element:
arr.fill( new Complex128( 3.0, 3.0 ), 0, 2 );

z = arr.get( 0 );
// returns <Complex128>

re = real( z );
// returns 3.0

im = imag( z );
// returns 3.0

z = arr.get( 1 );
// returns <Complex128>

re = real( z );
// returns 3.0

im = imag( z );
// returns 3.0

When a start and/or end index is negative, the respective index is determined relative to the last array element.

var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var arr = new Complex128Array( 3 );

// Set all array elements, except the last element, to the same value:
arr.fill( new Complex128( 1.0, 1.0 ), 0, -1 );

var z = arr.get( 0 );
// returns <Complex128>

var re = real( z );
// returns 1.0

var im = imag( z );
// returns 1.0

z = arr.get( arr.length - 1 );
// returns <Complex128>

re = real( z );
// returns 0.0

im = imag( z );
// returns 0.0

Complex128Array.prototype.filter( predicate[, thisArg] )

Returns a new array containing the elements of an array which pass a test implemented by a predicate function.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function predicate( v ) {
    return ( real( v ) === imag( v ) );
}

var arr = new Complex128Array( 3 );

// Set the first three elements:
arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, 2.0 ], 1 );
arr.set( [ 3.0, -3.0 ], 2 );

var out = arr.filter( predicate );
// returns <Complex128Array>

var len = out.length;
// returns 1

var z = out.get( 0 );
// returns <Complex128>

var re = real( z );
// returns 2.0

var im = imag( z );
// returns 2.0

The predicate function is provided three arguments:

• value: current array element.
• index: current array element index.
• arr: the array on which this method was called.

To set the function execution context, provide a thisArg.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function predicate( v, i ) {
    this.count += 1;
    return ( i >= 0 && real( v ) === imag( v ) );
}

var arr = new Complex128Array( 3 );

var context = {
    'count': 0
};

// Set the first three elements:
arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, 2.0 ], 1 );
arr.set( [ 3.0, 3.0 ], 2 );

var out = arr.filter( predicate, context );
// returns <Complex128Array>

var len = out.length;
// returns 2

var count = context.count;
// returns 3

Complex128Array.prototype.find( predicate[, thisArg] )

Returns the first element in an array for which a predicate function returns a truthy value.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function predicate( v ) {
    return ( real( v ) === imag( v ) );
}

var arr = new Complex128Array( 3 );

// Set the first three elements:
arr.set( [ 1.0, 1.0 ], 0 );
arr.set( [ 2.0, 2.0 ], 1 );
arr.set( [ 3.0, 3.0 ], 2 );

var z = arr.find( predicate );
// returns <Complex128>

var re = real( z );
// returns 1.0

var im = imag( z );
// returns 1.0

The predicate function is provided three arguments:

• value: current array element.
• index: current array element index.
• arr: the array on which this method was called.

To set the function execution context, provide a thisArg.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function predicate( v, i ) {
    this.count += 1;
    return ( i >= 0 && real( v ) === imag( v ) );
}

var arr = new Complex128Array( 3 );

var context = {
    'count': 0
};

// Set the first three elements:
arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, 2.0 ], 1 );
arr.set( [ 3.0, 3.0 ], 2 );

var z = arr.find( predicate, context );
// returns <Complex128>

var re = real( z );
// returns 2.0

var im = imag( z );
// returns 2.0

var count = context.count;
// returns 2

Complex128Array.prototype.findIndex( predicate[, thisArg] )

Returns the index of the first element in an array for which a predicate function returns a truthy value.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function predicate( v ) {
    return ( real( v ) === imag( v ) );
}

var arr = new Complex128Array( 3 );

// Set the first three elements:
arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, -2.0 ], 1 );
arr.set( [ 3.0, 3.0 ], 2 );

var idx = arr.findIndex( predicate );
// returns 2

The predicate function is provided three arguments:

• value: current array element.
• index: current array element index.
• arr: the array on which this method was called.

To set the function execution context, provide a thisArg.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function predicate( v, i ) {
    this.count += 1;
    return ( i >= 0 && real( v ) === imag( v ) );
}

var arr = new Complex128Array( 3 );

var context = {
    'count': 0
};

// Set the first three elements:
arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, -2.0 ], 1 );
arr.set( [ 3.0, -3.0 ], 2 );

var idx = arr.findIndex( predicate, context );
// returns -1

var count = context.count;
// returns 3

Complex128Array.prototype.findLast( predicate[, thisArg] )

Returns the last element in an array for which a predicate function returns a truthy value.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function predicate( v ) {
    return ( real( v ) === imag( v ) );
}

var arr = new Complex128Array( 3 );

// Set the first three elements:
arr.set( [ 1.0, 1.0 ], 0 );
arr.set( [ 2.0, 2.0 ], 1 );
arr.set( [ 3.0, 3.0 ], 2 );

var z = arr.findLast( predicate );
// returns <Complex128>

var re = real( z );
// returns 3.0

var im = imag( z );
// returns 3.0

The predicate function is provided three arguments:

• value: current array element.
• index: current array element index.
• arr: the array on which this method was called.

To set the function execution context, provide a thisArg.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function predicate( v, i ) {
    this.count += 1;
    return ( i >= 0 && real( v ) === imag( v ) );
}

var arr = new Complex128Array( 3 );

var context = {
    'count': 0
};

// Set the first three elements:
arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, 2.0 ], 1 );
arr.set( [ 3.0, -3.0 ], 2 );

var z = arr.findLast( predicate, context );
// returns <Complex128>

var re = real( z );
// returns 2.0

var im = imag( z );
// returns 2.0

var count = context.count;
// returns 2

Complex128Array.prototype.findLastIndex( predicate[, thisArg] )

Returns the index of the last element in an array for which a predicate function returns a truthy value.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function predicate( v ) {
    return ( real( v ) === imag( v ) );
}

var arr = new Complex128Array( 3 );

// Set the first three elements:
arr.set( [ 1.0, 1.0 ], 0 );
arr.set( [ 2.0, 2.0 ], 1 );
arr.set( [ 3.0, -3.0 ], 2 );

var idx = arr.findLastIndex( predicate );
// returns 1

The predicate function is provided three arguments:

• value: current array element.
• index: current array element index.
• arr: the array on which this method was called.

To set the function execution context, provide a thisArg.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function predicate( v, i ) {
    this.count += 1;
    return ( i >= 0 && real( v ) === imag( v ) );
}

var arr = new Complex128Array( 3 );

var context = {
    'count': 0
};

// Set the first three elements:
arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, -2.0 ], 1 );
arr.set( [ 3.0, -3.0 ], 2 );

var idx = arr.findLastIndex( predicate, context );
// returns -1

var count = context.count;
// returns 3

Complex128Array.prototype.forEach( callbackFn[, thisArg] )

Invokes a function once for each array element.

var Complex128 = require( '@stdlib/complex/float64' );

function log( v, i ) {
    console.log( '%s: %s', i, v.toString() );
}

var arr = new Complex128Array( 3 );

// Set the first three elements:
arr.set( [ 1.0, 1.0 ], 0 );
arr.set( [ 2.0, 2.0 ], 1 );
arr.set( [ 3.0, 3.0 ], 2 );

arr.forEach( log );
/* =>
    0: 1 + 1i
    1: 2 + 2i
    2: 3 + 3i
*/

The invoked function is provided three arguments:

• value: current array element.
• index: current array element index.
• arr: the array on which this method was called.

To set the function execution context, provide a thisArg.

var Complex128 = require( '@stdlib/complex/float64' );

function fcn( v, i ) {
    this.count += 1;
    console.log( '%s: %s', i, v.toString() );
}

var arr = new Complex128Array( 3 );

var context = {
    'count': 0
};

// Set the first three elements:
arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, -2.0 ], 1 );
arr.set( [ 3.0, -3.0 ], 2 );

arr.forEach( fcn, context );
/* =>
    0: 1 + 1i
    1: 2 + 2i
    2: 3 + 3i
*/

var count = context.count;
// returns 3

Complex128Array.prototype.get( i )

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

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var arr = new Complex128Array( 10 );

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

// Get the first element:
var z = arr.get( 0 );
// returns <Complex128>

var re = real( z );
// returns 1.0

var im = imag( z );
// returns -1.0

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

var arr = new Complex128Array( 10 );

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

Complex128Array.prototype.includes( searchElement[, fromIndex] )

Returns a boolean indicating whether an array includes a provided value.

var Complex128 = require( '@stdlib/complex/float64' );

var arr = new Complex128Array( 5 );

arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, -2.0 ], 1 );
arr.set( [ 3.0, -3.0 ], 2 );
arr.set( [ 4.0, -4.0 ], 3 );
arr.set( [ 5.0, -5.0 ], 4 );

var bool = arr.includes( new Complex128( 3.0, -3.0 ) );
// returns true

bool = arr.includes( new Complex128( 3.0, -3.0 ), 3 );
// returns false

bool = arr.includes( new Complex128( 4.0, -4.0 ), -3 );
// returns true

Complex128Array.prototype.indexOf( searchElement[, fromIndex] )

Returns the first index at which a given element can be found.

var Complex128 = require( '@stdlib/complex/float64' );

var arr = new Complex128Array( 5 );

arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, -2.0 ], 1 );
arr.set( [ 3.0, -3.0 ], 2 );
arr.set( [ 4.0, -4.0 ], 3 );
arr.set( [ 2.0, -2.0 ], 4 );

var idx = arr.indexOf( new Complex128( 3.0, -3.0 ) );
// returns 2

idx = arr.indexOf( new Complex128( 2.0, -2.0 ), 2 );
// returns 4

idx = arr.indexOf( new Complex128( 4.0, -4.0 ), -3 );
// returns 3

If searchElement is not present in the array, the method returns -1.

var Complex128 = require( '@stdlib/complex/float64' );

var arr = new Complex128Array( 5 );

arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, -2.0 ], 1 );

var idx = arr.indexOf( new Complex128( 3.0, -3.0 ) );
// returns -1

idx = arr.indexOf( new Complex128( 1.0, -1.0 ), 1 );
// returns -1

Complex128Array.prototype.join( [separator] )

Returns a new string by concatenating all array elements.

var arr = new Complex128Array( 3 );

arr.set( [ 1.0, 1.0 ], 0 );
arr.set( [ 2.0, -2.0 ], 1 );
arr.set( [ 3.0, 3.0 ], 2 );

var str = arr.join();
// returns '1 + 1i,2 - 2i,3 + 3i'

By default, the method separates serialized array elements with a comma. To use an alternative separator, provide a separator string.

var arr = new Complex128Array( 3 );

arr.set( [ 1.0, 1.0 ], 0 );
arr.set( [ 2.0, -2.0 ], 1 );
arr.set( [ 3.0, 3.0 ], 2 );

var str = arr.join( '/' );
// returns '1 + 1i/2 - 2i/3 + 3i'

Complex128Array.prototype.lastIndexOf( searchElement[, fromIndex] )

Returns the last index at which a given element can be found.

var Complex128 = require( '@stdlib/complex/float64' );

var arr = new Complex128Array( 5 );

arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, -2.0 ], 1 );
arr.set( [ 3.0, -3.0 ], 2 );
arr.set( [ 4.0, -4.0 ], 3 );
arr.set( [ 2.0, -2.0 ], 4 );

var idx = arr.lastIndexOf( new Complex128( 3.0, -3.0 ) );
// returns 2

idx = arr.lastIndexOf( new Complex128( 2.0, -2.0 ), 2 );
// returns 1

idx = arr.lastIndexOf( new Complex128( 4.0, -4.0 ), -1 );
// returns 3

If searchElement is not present in the array, the method returns -1.

var Complex128 = require( '@stdlib/complex/float64' );

var arr = new Complex128Array( 5 );

arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, -2.0 ], 1 );

var idx = arr.lastIndexOf( new Complex128( 3.0, -3.0 ) );
// returns -1

idx = arr.lastIndexOf( new Complex128( 2.0, -2.0 ), 0 );
// returns -1

Complex128Array.prototype.map( callbackFn[, thisArg] )

Returns a new array with each element being the result of a provided callback function.

var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function scale( v ) {
    return new Complex128( 2.0*real( v ), 2.0*imag( v ) );
}

var arr = new Complex128Array( 3 );

// Set the first three elements:
arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, -2.0 ], 1 );
arr.set( [ 3.0, -3.0 ], 2 );

var out = arr.map( scale );
// returns <Complex128Array>

var z = out.get( 0 );
// returns <Complex128>

var re = real( z );
// returns 2.0

var im = imag( z );
// returns -2.0

The callback function is provided three arguments:

• value: current array element.
• index: current array element index.
• arr: the array on which this method was called.

To set the function execution context, provide a thisArg.

var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function scale( v ) {
    this.count += 1;
    return new Complex128( 2.0*real( v ), 2.0*imag( v ) );
}

var arr = new Complex128Array( 3 );

var context = {
    'count': 0
};

// Set the first three elements:
arr.set( [ 1.0, 1.0 ], 0 );
arr.set( [ 2.0, 2.0 ], 1 );
arr.set( [ 3.0, 3.0 ], 2 );

var out = arr.map( scale, context );
// returns <Complex128Array>

var count = context.count;
// returns 3

Complex128Array.prototype.reverse()

Reverses an array in-place.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var arr = new Complex128Array( 3 );

arr.set( [ 1.0, 1.0 ], 0 );
arr.set( [ 2.0, 2.0 ], 1 );
arr.set( [ 3.0, 3.0 ], 2 );

var out = arr.reverse();
// returns <Complex128Array>

var z = out.get( 0 );
// returns <Complex128>

var re = real( z );
// returns 3.0

var im = imag( z );
// returns 3.0

z = out.get( 1 );
// returns <Complex128>

re = real( z );
// returns 2.0

im = imag( z );
// returns 2.0

z = out.get( 2 );
// returns <Complex128>

re = real( z );
// returns 1.0

im = imag( z );
// returns 1.0

Complex128Array.prototype.set( z[, i] )

Sets one or more array elements.

var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var arr = new Complex128Array( 10 );

// Get the first element:
var z = arr.get( 0 );
// returns <Complex128>

var re = real( z );
// returns 0.0

var im = imag( z );
// returns 0.0

// Set the first element:
arr.set( new Complex128( 1.0, -1.0 ) );

// Get the first element:
z = arr.get( 0 );
// returns <Complex128>

re = real( z );
// returns 1.0

im = imag( z );
// returns -1.0

By default, the method sets array elements starting at position (index) i = 0. To set elements starting elsewhere in the array, provide an index argument i.

var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var arr = new Complex128Array( 10 );

// Get the fifth element:
var z = arr.get( 4 );
// returns <Complex128>

var re = real( z );
// returns 0.0

var im = imag( z );
// returns 0.0

// Set the fifth element:
arr.set( new Complex128( 1.0, -1.0 ), 4 );

// Get the fifth element:
z = arr.get( 4 );
// returns <Complex128>

re = real( z );
// returns 1.0

im = imag( z );
// returns -1.0

In addition to providing a complex number, to set one or more array elements, provide an array-like object containing either complex numbers

var Complex128 = require( '@stdlib/complex/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var arr = new Complex128Array( 10 );

// Define an array of complex numbers:
var buf = [
    new Complex128( 1.0, -1.0 ),
    new Complex128( 2.0, -2.0 ),
    new Complex128( 3.0, -3.0 )
];

// Set the fifth, sixth, and seventh elements:
arr.set( buf, 4 );

// Get the sixth element:
var z = arr.get( 5 );
// returns <Complex128>

var re = real( z );
// returns 2.0

var im = imag( z );
// returns -2.0

or interleaved real and imaginary components

var Float64Array = require( '@stdlib/array/float64' );
var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var arr = new Complex128Array( 10 );

// Define an interleaved array of real and imaginary components:
var buf = new Float64Array( [ 1.0, -1.0, 2.0, -2.0, 3.0, -3.0 ] );

// Set the fifth, sixth, and seventh elements:
arr.set( buf, 4 );

// Get the sixth element:
var z = arr.get( 5 );
// returns <Complex128>

var re = real( z );
// returns 2.0

var im = imag( z );
// returns -2.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 with the target array, the method will intelligently copy the source range to the destination range.

Complex128Array.prototype.some( predicate[, thisArg] )

Returns a boolean indicating whether at least one element passes a test.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function predicate( v ) {
    return ( real( v ) === imag( v ) );
}

var arr = new Complex128Array( 3 );

// Set the first three elements:
arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, 2.0 ], 1 );
arr.set( [ 3.0, -3.0 ], 2 );

// Check whether at least one element passes a test:
var bool = arr.some( predicate );
// returns true

The predicate function is provided three arguments:

• value: current array element.
• index: current array element index.
• arr: the array on which this method was called.

To set the function execution context, provide a thisArg.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

function predicate( v, i ) {
    this.count += 1;
    return ( imag( v ) === real( v ) );
}

var arr = new Complex128Array( 3 );

var context = {
    'count': 0
};

// Set the first three elements:
arr.set( [ 1.0, -1.0 ], 0 );
arr.set( [ 2.0, 2.0 ], 1 );
arr.set( [ 3.0, -3.0 ], 2 );

var bool = arr.some( predicate, context );
// returns true

var count = context.count;
// returns 2

Complex128Array.prototype.subarray( [begin[, end]] )

Creates a new typed array view over the same underlying ArrayBuffer and with the same underlying data type as the host array.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var arr = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );

var subarr = arr.subarray();
// returns <Complex128Array>

var len = subarr.length;
// returns 4

var z = subarr.get( 0 );
// returns <Complex128>

var re = real( z );
// returns 1.0

var im = imag( z );
// returns 2.0

z = subarr.get( len-1 );
// returns <Complex128>

re = real( z );
// returns 7.0

im = imag( z );
// returns 8.0

By default, the method creates a typed array view beginning with the first array element. To specify an alternative array index at which to begin, provide a begin index (inclusive).

var imag = require( '@stdlib/complex/imag' );
var real = require( '@stdlib/complex/real' );

var arr = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );

var subarr = arr.subarray( 1 );
// returns <Complex128Array>

var len = subarr.length;
// returns 3

var z = subarr.get( 0 );
// returns <Complex128>

var re = real( z );
// returns 3.0

var im = imag( z );
// returns 4.0

By default, the method creates a typed array view which includes all array elements after begin. To limit the number of array elements after begin, provide an end index (exclusive).

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var arr = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );

var subarr = arr.subarray( 1, -1 );
// returns <Complex128Array>

var len = subarr.length;
// returns 2

var z = subarr.get( 0 );
// returns <Complex128>

var re = real( z );
// returns 3.0

var im = imag( z );
// returns 4.0

z = subarr.get( len-1 );
// returns <Complex128>

re = real( z );
// returns 5.0

im = imag( z );
// returns 6.0

Complex128Array.prototype.toReversed()

Returns a new typed array containing the elements in reversed order.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );

var arr = new Complex128Array( 3 );

arr.set( [ 1.0, 1.0 ], 0 );
arr.set( [ 2.0, 2.0 ], 1 );
arr.set( [ 3.0, 3.0 ], 2 );

var out = arr.toReversed();
// returns <Complex128Array>

var z = out.get( 0 );
// returns <Complex128>

var re = real( z );
// returns 3.0

var im = imag( z );
// returns 3.0

z = out.get( 1 );
// returns <Complex128>

re = real( z );
// returns 2.0

im = imag( z );
// returns 2.0

z = out.get( 2 );
// returns <Complex128>

re = real( z );
// returns 1.0

im = imag( z );
// returns 1.0

Complex128Array.prototype.toString()

Serializes an array as a string.

var arr = new Complex128Array( 3 );

arr.set( [ 1.0, 1.0 ], 0 );
arr.set( [ 2.0, -2.0 ], 1 );
arr.set( [ 3.0, 3.0 ], 2 );

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

Complex128Array.prototype.with( index, value )

Returns a new typed array with the element at a provided index replaced with a provided value.

var real = require( '@stdlib/complex/real' );
var imag = require( '@stdlib/complex/imag' );
var Complex128 = require( '@stdlib/complex/float64' );

var arr = new Complex128Array( 3 );

arr.set( [ 1.0, 1.0 ], 0 );
arr.set( [ 2.0, 2.0 ], 1 );
arr.set( [ 3.0, 3.0 ], 1 );

var out = arr.with( 0, new Complex128( 4.0, 4.0 ) );
// returns <Complex128Array>

var z = out.get( 0 );
// returns <Complex128>

var re = real( z );
// returns 4.0

var im = imag( z );
// returns 4.0

---

Notes

• While a Complex128Array strives to maintain (but does not guarantee) consistency with typed arrays, significant deviations from ECMAScript-defined typed array behavior are as follows:

  • The constructor does not require the new operator.
  • The constructor and associated methods support a broader variety of input argument types in order to better accommodate complex number input.
  • Accessing array elements using bracket syntax (e.g., Z[i]) is not supported. Instead, one must use the .get() method which returns a value compatible with complex number output.
  • The set method has extended behavior in order to support complex numbers.

---

Examples

var Complex128 = require( '@stdlib/complex/float64' );
var Float64Array = require( '@stdlib/array/float64' );
var logEach = require( '@stdlib/console/log-each' );
var Complex128Array = require( '@stdlib/array/complex128' );

// Create a complex array by specifying a length:
var out = new Complex128Array( 3 );
logEach( '%s', out );

// Create a complex array from an array of complex numbers:
var arr = [
    new Complex128( 1.0, -1.0 ),
    new Complex128( -3.14, 3.14 ),
    new Complex128( 0.5, 0.5 )
];
out = new Complex128Array( arr );
logEach( '%s', out );

// Create a complex array from an interleaved typed array:
arr = new Float64Array( [ 1.0, -1.0, -3.14, 3.14, 0.5, 0.5 ] );
out = new Complex128Array( arr );
logEach( '%s', out );

// Create a complex array from an array buffer:
arr = new Float64Array( [ 1.0, -1.0, -3.14, 3.14, 0.5, 0.5 ] );
out = new Complex128Array( arr.buffer );
logEach( '%s', out );

// Create a complex array from an array buffer view:
arr = new Float64Array( [ 1.0, -1.0, -3.14, 3.14, 0.5, 0.5 ] );
out = new Complex128Array( arr.buffer, 16, 2 );
logEach( '%s', out );

---

See Also

• @stdlib/array/complex64: Complex64Array.
• @stdlib/complex/cmplx: create a complex number.
• @stdlib/complex/float64: 128-bit complex number.