Complex64
64-bit complex number.
Usage
var Complex64 = require( '@stdlib/complex/float32' );
Complex64( real, imag )
64-bit complex number constructor, where real
and imag
are the real and imaginary components, respectively.
var z = new Complex64( 5.0, 3.0 );
// returns <Complex64>
Properties
Complex64.BYTES_PER_ELEMENT
Size (in bytes) of each component.
var nbytes = Complex64.BYTES_PER_ELEMENT;
// returns 4
Complex64.prototype.BYTES_PER_ELEMENT
Size (in bytes) of each component.
var z = new Complex64( 5.0, 3.0 );
var nbytes = z.BYTES_PER_ELEMENT;
// returns 4
Complex64.prototype.byteLength
Length (in bytes) of a complex number.
var z = new Complex64( 5.0, 3.0 );
var nbytes = z.byteLength;
// returns 8
Instance
A Complex64
instance has the following properties...
re
A read-only property returning the real component.
var z = new Complex64( 5.0, 3.0 );
var re = z.re;
// returns 5.0
im
A read-only property returning the imaginary component.
var z = new Complex64( 5.0, -3.0 );
var im = z.im;
// returns -3.0
Methods
Accessor Methods
These methods do not mutate a Complex64
instance and, instead, return a complex number representation.
Complex64.prototype.toString()
Returns a string
representation of a Complex64
instance.
var z = new Complex64( 5.0, 3.0 );
var str = z.toString();
// returns '5 + 3i'
z = new Complex64( -5.0, -3.0 );
str = z.toString();
// returns '-5 - 3i'
Complex64.prototype.toJSON()
Returns a JSON representation of a Complex64
instance. JSON.stringify()
implicitly calls this method when stringifying a Complex64
instance.
var z = new Complex64( 5.0, -3.0 );
var o = z.toJSON();
/*
{
"type": "Complex64",
"re": 5.0,
"im": -3.0
}
*/
To revive a Complex64
number from a JSON string
, see @stdlib/complex/reviver-float32.
Notes
- Both the real and imaginary components are stored as single-precision floating-point numbers.
Examples
var Complex64 = require( '@stdlib/complex/float32' );
var z = new Complex64( 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":"Complex64","re":3,"im":-2}'
C APIs
Usage
#include "stdlib/complex/float32.h"
stdlib_complex64_t
An opaque type definition for a single-precision complex floating-point number.
stdlib_complex64_t z = stdlib_complex64( 5.0f, 2.0f );
stdlib_complex64_parts_t
An opaque type definition for a union for accessing the real and imaginary parts of a single-precision complex floating-point number.
float realf( const stdlib_complex64_t z ) {
stdlib_complex64_parts_t v;
// Assign a single-precision complex floating-point number:
v.value = z;
// Extract the real component:
float re = v.parts[ 0 ];
return re;
}
// ...
// Create a complex number:
stdlib_complex64_t z = stdlib_complex64( 5.0f, 2.0f );
// ...
// Access the real component:
float re = realf( z );
// returns 5.0f
The union has the following members:
value:
stdlib_complex64_t
single-precision complex floating-point number.parts:
float[]
array having the following elements:- 0:
float
real component. - 1:
float
imaginary component.
- 0:
stdlib_complex64( real, imag )
Returns a single-precision complex floating-point number.
stdlib_complex64_t z = stdlib_complex64( 5.0f, 2.0f );
The function accepts the following arguments:
- real:
[in] float
real component. - imag:
[in] float
imaginary component.
stdlib_complex64_t stdlib_complex64( const float real, const float imag );
stdlib_complex64_from_float32( real )
Converts a single-precision floating-point number to a single-precision complex floating-point number.
stdlib_complex64_t z = stdlib_complex64_from_float32( 5.0f );
The function accepts the following arguments:
- real:
[in] float
real component.
stdlib_complex64_t stdlib_complex64_from_float32( const float real );
stdlib_complex64_from_float64( real )
Converts a double-precision floating-point number to a single-precision complex floating-point number.
stdlib_complex64_t z = stdlib_complex64_from_float64( 5.0 );
The function accepts the following arguments:
- real:
[in] double
real component.
stdlib_complex64_t stdlib_complex64_from_float64( const double real );
stdlib_complex64_from_complex64( z )
Converts (copies) a single-precision complex floating-point number to a single-precision complex floating-point number.
stdlib_complex64_t z1 = stdlib_complex64( 5.0f, 3.0f );
stdlib_complex64_t z2 = stdlib_complex64_from_complex64( z1 );
The function accepts the following arguments:
- z:
[in] stdlib_complex64_t
single-precision complex floating-point number.
stdlib_complex64_t stdlib_complex64_from_complex64( const stdlib_complex64_t z );
stdlib_complex64_from_int8( real )
Converts a signed 8-bit integer to a single-precision complex floating-point number.
stdlib_complex64_t z = stdlib_complex64_from_int8( 5 );
The function accepts the following arguments:
- real:
[in] int8_t
real component.
stdlib_complex64_t stdlib_complex64_from_int8( const int8_t real );
stdlib_complex64_from_uint8( real )
Converts an unsigned 8-bit integer to a single-precision complex floating-point number.
stdlib_complex64_t z = stdlib_complex64_from_uint8( 5 );
The function accepts the following arguments:
- real:
[in] uint8_t
real component.
stdlib_complex64_t stdlib_complex64_from_uint8( const uint8_t real );
stdlib_complex64_from_int16( real )
Converts a signed 16-bit integer to a single-precision complex floating-point number.
stdlib_complex64_t z = stdlib_complex64_from_int16( 5 );
The function accepts the following arguments:
- real:
[in] int16_t
real component.
stdlib_complex64_t stdlib_complex64_from_int16( const int16_t real );
stdlib_complex64_from_uint16( real )
Converts an unsigned 16-bit integer to a single-precision complex floating-point number.
stdlib_complex64_t z = stdlib_complex64_from_uint16( 5 );
The function accepts the following arguments:
- real:
[in] uint16_t
real component.
stdlib_complex64_t stdlib_complex64_from_uint16( const uint16_t real );
Examples
#include "stdlib/complex/float32.h"
#include <stdint.h>
#include <stdio.h>
/**
* Return the real component of a single-precision complex floating-point number.
*
* @param z complex number
* @return real component
*/
static float real( const stdlib_complex64_t z ) {
stdlib_complex64_parts_t v;
// Assign a single-precision complex floating-point number:
v.value = z;
// Extract the real component:
float re = v.parts[ 0 ];
return re;
}
/**
* Return the imaginary component of a single-precision complex floating-point number.
*
* @param z complex number
* @return imaginary component
*/
static float imag( const stdlib_complex64_t z ) {
stdlib_complex64_parts_t v;
// Assign a single-precision complex floating-point number:
v.value = z;
// Extract the imaginary component:
float im = v.parts[ 1 ];
return im;
}
int main() {
stdlib_complex64_t x[] = {
stdlib_complex64( 5.0f, 2.0f ),
stdlib_complex64( -2.0f, 1.0f ),
stdlib_complex64( 0.0f, -0.0f ),
stdlib_complex64( 0.0f/0.0f, 0.0f/0.0f )
};
stdlib_complex64_t v;
int i;
for ( i = 0; i < 4; i++ ) {
v = x[ i ];
printf( "%f + %fi\n", real( v ), imag( v ) );
}
}