cscal

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

Usage

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

cscal( N, ca, cx, strideX )

Scales values from cx by ca.

var Complex64Array = require( '@stdlib/array/complex64' );
var Complex64 = require( '@stdlib/complex/float32/ctor' );
var realf = require( '@stdlib/complex/float32/real' );
var imagf = require( '@stdlib/complex/float32/imag' );

var cx = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
var ca = new Complex64( 2.0, 0.0 );

cscal( 3, ca, cx, 1 );

var z = cx.get( 0 );
// returns <Complex64>

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

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

The function has the following parameters:

N: number of indexed elements.
ca: scalar Complex64 constant.
cx: input Complex64Array.
strideX: index increment for cx.

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

var Complex64Array = require( '@stdlib/array/complex64' );
var Complex64 = require( '@stdlib/complex/float32/ctor' );
var realf = require( '@stdlib/complex/float32/real' );
var imagf = require( '@stdlib/complex/float32/imag' );

var cx = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
var ca = new Complex64( 2.0, 0.0 );

cscal( 2, ca, cx, 2 );

var z = cx.get( 2 );
// returns <Complex64>

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

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

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

var Complex64Array = require( '@stdlib/array/complex64' );
var Complex64 = require( '@stdlib/complex/float32/ctor' );
var realf = require( '@stdlib/complex/float32/real' );
var imagf = require( '@stdlib/complex/float32/imag' );

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

// Define a scalar constant:
var ca = new Complex64( 2.0, 2.0 );

// Create an offset view:
var cx1 = new Complex64Array( cx0.buffer, cx0.BYTES_PER_ELEMENT*1 ); // start at 2nd element

// Scales every other value from `cx1` by `ca`...
cscal( 3, ca, cx1, 1 );

var z = cx0.get( 1 );
// returns <Complex64>

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

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

cscal.ndarray( N, ca, cx, strideX, offsetX )

Scales values from cx by ca using alternative indexing semantics.

var Complex64Array = require( '@stdlib/array/complex64' );
var Complex64 = require( '@stdlib/complex/float32/ctor' );
var realf = require( '@stdlib/complex/float32/real' );
var imagf = require( '@stdlib/complex/float32/imag' );

var cx = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
var ca = new Complex64( 2.0, 2.0 );

cscal.ndarray( 3, ca, cx, 1, 0 );

var z = cx.get( 0 );
// returns <Complex64>

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

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

The function has the following additional parameters:

offsetX: starting index for cx.

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 Complex64Array = require( '@stdlib/array/complex64' );
var Complex64 = require( '@stdlib/complex/float32/ctor' );
var realf = require( '@stdlib/complex/float32/real' );
var imagf = require( '@stdlib/complex/float32/imag' );

var cx = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
var ca = new Complex64( 2.0, 2.0 );

cscal.ndarray( 2, ca, cx, 2, 1 );

var z = cx.get( 3 );
// returns <Complex64>

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

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

Notes

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

Examples

var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
var filledarrayBy = require( '@stdlib/array/filled-by' );
var Complex64 = require( '@stdlib/complex/float32/ctor' );
var cscal = require( '@stdlib/blas/base/cscal' );

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

var cx = filledarrayBy( 10, 'complex64', rand );
console.log( cx.toString() );

var ca = new Complex64( 2.0, 2.0 );
console.log( ca.toString() );

// Scale elements from `cx` by `ca`:
cscal( cx.length, ca, cx, 1 );
console.log( cx.get( cx.length-1 ).toString() );

C APIs

Usage

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

c_cscal( N, ca, *CX, strideX )

Scales values from CX by ca.

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

float cx[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f };
const stdlib_complex64_t ca = stdlib_complex64( 2.0f, 2.0f );

c_cscal( 4, ca, (void *)cx, 1 );

The function accepts the following arguments:

N: [in] CBLAS_INT number of indexed elements.
ca: [in] stdlib_complex64_t scalar constant.
CX: [inout] void* input array.
strideX: [in] CBLAS_INT index increment for CX.

void c_cscal( const CBLAS_INT N, const stdlib_complex64_t ca, void *CX, const CBLAS_INT strideX );

c_cscal_ndarray( N, ca, *CX, strideX, offsetX )

Scales values from CX by ca using alternative indexing semantics.

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

float cx[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f };
const stdlib_complex64_t ca = stdlib_complex64( 2.0f, 2.0f );

c_cscal( 4, ca, (void *)cx, 1, 0 );

The function accepts the following arguments:

N: [in] CBLAS_INT number of indexed elements.
ca: [in] stdlib_complex64_t scalar constant.
CX: [inout] void* input array.
strideX: [in] CBLAS_INT index increment for CX.
offsetX: [in] CBLAS_INT starting index for CX.

void c_cscal_ndarray( const CBLAS_INT N, const stdlib_complex64_t ca, void *CX, const CBLAS_INT strideX, const CBLAS_INT offsetX );

Examples

#include "stdlib/blas/base/cscal.h"
#include "stdlib/complex/float32/ctor.h"
#include <stdio.h>

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

    // Create a complex scalar:
    const stdlib_complex64_t ca = stdlib_complex64( 2.0f, 2.0f );

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

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

    // Scale the elements of the array:
    c_cscal( N, ca, (void *)cx, strideX );

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

    // Scale the elements of the array:
    c_cscal_ndarray( N, ca, (void *)cx, -strideX, 3 );

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