Usage

`javascript
var csrot = require( '@stdlib/blas-base-wasm-csrot' );
`

#### csrot.main( N, cx, strideX, cy, strideY, c, s )

Applies a plane rotation.

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

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

csrot.main( cx.length, cx, 1, cy, 1, 0.8, 0.6 );
// cx => [ ~0.8, ~1.6, ~2.4, ~3.2, 4.0, ~4.8, ~5.6, ~6.4 ]
// cy => [ ~-0.6, ~-1.2, ~-1.8, ~-2.4, -3.0, ~-3.6, ~-4.2, ~-4.8 ]
`

The function has the following parameters:

- N: number of indexed elements.
- cx: first input [Complex64Array][@stdlib/array/complex64].
- strideX: index increment for cx.
- cy: second input [Complex64Array][@stdlib/array/complex64].
- strideY: index increment for cy.
- c: cosine of the angle of rotation.
- s: sine of the angle of rotation.

The N and stride parameters determine how values in the strided arrays are accessed at runtime. For example, to apply a plane rotation to every other element,

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

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

csrot.main( 2, cx, 2, cy, 2, 0.8, 0.6 );
// cx => [ ~0.8, ~1.6, 3.0, 4.0, 4.0, ~4.8, 7.0, 8.0 ]
// cy => [ ~-0.6, ~-1.2, 0.0, 0.0, -3.0, ~-3.6, 0.0, 0.0 ]
`

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

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

// Initial arrays...
var cx0 = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
var cy0 = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );

// Create offset views...
var cx1 = new Complex64Array( cx0.buffer, cx0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
var cy1 = new Complex64Array( cy0.buffer, cy0.BYTES_PER_ELEMENT*2 ); // start at 3rd element

csrot.main( 2, cx1, -2, cy1, 1, 0.8, 0.6 );
// cx0 => [ 1.0, 2.0, ~2.4, ~3.2, 5.0, 6.0, ~5.6, ~6.4 ]
// cy0 => [ 0.0, 0.0, 0.0, 0.0, ~-4.2, ~-4.8, ~-1.8, ~-2.4 ]
`

#### csrot.ndarray( N, cx, strideX, offsetX, cy, strideY, offsetY, c, s )

Applies a plane rotation using alternative indexing semantics.

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

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

csrot.ndarray( cx.length, cx, 1, 0, cy, 1, 0, 0.8, 0.6 );
// cx => [ ~0.8, ~1.6, ~2.4, ~3.2, 4.0, ~4.8 ]
// cy => [ ~-0.6, ~-1.2, ~-1.8, ~-2.4, -3.0, ~-3.6 ]
`

The function has the following additional parameters:

- offsetX: starting index for cx.
- offsetY: starting index for cy.

While [typed array][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example, to apply a plane rotation to every other element starting from the second element,

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

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

csrot.ndarray( 2, cx, 2, 1, cy, 2, 1, 0.8, 0.6 );
// cx => [ 1.0, 2.0, ~2.4, ~3.2, 5.0, 6.0, ~5.6, ~6.4 ]
// cy => [ 0.0, 0.0, ~-1.8, ~-2.4, 0.0, 0.0, ~-4.2, ~-4.8 ]
`

*

$3

#### csrot.Module( memory )

Returns a new WebAssembly [module wrapper][@stdlib/wasm/module-wrapper] instance which uses the provided WebAssembly [memory][@stdlib/wasm/memory] instance as its underlying memory.

`javascript
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 csrot.Module( mem );
// returns

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

#### csrot.Module.prototype.main( N, cxp, sx, cyp, sy, c, s )

Applies a plane rotation.

`javascript
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' );
var Complex64Array = require( '@stdlib/array-complex64' );
var reinterpretComplex64 = require( '@stdlib/strided-base-reinterpret-complex64' );
var csrot = require( '@stdlib/blas-base-wasm-csrot' );

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

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

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

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

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

// Define pointers (i.e., byte offsets) for storing the input vectors:
var cxptr = 0;
var cyptr = N * bytesPerElement( dtype );

// Write vector values to module memory:
var xbuf = oneTo( N*2, 'float32' );
var cx = new Complex64Array( xbuf.buffer );
mod.write( cxptr, cx );

var ybuf = ones( N*2, 'float32' );
var cy = new Complex64Array( ybuf.buffer );
mod.write( cyptr, cy );

// Perform computation:
mod.main( N, cxptr, 1, cyptr, 1, 0.8, 0.6 );

// Read out the results:
var viewX = zeros( N, dtype );
var viewY = zeros( N, dtype );
mod.read( cxptr, viewX );
mod.read( cyptr, viewY );

console.log( reinterpretComplex64( viewX, 0 ) );
// => [ ~1.4, ~2.2, 3.0, ~3.8, ~4.6, ~5.4, ~6.2, 7.0, ~7.8, ~8.6 ]

console.log( reinterpretComplex64( viewY, 0 ) );
// => [ ~0.2, ~-0.4, -1.0, ~-1.6, ~-2.2, ~-2.8, ~-3.4, -4.0, ~-4.6, ~-5.2 ]
`

The function has the following parameters:

- N: number of indexed elements.
- cxp: first input [Complex64Array][@stdlib/array/complex64] pointer (i.e., byte offset).
- sx: index increment for cx.
- cyp: second input [Complex64Array][@stdlib/array/complex64] pointer (i.e., byte offset).
- sy: index increment for cy.
- c: cosine of the angle of rotation.
- s: sine of the angle of rotation.

#### csrot.Module.prototype.ndarray( N, cxp, sx, ox, cyp, sy, oy, c, s )

Applies a plane rotation using alternative indexing semantics.

`javascript
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' );
var Complex64Array = require( '@stdlib/array-complex64' );
var reinterpretComplex64 = require( '@stdlib/strided-base-reinterpret-complex64' );
var csrot = require( '@stdlib/blas-base-wasm-csrot' );

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

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

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

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

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

// Define pointers (i.e., byte offsets) for storing input vectors:
var cxptr = 0;
var cyptr = N * bytesPerElement( dtype );

// Write vector values to module memory:
var xbuf = oneTo( N*2, 'float32' );
var cx = new Complex64Array( xbuf.buffer );
mod.write( cxptr, cx );

var ybuf = ones( N*2, 'float32' );
var cy = new Complex64Array( ybuf.buffer );
mod.write( cyptr, cy );

// Perform computation:
mod.ndarray( N, cxptr, 1, 0, cyptr, 1, 0, 0.8, 0.6 );

// Read out the results:
var viewX = zeros( N, dtype );
var viewY = zeros( N, dtype );
mod.read( cxptr, viewX );
mod.read( cyptr, viewY );

console.log( reinterpretComplex64( viewX, 0 ) );
// => [ ~1.4, ~2.2, 3.0, ~3.8, ~4.6, ~5.4, ~6.2, 7.0, ~7.8, ~8.6 ]

console.log( reinterpretComplex64( viewY, 0 ) );
// => [ ~0.2, ~-0.4, -1.0, ~-1.6, ~-2.2, ~-2.8, ~-3.4, -4.0, ~-4.6, ~-5.2 ]
`

The function has the following additional parameters:

- ox: starting index for cx.
- oy: starting index for cy.