Complex128

128-bit complex number.

Usage

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

Complex128( real, imag )

128-bit complex number constructor, where real and imag are the real and imaginary components, respectively.

var z = new Complex128( 5.0, 3.0 );
// returns <Complex128>

Properties

Complex128.BYTES_PER_ELEMENT

Size (in bytes) of each component.

var nbytes = Complex128.BYTES_PER_ELEMENT;
// returns 8

Complex128.prototype.BYTES_PER_ELEMENT

Size (in bytes) of each component.

var z = new Complex128( 5.0, 3.0 );

var nbytes = z.BYTES_PER_ELEMENT;
// returns 8

Complex128.prototype.byteLength

Length (in bytes) of a complex number.

var z = new Complex128( 5.0, 3.0 );

var nbytes = z.byteLength;
// returns 16

Instance

A Complex128 instance has the following properties...

re

A read-only property returning the real component.

var z = new Complex128( 5.0, 3.0 );

var re = z.re;
// returns 5.0

im

A read-only property returning the imaginary component.

var z = new Complex128( 5.0, -3.0 );

var im = z.im;
// returns -3.0

Methods

Accessor Methods

These methods do not mutate a Complex128 instance and, instead, return a complex number representation.

Complex128.prototype.toString()

Returns a string representation of a Complex128 instance.

var z = new Complex128( 5.0, 3.0 );
var str = z.toString();
// returns '5 + 3i'

z = new Complex128( -5.0, -3.0 );
str = z.toString();
// returns '-5 - 3i'

Complex128.prototype.toJSON()

Returns a JSON representation of a Complex128 instance. JSON.stringify() implicitly calls this method when stringifying a Complex128 instance.

var z = new Complex128( 5.0, -3.0 );

var o = z.toJSON();
/*
  {
    "type": "Complex128",
    "re": 5.0,
    "im": -3.0
  }
*/

To revive a Complex128 number from a JSON string, see @stdlib/complex/reviver-float64.

Notes

  • Both the real and imaginary components are stored as double-precision floating-point numbers.

Examples

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

var z = new Complex128( 3.0, -2.0 );

console.log( 'type: %s', typeof z );
// => 'type: object'

console.log( 'str: %s', z );
// => 'str: 3 - 2i'

console.log( 'real: %d', z.re );
// => 'real: 3'

console.log( 'imag: %d', z.im );
// => 'imag: -2'

console.log( 'JSON: %s', JSON.stringify( z ) );
// => 'JSON: {"type":"Complex128","re":3,"im":-2}'

C APIs

Usage

#include "stdlib/complex/float64.h"

stdlib_complex128_t

An opaque type definition for a double-precision complex floating-point number.

stdlib_complex128_t z = stdlib_complex128( 5.0, 2.0 );

stdlib_complex128_parts_t

An opaque type definition for a union for accessing the real and imaginary parts of a double-precision complex floating-point number.

double real( const stdlib_complex128_t z ) {
    stdlib_complex128_parts_t v;

    // Assign a double-precision complex floating-point number:
    v.value = z;

    // Extract the real component:
    double re = v.parts[ 0 ];

    return re;
}

// ...

// Create a complex number:
stdlib_complex128_t z = stdlib_complex128( 5.0, 2.0 );

// ...

// Access the real component:
double re = real( z );
// returns 5.0

The union has the following members:

  • value: stdlib_complex128_t double-precision complex floating-point number.

  • parts: double[] array having the following elements:

    • 0: double real component.
    • 1: double imaginary component.

stdlib_complex128( real, imag )

Returns a double-precision complex floating-point number.

stdlib_complex128_t z = stdlib_complex128( 5.0, 2.0 );

The function accepts the following arguments:

  • real: [in] double real component.
  • imag: [in] double imaginary component.
stdlib_complex128_t stdlib_complex128( const double real, const double imag );

stdlib_complex128_from_float32( real )

Converts a single-precision floating-point number to a double-precision complex floating-point number.

stdlib_complex128_t z = stdlib_complex128_from_float32( 5.0f );

The function accepts the following arguments:

  • real: [in] float real component.
stdlib_complex128_t stdlib_complex128_from_float32( const float real );

stdlib_complex128_from_float64( real )

Converts a double-precision floating-point number to a double-precision complex floating-point number.

stdlib_complex128_t z = stdlib_complex128_from_float64( 5.0 );

The function accepts the following arguments:

  • real: [in] double real component.
stdlib_complex128_t stdlib_complex128_from_float64( const double real );

stdlib_complex128_from_complex64( z )

Converts a single-precision complex floating-point number to a double-precision complex floating-point number.

#include "stdlib/complex/float32.h"

stdlib_complex64_t z1 = stdlib_complex64( 5.0f, 3.0f );
stdlib_complex128_t z2 = stdlib_complex128_from_complex64( z1 );

