scasum

Compute the sum of the absolute values of the real and imaginary components of a single-precision complex floating-point vector.

Usage

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

scasum( N, cx, strideX )

Computes the sum of the absolute values of the real and imaginary components of a single-precision complex floating-point vector.

var Complex64Array = require( '@stdlib/array/complex64' );

var cx = new Complex64Array( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5, 0.0, 0.2 ] );

var out = scasum( 4, cx, 1 );
// returns ~1.6

The function has the following parameters:

N: number of indexed elements.
cx: input Complex64Array.
strideX: index increment for cx.

The N and stride parameters determine which elements in the strided array are accessed at runtime. For example, to traverse every other value,

var Complex64Array = require( '@stdlib/array/complex64' );

var cx = new Complex64Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] );

var out = scasum( 2, cx, 2 );
// returns 7.0

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

var Complex64Array = require( '@stdlib/array/complex64' );

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

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

// Compute the L2-out:
var out = scasum( 2, cx1, 1 );
// returns 18.0

scasum.ndarray( N, cx, strideX, offset )

Computes the sum of the absolute values of the real and imaginary components of a single-precision complex floating-point vector using alternative indexing semantics.

var Complex64Array = require( '@stdlib/array/complex64' );

var cx = new Complex64Array( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5, 0.0, 0.2 ] );

var out = scasum.ndarray( 4, cx, 1, 0 );
// returns ~1.6

The function has the following additional parameters:

offsetX: starting index.

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 start from the second index,

var Complex64Array = require( '@stdlib/array/complex64' );

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

var out = scasum.ndarray( 2, cx, 1, 1 );
// returns 18.0

Notes

If N <= 0, both functions return 0.0.
scasum() corresponds to the BLAS level 1 function scasum.

Examples

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

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

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

// Compute the sum of the absolute values of real and imaginary components:
var out = scasum( cx.length, cx, 1 );
console.log( out );

C APIs

Usage

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

c_scasum( N, *CX, strideX )

Computes the sum of the absolute values of the real and imaginary components of a single-precision complex floating-point vector.

const float cx[] = { 0.3f, 0.1f, 0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.2f };

float out = c_scasum( 4, (void *)cx, 1 );
// returns 1.6f

The function accepts the following arguments:

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

float c_scasum( const CBLAS_INT N, const void *CX, const CBLAS_INT strideX );

c_scasum_ndarray( N, *CX, strideX, offsetX )

Computes the sum of the absolute values of the real and imaginary components of a single-precision complex floating-point vector using alternative indexing semantics.

const float cx[] = { 0.3f, 0.1f, 0.5f, 0.0f, 0.0f, 0.5f, 0.0f, 0.2f };

float out = c_scasum_ndarray( 4, (void *)cx, 1, 0 );
// returns 1.6f

The function accepts the following arguments:

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

float c_scasum_ndarray( const CBLAS_INT N, const void *CX, const CBLAS_INT strideX, const CBLAS_INT offsetX );

Examples

#include "stdlib/blas/base/scasum.h"
#include <stdio.h>

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

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

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

    // Compute the sum of the absolute values of real and imaginary components:
    float out = c_scasum( N, (void *)cx, strideX );

    // Print the result:
    printf( "out: %f\n", out );

    // Compute the sum of the absolute values of real and imaginary components using alternative indexing semantics:
    out = c_scasum_ndarray( N, (void *)cx, -strideX, N-1 );

    // Print the result:
    printf( "out: %f\n", out );
}