dscal

Usage

var dscal = require( '@stdlib/blas/base/dscal-wasm' );

dscal.main( N, alpha, x, strideX )

Multiplies a vector x by a constant alpha.

var Float64Array = require( '@stdlib/array/float64' );

var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );

dscal.main( x.length, 5.0, x, 1 );
// x => <Float64Array>[ 5.0, 10.0, 15.0, 20.0, 25.0 ]

The function has the following parameters:

• N: number of indexed elements.
• alpha: scalar constant.
• x: input Float64Array.
• strideX: index increment for x.

The N and stride parameters determine which elements in the input strided array are accessed at runtime. For example, to multiply every other value in x by alpha in reverse order,

var Float64Array = require( '@stdlib/array/float64' );

var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );

dscal.main( 5, 5.0, x, -1 );
// x => <Float64Array>[ 5.0, 10.0, 15.0, 20.0, 25.0 ]

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

var Float64Array = require( '@stdlib/array/float64' );

// Initial array:
var x0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );

// Create a typed array view:
var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element

dscal.main( 3, 5.0, x1, -2 );
// x0 => <Float64Array>[ 1.0, 10.0, 3.0, 20.0, 5.0, 30.0 ]

dscal.ndarray( N, alpha, x, strideX, offsetX )

Multiplies a vector x by a constant alpha using alternative indexing semantics.

var Float64Array = require( '@stdlib/array/float64' );

var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );

dscal.ndarray( x.length, 5.0, x, 1, 0 );
// x => <Float64Array>[ 5.0, 10.0, 15.0, 20.0, 25.0 ]

The function has the following additional parameters:

• offsetX: starting index for x.

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 multiply every other value in x by a constant alpha starting from the second element,

var Float64Array = require( '@stdlib/array/float64' );

var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );

dscal.ndarray( 3, 5.0, x, 2, 1 );
// x => <Float64Array>[ 1.0, 10.0, 3.0, 20.0, 5.0, 30.0 ]

Module

dscal.Module( memory )

Returns a new WebAssembly module wrapper instance which uses the provided WebAssembly memory instance as its underlying memory.

var Memory = require( '@stdlib/wasm/memory' );

// Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
var mem = new Memory({
    'initial': 10,
    'maximum': 100
});

// Create a BLAS routine:
var mod = new dscal.Module( mem );
// returns <Module>

// Initialize the routine:
mod.initializeSync();

dscal.Module.prototype.main( N, α, xp, sx )

Multiplies a vector x by a constant α.

var Memory = require( '@stdlib/wasm/memory' );
var oneTo = require( '@stdlib/array/one-to' );
var ones = require( '@stdlib/array/ones' );
var zeros = require( '@stdlib/array/zeros' );
var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' );

// Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
var mem = new Memory({
    'initial': 10,
    'maximum': 100
});

// Create a BLAS routine:
var mod = new dscal.Module( mem );
// returns <Module>

// Initialize the routine:
mod.initializeSync();

// Define a vector data type:
var dtype = 'float64';

// Specify a vector length:
var N = 5;

// Define a pointer (i.e., byte offset) for storing the input vector:
var xptr = 0;

// Write vector values to module memory:
mod.write( xptr, oneTo( N, dtype ) );

// Perform computation:
mod.main( N, 5.0, xptr, 1 );

// Read out the results:
var view = zeros( N, dtype );
mod.read( xptr, view );

console.log( view );
// => <Float64Array>[ 5.0, 10.0, 15.0, 20.0, 25.0 ]

The function has the following parameters:

• N: number of indexed elements.
• α: scalar constant.
• xp: input Float64Array pointer (i.e., byte offset).
• sx: index increment for x.

dscal.Module.prototype.ndarray( N, α, xp, sx, ox )

Multiplies a vector x by a constant α using alternative indexing semantics.

var Memory = require( '@stdlib/wasm/memory' );
var oneTo = require( '@stdlib/array/one-to' );
var ones = require( '@stdlib/array/ones' );
var zeros = require( '@stdlib/array/zeros' );
var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' );

// Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
var mem = new Memory({
    'initial': 10,
    'maximum': 100
});

// Create a BLAS routine:
var mod = new dscal.Module( mem );
// returns <Module>

// Initialize the routine:
mod.initializeSync();

// Define a vector data type:
var dtype = 'float64';

// Specify a vector length:
var N = 5;

// Define a pointer (i.e., byte offset) for storing the input vector:
var xptr = 0;

// Write vector values to module memory:
mod.write( xptr, oneTo( N, dtype ) );

// Perform computation:
mod.ndarray( N, 5.0, xptr, 1, 0 );

// Read out the results:
var view = zeros( N, dtype );
mod.read( xptr, view );

console.log( view );
// => <Float64Array>[ 5.0, 10.0, 15.0, 20.0, 25.0 ]

The function has the following additional parameters:

• ox: starting index for x.