The function accepts the following arguments:

  • z: [in] stdlib_complex64_t single-precision complex floating-point number.
stdlib_complex128_t stdlib_complex128_from_complex64( const stdlib_complex64_t z );

stdlib_complex128_from_complex128( z )

Converts (copies) a double-precision complex floating-point number to a double-precision complex floating-point number.

stdlib_complex128_t z1 = stdlib_complex128( 5.0, 3.0 );
stdlib_complex128_t z2 = stdlib_complex128_from_complex128( z1 );

The function accepts the following arguments:

  • z: [in] stdlib_complex128_t double-precision complex floating-point number.
stdlib_complex128_t stdlib_complex128_from_complex128( const stdlib_complex128_t z );

stdlib_complex128_from_int8( real )

Converts a signed 8-bit integer to a double-precision complex floating-point number.

stdlib_complex128_t z = stdlib_complex128_from_int8( 5 );

The function accepts the following arguments:

  • real: [in] int8_t real component.
stdlib_complex128_t stdlib_complex128_from_int8( const int8_t real );

stdlib_complex128_from_uint8( real )

Converts an unsigned 8-bit integer to a double-precision complex floating-point number.

stdlib_complex128_t z = stdlib_complex128_from_uint8( 5 );

The function accepts the following arguments:

  • real: [in] uint8_t real component.
stdlib_complex128_t stdlib_complex128_from_uint8( const uint8_t real );

stdlib_complex128_from_int16( real )

Converts a signed 16-bit integer to a double-precision complex floating-point number.

stdlib_complex128_t z = stdlib_complex128_from_int16( 5 );

The function accepts the following arguments:

  • real: [in] int16_t real component.
stdlib_complex128_t stdlib_complex128_from_int16( const int16_t real );

stdlib_complex128_from_uint16( real )

Converts an unsigned 16-bit integer to a double-precision complex floating-point number.

stdlib_complex128_t z = stdlib_complex128_from_uint16( 5 );

The function accepts the following arguments:

  • real: [in] uint16_t real component.
stdlib_complex128_t stdlib_complex128_from_uint16( const uint16_t real );

stdlib_complex128_from_int32( real )

Converts a signed 32-bit integer to a double-precision complex floating-point number.

stdlib_complex128_t z = stdlib_complex128_from_int32( 5 );

The function accepts the following arguments:

  • real: [in] int32_t real component.
stdlib_complex128_t stdlib_complex128_from_int32( const int32_t real );

stdlib_complex128_from_uint32( real )

Converts an unsigned 32-bit integer to a double-precision complex floating-point number.

stdlib_complex128_t z = stdlib_complex128_from_uint32( 5 );

The function accepts the following arguments:

  • real: [in] uint32_t real component.
stdlib_complex128_t stdlib_complex128_from_uint32( const uint32_t real );

stdlib_complex128_to_complex64( z )

Converts a double-precision complex floating-point number to a single-precision complex floating-point number.

#include "stdlib/complex/float32.h"

stdlib_complex128_t z1 = stdlib_complex128( 5.0, 3.0 );
stdlib_complex64_t z2 = stdlib_complex128_to_complex64( z1 );

The function accepts the following arguments:

  • z: [in] stdlib_complex64_t double-precision complex floating-point number.
stdlib_complex64_t stdlib_complex128_to_complex64( const stdlib_complex128_t z );

Examples

#include "stdlib/complex/float64.h"
#include <stdint.h>
#include <stdio.h>

/**
* Return the real component of a double-precision complex floating-point number.
*
* @param z    complex number
* @return     real component
*/
static double real( const stdlib_complex128_t z ) {
    stdlib_complex128_parts_t v;

    // Assign a double-precision complex floating-point number:
    v.value = z;

    // Extract the real component:
    double re = v.parts[ 0 ];

    return re;
}

/**
* Return the imaginary component of a double-precision complex floating-point number.
*
* @param z    complex number
* @return     imaginary component
*/
static double imag( const stdlib_complex128_t z ) {
    stdlib_complex128_parts_t v;

    // Assign a double-precision complex floating-point number:
    v.value = z;

    // Extract the imaginary component:
    double im = v.parts[ 1 ];

    return im;
}

int main() {
    stdlib_complex128_t x[] = {
        stdlib_complex128( 5.0, 2.0 ),
        stdlib_complex128( -2.0, 1.0 ),
        stdlib_complex128( 0.0, -0.0 ),
        stdlib_complex128( 0.0/0.0, 0.0/0.0 )
    };

    stdlib_complex128_t v;
    int i;
    for ( i = 0; i < 4; i++ ) {
        v = x[ i ];
        printf( "%lf + %lfi\n", real( v ), imag( v ) );
    }
}

See Also

Did you find this page helpful?