<section class="intro">

</section>

<section class="usage">

var zmap = require( '@stdlib/strided/base/zmap' );

Applies a unary function to a double-precision complex floating-point strided input array and assigns results to a double-precision complex floating-point strided output array.

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

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

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

var cceil = require( '@stdlib/math/base/special/cceil' );

var x = new Complex128Array( [ -2.3, 1.5, 3.1, -5.2, 4.8, 0.0, -1.6, 3.4 ] );

var y = new Complex128Array( x.length );

zmap( x.length, x, 1, y, 1, cceil );

var v = y.get( 0 );

var re = real( v );

var im = imag( v );

The function accepts the following arguments:

- **N**: number of indexed elements.

- **x**: input [`Complex128Array`][@stdlib/array/complex128].

- **strideX**: index increment for `x`.

- **y**: output [`Complex128Array`][@stdlib/array/complex128].

- **strideY**: index increment for `y`.

- **fcn**: function to apply.

The `N` and stride parameters determine which elements in the strided arrays are accessed at runtime. For example, to index every other value in `x` and to index the first `N` elements of `y` in reverse order,

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

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

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

var cceil = require( '@stdlib/math/base/special/cceil' );

var x = new Complex128Array( [ -2.3, 1.5, 3.1, -5.2, 4.8, 0.0, -1.6, 3.4 ] );

var y = new Complex128Array( x.length );

zmap( 2, x, 2, y, -1, cceil );

var v = y.get( 0 );

var re = real( v );

var im = imag( v );

Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][@stdlib/array/complex128] views.

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

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

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

var cceil = require( '@stdlib/math/base/special/cceil' );

var x0 = new Complex128Array( [ -2.3, 1.5, 3.1, -5.2, 4.8, 0.0, -1.6, 3.4 ] );

var y0 = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );

var x1 = new Complex128Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element

var y1 = new Complex128Array( y0.buffer, y0.BYTES_PER_ELEMENT*2 ); // start at 3rd element

zmap( 2, x1, -2, y1, 1, cceil );

var v = y.get( 0 );

var re = real( v );

var im = imag( v );

Applies a unary function to a double-precision complex floating-point strided input array and assigns results to a double-precision complex floating-point strided output array using alternative indexing semantics.

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

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

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

var cceil = require( '@stdlib/math/base/special/cceil' );

var x = new Complex128Array( [ -2.3, 1.5, 3.1, -5.2, 4.8, 0.0, -1.6, 3.4 ] );

var y = new Complex128Array( x.length );

zmap.ndarray( x.length, x, 1, 0, y, 1, 0, cceil );

var v = y.get( 0 );

var re = real( v );

var im = imag( v );

The function accepts the following additional arguments:

- **offsetX**: starting index for `x`.

- **offsetY**: starting index for `y`.

While [`typed array`][@stdlib/array/complex128] views mandate a view offset based on the underlying `buffer`, the offset parameters support indexing semantics based on starting indices. For example, to index every other value in `x` starting from the second value and to index the last `N` elements in `y` in reverse order,

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

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

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

var cceil = require( '@stdlib/math/base/special/cceil' );

var x = new Complex128Array( [ -2.3, 1.5, 3.1, -5.2, 4.8, 0.0, -1.6, 3.4 ] );

var y = new Complex128Array( x.length );

zmap.ndarray( 2, x, 2, 1, y, -1, y.length-1, cceil );

var v = y.get( y.length-1 );

var re = real( v );

var im = imag( v );

</section>

<section class="notes">

</section>

<section class="examples">

var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ).factory;

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

var filledarrayBy = require( '@stdlib/array/filled-by' );

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

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

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

var zmap = require( '@stdlib/strided/base/zmap' );

function scale( x ) {

var re = real( x );

var im = imag( x );

return new Complex128( re*10.0, im*10.0 );

}

var xbuf = filledarrayBy( 10*2, 'float64', discreteUniform( -100.0, 100.0 ) );

var x = new Complex128Array( xbuf.buffer );

console.log( x );

var y = new Complex128Array( x.length );

console.log( y );

zmap.ndarray( x.length, x, 1, 0, y, -1, y.length-1, scale );

console.log( y );

</section>

<section class="c">

<section class="intro">

</section>

<section class="usage">

#include "stdlib/strided/base/zmap.h"

Applies a unary function to a double-precision complex floating-point strided input array and assigns results to a double-precision complex floating-point strided output array.

#include <stdint.h>

#include <complex.h>

static double complex scale( const double complex x ) {

double re = creal( x );

double im = cimag( x );

return ( re+10.0 ) + ( im+10.0 )*I;

}

double complex X[] = { 1.0+1.0*I, 2.0+2.0*I, 3.0+3.0*I, 4.0+4.0*I, 5.0+5.0*I, 6.0+6.0*I };

double complex Y[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };

int64_t N = 6;

stdlib_strided_zmap( N, X, 1, Y, 1, scale );

</section>

<section class="notes">

</section>

<section class="examples">

#include "stdlib/strided/base/zmap.h"

#include <stdint.h>

#include <stdio.h>

#include <inttypes.h>

#include <complex.h>

static double complex scale( const double complex x ) {

double re = creal( x );

double im = cimag( x );

return ( re+10.0 ) + ( im+10.0 )*I;

}

int main() {

// Create an input strided array:

double complex X[] = { 1.0+1.0*I, 2.0+2.0*I, 3.0+3.0*I, 4.0+4.0*I, 5.0+5.0*I, 6.0+6.0*I };

// Create an output strided array:

double complex Y[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };

// Specify the number of elements:

int64_t N = 6;

// Define the strides:

int64_t strideX = 1;

int64_t strideY = -1;

// Apply the callback:

stdlib_strided_zmap( N, X, strideX, Y, strideY, scale );

// Print the results:

for ( int64_t i = 0; i < N; i++ ) {

printf( "Y[ %"PRId64" ] = %lf + %lfi\n", i, creal( Y[i] ), cimag( Y[i] ) );

}

}