zscal

Scales a double-precision complex floating-point vector by a double-precision complex floating-point constant.

Usage

var zscal = require( '@stdlib/blas/base/zscal' );

zscal( N, za, zx, strideX )

Scales values from zx by za.

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

var zx = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
var za = new Complex128( 2.0, 0.0 );

zscal( 3, za, zx, 1 );

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

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

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

The function has the following parameters:

N: number of indexed elements.
za: scalar Complex128 constant.
zx: input Complex128Array.
strideX: index increment for zx.

The N and stride parameters determine how values from zx are scaled by za. For example, to scale every other value in zx by za,

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

var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
var za = new Complex128( 2.0, 0.0 );

zscal( 2, za, zx, 2 );

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

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

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

Note that indexing is relative to the first index. To introduce an offset, use typed array views.

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

// Initial array:
var zx0 = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );

// Define a scalar constant:
var za = new Complex128( 2.0, 2.0 );

// Create an offset view:
var zx1 = new Complex128Array( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 ); // start at 2nd element

// Scales every other value from `zx1` by `za`...
zscal( 3, za, zx1, 1 );

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

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

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

zscal.ndarray( N, za, zx, strideX, offsetX )

Scales values from zx by za using alternative indexing semantics.

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

var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
var za = new Complex128( 2.0, 2.0 );

zscal.ndarray( 3, za, zx, 1, 0 );

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

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

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

The function has the following additional parameters:

offsetX: starting index for zx.

While typed array views mandate a view offset based on the underlying buffer, the offset parameter supports indexing semantics based on a starting index. For example, to scale every other value in the input strided array starting from the second element,

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

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

zscal.ndarray( 2, za, zx, 2, 1 );

var z = zx.get( 3 );
// returns <Complex128>

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

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

Notes

If N <= 0 or strideX <= 0 , both functions return zx unchanged.
zscal() corresponds to the BLAS level 1 function zscal.

Examples

var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
var filledarrayBy = require( '@stdlib/array/filled-by' );
var Complex128 = require( '@stdlib/complex/float64/ctor' );
var zscal = require( '@stdlib/blas/base/zscal' );

function rand() {
    return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) );
}

var zx = filledarrayBy( 10, 'complex128', rand );
console.log( zx.toString() );

var za = new Complex128( 2.0, 2.0 );
console.log( za.toString() );

// Scales elements from `zx` by `za`:
zscal( zx.length, za, zx, 1 );
console.log( zx.get( zx.length-1 ).toString() );

C APIs

Usage

#include "stdlib/blas/base/zscal.h"

c_zscal( N, za, *ZX, strideX )

Scales values from ZX by za.

#include "stdlib/complex/float64/ctor.h"

double zx[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 };
const stdlib_complex128_t za = stdlib_complex128( 2.0, 2.0 );

c_zscal( 4, za, (void *)zx, 1 );

The function accepts the following arguments:

N: [in] CBLAS_INT number of indexed elements.
za: [in] stdlib_complex128_t scalar constant.
ZX: [inout] void* input array.
strideX: [in] CBLAS_INT index increment for ZX.

void c_zscal( const CBLAS_INT N, const stdlib_complex128_t za, void *ZX, const CBLAS_INT strideX );

Examples

#include "stdlib/blas/base/zscal.h"
#include "stdlib/complex/float64/ctor.h"
#include <stdio.h>

int main( void ) {
    // Create a strided array of interleaved real and imaginary components:
    double zx[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 };

    // Create a complex scalar:
    const stdlib_complex128_t ca = stdlib_complex128( 2.0, 2.0 );

    // Specify the number of elements:
    const int N = 4;

    // Specify stride length:
    const int strideX = 1;

    // Scale the elements of the array:
    c_zscal( N, za, (void *)zx, strideX );

    // Print the result:
    for ( int i = 0; i < N; i++ ) {
        printf( "zx[ %i ] = %f + %fj\n", i, zx[ i*2 ], zx[ (i*2)+1 ] );
    }
}