Scale a double-precision complex floating-point vector by a double-precision floating-point constant.
var zdscal = require( '@stdlib/blas/base/zdscal' );
Scales a double-precision complex floating-point vector by a double-precision floating-point constant.
var Complex128Array = require( '@stdlib/array/complex128' );
var zx = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
zdscal( 3, 2.0, zx, 1 );
// zx => <Complex128Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
The function has the following parameters:
- N: number of indexed elements.
- da: scalar constant.
- zx: input
Complex128Array
. - strideZX: stride length for
zx
.
The N
and stride parameters determine which elements in zx
are scaled by da
. For example, to scale every other element in zx
by da
,
var Complex128Array = require( '@stdlib/array/complex128' );
var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
zdscal( 2, 2.0, zx, 2 );
// zx => <Complex128Array>[ 2.0, 4.0, 3.0, 4.0, 10.0, 12.0, 7.0, 8.0 ]
Note that indexing is relative to the first index. To introduce an offset, use typed array
views.
var Complex128Array = require( '@stdlib/array/complex128' );
// Initial array:
var zx0 = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
// Create an offset view:
var zx1 = new Complex128Array( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
// Scale every element in `zx1`:
zdscal( 3, 2.0, zx1, 1 );
// zx0 => <Complex128Array>[ 1.0, 2.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0 ]
Scales a double-precision complex floating-point vector by a double-precision floating-point constant using alternative indexing semantics.
var Complex128Array = require( '@stdlib/array/complex128' );
var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
zdscal.ndarray( 3, 2.0, zx, 1, 0 );
// zx => <Complex128Array>[ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
The function has the following additional parameters:
- offsetZX: 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 element in the input strided array starting from the second element,
var Complex128Array = require( '@stdlib/array/complex128' );
var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
zdscal.ndarray( 2, 2.0, zx, 2, 1 );
// zx => <Complex128Array>[ 1.0, 2.0, 6.0, 8.0, 5.0, 6.0, 14.0, 16.0 ]
var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
var filledarrayBy = require( '@stdlib/array/filled-by' );
var Complex128 = require( '@stdlib/complex/float64/ctor' );
var zdscal = require( '@stdlib/blas/base/zdscal' );
function rand() {
return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) );
}
var zx = filledarrayBy( 10, 'complex128', rand );
console.log( zx.toString() );
zdscal( zx.length, 2.0, zx, 1 );
console.log( zx.toString() );
#include "stdlib/blas/base/zdscal.h"
Scales a double-precision complex floating-point vector by a double-precision floating-point constant.
#include "stdlib/complex/float64/ctor.h"
stdlib_complex128_t x[] = { stdlib_complex128( 1.0, 2.0 ), stdlib_complex128( 3.0, 4.0 ), stdlib_complex128( 5.0, 6.0 ) }; // interleaved real and imaginary components
c_zdscal( 3, 2.0, x, 1 );
The function accepts the following arguments:
- N:
[in] CBLAS_INT
number of indexed elements. - alpha:
[in] double
constant. - x:
[inout] stdlib_complex128_t*
input array. - strideX:
[in] CBLAS_INT
index increment forx
.
void c_zdscal( const CBLAS_INT N, const double alpha, stdlib_complex128_t *X, const CBLAS_INT strideX );
Scales a double-precision complex floating-point vector by a double-precision floating-point constant using alternative indexing semantics.
stdlib_complex128_t x[] = { stdlib_complex128( 1.0, 2.0 ), stdlib_complex128( 3.0, 4.0 ), stdlib_complex128( 5.0, 6.0 ) }; // interleaved real and imaginary components
c_zdscal_ndarray( 3, 2.0, x, 1, 0 );
The function accepts the following arguments:
- N:
[in] CBLAS_INT
number of indexed elements. - alpha:
[in] double
constant. - x:
[inout] void*
input array. - strideX:
[in] CBLAS_INT
index increment forx
. - offsetX:
[in] CBLAS_INT
starting index forx
.
void c_zdscal_ndarray( const CBLAS_INT N, const double alpha, stdlib_complex128_t *X, const CBLAS_INT strideX, const CBLAS_INT offsetX );
#include "stdlib/blas/base/zdscal.h"
#include "stdlib/complex/float64/ctor.h"
#include "stdlib/complex/float64/real.h"
#include "stdlib/complex/float64/imag.h"
#include <stdio.h>
int main( void ) {
// Create strided arrays:
stdlib_complex128_t x[] = { stdlib_complex128( 1.0, 2.0 ), stdlib_complex128( 3.0, 4.0 ), stdlib_complex128( 5.0, 6.0 ), stdlib_complex128( 7.0, 8.0 ) };
// Specify the number of elements:
const int N = 4;
// Specify stride lengths:
const int strideX = 1;
c_zdscal( N, 2.0, (void *)x, strideX );
// Print the result:
for ( int i = 0; i < N; i++ ) {
printf( "x[ %i ] = %lf + %lfj\n", i, stdlib_complex128_real( x[ i ] ), stdlib_complex128_imag( x[ i ] ) );
}
c_zdscal_ndarray( N, 2.0, (void *)x, strideX, 0 );
// Print the result:
for ( int i = 0; i < N; i++ ) {
printf( "x[ %i ] = %lf + %lfj\n", i, stdlib_complex128_real( x[ i ] ), stdlib_complex128_imag( x[ i ] ) );
}
}