`typescript
export type fpArray = Float32Array | Float64Array;
`

`typescript
export declare type FortranArr = {
base: number;
r: fpArray;
i?: fpArray;
s: (index: number) => (re?: number, im?: number) => number | Complex;
toArr: () => Complex[] | number[];
};
`

fields:

* base: fortran by default has a 1-value based array. Mimiced by this property.
* r: See decl fpArray. The Real part of complex array.
* i: (optional). See decl fpArray. The Imaginary part of the complex array.
* s: set, get values of the array. Uses FORTRAN style array indexes taking the value of base into account.
* toArr generates an JavaScript array from the r and i (optional) data.

Usage:

`javascript
const blas = require('blasjs');

const { helper: { fortranArrComplex64 } } = blas;

// You can also use the helper "complex" or "muxComplex"
// to generate JS complex arrays
const complexDataArr = [
{ re: 1.8, im: -0.2 },
{ re: 2.3, im: 0.6 }
];

// Create an object that mimics FORTRAN COMPLEX*16 SP(2:3)
// and fill it with above data
const sp = fortranArrComplex64(complexArr)(2);

// fast! normal JS TypedArray access
let re = sp.r[ 2 - sp.base ];
// 1.8

let im = sp.i[ 2 - sp.base ];
// -0.2

// not so fast, but easier syntax
let v = sp.s(2)(); // Terse syntax,
// { re: 1.8, im: -0.2 }

// sets the value at index 3 to complex: 0.11 - i0.9
// and returns the old value: 2.3 + i0.6
let old = sp.s(3)(0.11, -0.9);

sp.toArr();
// [ { re:1.8, im: -0.2 },
// { re:0.11, im: -0.9 } ]
`

_Usage TypeScript:_

`typescript
import {
// pure types
Complex,
fpArray,
FortranArr,
// helper
helper
} from 'blasjs';

const { fortranArrComplex64 } = helper;

const complexArr: Complex[] [
{ re: 1.8, im: -0.2 },
{ re: 2.3, im: 0.6 }
];

// Create an object that mimics FORTRAN COMPLEX*16 SP(2:3)
// and fill it with above data
const sp: FortranArr = fortranArrComplex64(complexArr)(2);

let re = sp.r[ 2 - sp.base ]; //fastest! direct TypedArray access
// 1.8

let im = sp.i[ 2 - sp.base ]; //fastest! direct TypedArray access
// -0.2

// not so fast, but easier syntax
let v = sp.s(2)(); // Terse syntax,
// { re: 1.8, im: -0.2 }

// sets the value at index 3 to complex: 0.11 - i0.9
// and returns the old value: 2.3 + i0.6
let old = sp.s(3)(0.11, -0.9);
// {re: 2.3, im: 0.6 }
`

`typescript
declare type Complex = {
re: number;
im?: number;
}
`

Usage:

`typescript
import { Complex / pure type / } from 'blasjs';

const complexArr: Complex[] [
{ re: 1.8, im: -0.2 },
{ re: 2.3, im: 0.6 }
];
`

`typescript
declare type Matrix = { //Incomplete declaration
.
r: Float64Array|Float32Array;
i: Float64Array|Float32Array;
.
}
`

`fortran
DOUBLE PRECISION A1(4) ! array indexes 1,2,3,4
DOUBLE PRECISION A2(-1:3) ! array indexes -1,0,2,3
DOUBLE PRECISION A3(0:3) ! Javascript like Array with 4 elements
`

This expands to 2-dimensional arrays (matrices).

`fortran
! (default) first index loops from 1 to 4(inclusive), second index loops from 1 to 5(inclusive)
DOUBLE PRECISION A1(4,5)
! first index loops from -2 to 4(inclusive), second index loops from -5 to -7(inclusive)
DOUBLE PRECISION A2(-2:4,-5:-7)
`

The values of the FORTRAN array basis are preserved as rowBase (first index) and colBase (second index).

`typescript
declare type Matrix = { //SHOW PARTIAL TYPE
.
rowBase: number;
colBase: number;
.
}
`

JavaScript doesn't have the notion of typed 2-dimensional arrays. The Matrix objects handles this by mapping 2 dimensional arrays to single 1-dimensional array, by serializing data on a column-first basis.

For example the elements 2x2 Matrix will be mapped in a TypedArray as:

`bash
matrix A =

| a11 a12 |
| a21 a22 |


Stored in TypedArray as

In case of complex values for A, the real part will be stored in r and the imaginary part in i each in the same column-first manner.

`typescript
declare type Matrix = { //SHOW PARTIAL TYPE
.
rowBase: number;
colBase: number;
nrCols: number;
nrRows: number;
.
colOfEx(number): number;
coord(col): (row) => number;
setCol(col: number, rowStart: number, rowEnd: number, value: number): void;
.
}
`

`typescript
declare type Matrix = { // only "slice" is shown
.
slice(rowStart: number, rowEnd: number, colStart: number, colEnd: number): Matrix;
.
}
`

* rowStart: The row in the matrix to begin slicing.
* rowEnd: The last row to include in the slice.
* colStart: The column in the matrix to begin slicing.
* colEnd: The last column to include in the slice.

_See Example_

`typescript
declare type Matrix = { // only "setLower" is shown.
.
setLower(value = 0): Matrix;
.
}
`

_See Example_

`typescript
declare type Matrix = { //only "setUpper" is shown
.
setUpper(value = 0): Matrix;
.
}
`

_See Example_

`typescript
declare type Matrix = { //only "upperBand" is shown
.
upperBand(k = nrRows - 1): Matrix;
.
}
`

The default value for k is the the maximum size possible for the number of super-diagonals: ( nrRows-1 )

_See Example_

`typescript
declare type Matrix = { // Only "lowerBand" is shown
.
lowerBand(k = nrRows-1): Matrix;
.
}
`

The default value for k is the the maximum size possible for the number of sub-diagonals: ( nrRows-1 )

_See Example_

`typescript
declare type Matrix = { // Only "real" is shown
.
real(): Matrix;
.
}
`

_See Example_

`typescript
declare type Matrix = { // Only "imaginary" is shown.
.
imaginary(): Matrix;
.
}
`

_See Example_

`typescript
declare type Matrix = { // Only "packedUpper" is shown.
.
packedUpper(k = nrRows-1): FortranArr;
.
}
`

_See Example_

The default value for k is the the maximum size possible for the number of super-diagonals: ( nrRows-1 )

`typescript
declare type Matrix = { // Only "packedUpper" is shown.
.
packedLower(k = nrRows-1): FortranArr;
.
}
`

_See Example_

The default value for k is the the maximum size possible for the number of sub-diagonals: ( nrRows-1 )

`typescript
declare type Matrix = { // Only "packedUpper" is shown.
.
packedLower(k = nrRows - 1): FortranArr;
.
}
`

The default value for k is the the maximum size possible for the number of sub-diagonals: ( nrRows - 1 )

`typescript
declare type Matrix = { // Only "toArr" is shown.
.
toArr(): number[]|Complex[];
.
}
`

_See Example_

`javascript
const blas = require('../blasjs');
const { fortranMatrixComplex64 } = blas.helper;

// some matrix data 3x3 array aka a_row_column

const a11 = { re: .2, im: -.11 };
const a21 = { re: .1, im: -.2 };
const a31 = { re: .3, im: .9 };
const a12 = { re: .4, im: .5 };
const a22 = { re: .9, im: -.34 };
const a32 = { re: -.2, im: .45 };
const a13 = { re: -.1, im: .89 };
const a23 = { re: .43, im: .23 };
const a33 = { re: .23, im: .56 };

//create Matrix A
const A = fortranMatrixComplex64([
a11, a21, a31, a12, a22, a32, a13, a23, a33
])(3, 3);

// get the second column
const columnj = A.colOfEx(3); // formula: (j - colBase )* nrRows

A.r[A.coord(1, 2)] === a12.re // true

A.slice(1, 2, 2, 3);// creates new matrix with elements from A
/*[
a12 a13
a22 a23
]*/

A.setLower(0); // creates new Matrix object from A
/*[
a11 a12 a13
0 a22 a23
0 0 a33
]*/

A.setUpper(0); //creates new Matrix object from A
/*[
a11 0 0
a21 a22 0
a31 a32 a33
]*/

A.upperBand(1); // banded array storage for BLAS(js)
/*[
0 a12 a23
a11 a22 a33
]*/

A.lowerBand(1); // banded array storage for BLAS(js)
/*[
a11 a22 a33
a21 a32 0
]*/

const Areal = A.real();
// Areal.i is undefined
// Areal.r =
/*[
0.2 0.4 -0.1
0.1 0.9 0.43
0.3 -0.2, 0.23
]*/

const Aimag = A.imaginary();
// imaginary parts are copied to real side in new Matrix
// Aimag.i is undefined
// Aimag.r =
/*[
-0.11 0.5, 0.89
-0.2 -0.34 0.23
0.9 0.45 0.56
]*/

A.packedUpper(1)
/ [ a11 a12 a22 a23 a 33] /

A.packedLower(1)
/ [ a11 a21 a22 a32 a33] /

A.toArr(); // returns JavaScript Array
/*[
{ re: 0.2, im: -0.11 },
{ re: 0.1, im: -0.2 },
{ re: 0.3, im: 0.9 },
{ re: 0.4, im: 0.5 },
{ re: 0.9, im: -0.34 },
{ re: -0.2, im: 0.45 },
{ re: -0.1, im: 0.89 },
{ re: 0.43, im: 0.23 },
{ re: 0.23, im: 0.56 }
]
*/
`

`javascript
const blas = require('blasjs');

const { helper: { arrayrify } } = blas;
const PI = Math.PI;
//
const sin = arrayrify(Math.sin)

sin([PI/3, PI/4, PI/6]); // returns array aswell
// [ 0.866025, 0.7071067811, 0.5 ]

sin(PI/3); // returns scalar
sin( [ PI/3 ] ); // returns scalar
// 0.866025

sin([]) // edge case
// undefined

sin() //
//NaN same as Math.sin()
`

`javascript
const blas = require('blasjs');

const { helper: { complex } } = blas;

const c1 = complex(0.1,0.3);
//c1 = { re: 0.1, im: 0.3 }

const c2 = complex();
//c2 = { re: 0, im: 0 }

const c3 = complex(0.5);
//c3 = { re: 0.5, im:0 }
`

`javascript
const blas = require('blasjs');

const { helper: { each } } = blas;

//Iterates over an object like a map
const curry1 = each( { hello: 'world', ts: new Date() })
curry1( (val, key) => console.log(${val} ':' ${key})))
//world: hello
//2018-05-10T13:57:08.923Z : ts

//Handles array also
each( ['a','b','c','d'])( (v,idx) =>console.log(v,idx, typeof idx))
//a 0 number
//b 1 number
//c 2 number
//d 3 number

//Edge cases
each()(console.log)
//nothing happens

each(null)(console.log)
//nothing happens

each([])(console.log)
//nothing happens
`

`javascript
const blas = require('blasjs');

const { helper: { map } } = blas;

//trivial
map([1,2,3])(v=>v*2);
//[ 2, 4, 6 ]

//key properties
map({ a:'A', b:'B' })( (val, key) => key+'='+val);
//[ 'a=A', 'b=B' ]

map(null)( v => '/'+v);
//[]

map()( v => '/'+v);
//[]

map()()
//[]
`

`javascript
const blas = require('blasjs');

const { helper: { muxCmplx } } = blas;

const reals = [ 0.1, -0.2, 0.3, 0.45 ];
const imaginary = [ 0.1, -0.2, 0.3, 0.45 ];

// normal usage
muxCmplx(reals, imaginary)
/*[ { re: 0.1, im: 0.1 },
{ re: -0.2, im: -0.2 },
{ re: 0.3, im: 0.3 },
{ re: 0.45, im: 0.45 } ]*/

//R recycling rule is used
muxCmplx([1,2], imaginary)
/*^[ { re: 1, im: 0.1 },
{ re: 2, im: -0.2 },
{ re: 1, im: 0.3 },
{ re: 2, im: 0.45 } ]*/

//dont care about imaginary
muxCmplx(reals)
/*[ { re: 0.1, im: undefined },
{ re: -0.2, im: undefined },
{ re: 0.3, im: undefined },
{ re: 0.45, im: undefined } ]*/

muxCmplx() //
// [ { re: undefined, im: undefined } ]

muxCmplx(1) //
// [ { re: 1, im: undefined } ]

//3 specify real and imaginary
muxCmplx(1,-2)//
//[ { re: 1, im: -2 } ]
`

`javascript
const blas = require('blasjs');

const { helper: { numberPrecision } } = blas;

const _4 = numberPrecision(4);

_4(0.123456789);
//0.1235

_4(123456789)
//123500000

//enforce significance over properties
_4( { car: 'Mazda' , aux: { priceUSD: 24.3253E+3, maxWarpSpeed:3.42111E-4 } } );
//{ car: 'Mazda', aux: { priceUSD: 24330, maxWarpSpeed: 0.0003421 } }

_4([0.123456, 0.78901234]);
//[ 0.1235, 0.789 ]
`

`typescript
declare function fortranArrComplex32(
...rest: (number | number[] | Complex | Complex[])[]
): (offset = 1) => FortranArr;
`

Argument list:

* rest: takes as input.
* A single numeric value.
* A single Complex object.
* An array of Complex objects.
* An array of number values.
* offset: the Fortran dimension offset (defaults to 1)

See _Examples_

`typescript
declare function fortranArrComplex64(
...rest: (number | number[] | Complex | Complex[])[]
): (offset = 1) => FortranArr;
`

Argument list:

* rest: takes as input.
* A single numeric value.
* A single Complex object.
* An array of Complex objects.
* An array of number values.
* offset: the Fortran dimension offset (defaults to 1)

`javascript
const blas = require('blasjs');

const { fortranArrComplex64, fortranArrComplex32 } = blas.helper;

const complexDataArr = [
{ re: 1.8, im: -0.2 },
{ re: 2.3, im: 0.6 }
];

const realData = [ 0.1, 2, 0.34, .56 ];

const sp1 = fortranArrComplex32(complexDataArr)();
//sp1.r = [ 1.7999999523162842, 2.299999952316284 ],
//sp1.i = [ -0.20000000298023224, 0.6000000238418579 ],

const sp2 = fortranArrComplex32(realData)();
//sp2.r = [ 0.10000000149011612, 2, 0.3400000035762787, 0.5600000023841858 ]
//sp2.i = undefined

const sp3 = fortranArrComplex32({re:0.2, im:-0.3})();
//[ 0.20000000298023224 ]
//[ -0.30000001192092896 ]

const sp4 = fortranArrComplex32(123)(4);
/*{
base: 4,
r: Float32Array [ 123 ],
i: undefined,
}*/

const sdp1 = fortranArrComplex64(complexDataArr)();
//sp1.r = [ 1.8, 2.3 ],
//sp1.i = [ -0.2, 0.6 ],

const sdp2 = fortranArrComplex64(realData)();
//sp2.r = [ 0.1, 2, 0.34, 0.56 ]
//sp2.i = undefined

const sp3 = fortranArrComplex64({re:0.2, im:-0.3})();
//[ 0.2 ]
//[ -0.3 ]

const sp4 = fortranArrComplex64(123)(4);
/*{
base: 4,
r: Float32Array [ 123 ],
i: undefined,
}*/
`

`typescript
declare function fortranMatrixComplex32(...rest: (Complex | Complex[])[]):
(nrRows: number, nrCols: number, rowBase?: number, colBase?: number) => Matrix
`

Argument list:

* rest: takes as input.
* A single numeric value.
* A single Complex object.
* An array of Complex objects.
* An array of number values.
* nrRows: where nrRows is equal to n in the matrix A(m,n).
* nrCols: where nrCols is equal to m in the matrix A(m,n).
* rowBase: FORTRAN offset for the first dimension (rows) as explained in [Language differences][language-differences].
* rowBase: FORTRAN offset for the second dimension (columns) as explained in [Language differences][language-differences].

See _Examples_

`typescript
declare function fortranMatrixComplex64(...rest: (Complex | Complex[])[]):
(nrRows: number, nrCols: number, rowBase?: number, colBase?: number) => Matrix
`

Argument list:

* rest: takes as input.
* A single numeric value.
* A single Complex object.
* An array of Complex objects.
* An array of number values.
* nrRows: where rnRows is equal to n in the matrix A(m,n).
* nrCols: where nrCols is equal to m in the matrix A(m,n).
* rowBase: FORTRAN offset for the first dimension (rows) as explained in [Language differences][language-differences].
* rowBase: FORTRAN offset for the second dimension (columns) as explained in [Language differences][language-differences].

`javascript
const blas = require('blasjs');
const {
fortranMatrixComplex64,
fortranMatrixComplex32
} = blas.helper;

// some matrix data 3x3 array aka a_row_column

const a11 = { re: .2, im: -.11 };
const a21 = { re: .1, im: -.2 };
const a31 = { re: .3, im: .9 };
const a12 = { re: .4, im: .5 };
const a22 = { re: .9, im: -.34 };
const a32 = { re: -.2, im: .45 };
const a13 = { re: -.1, im: .89 };
const a23 = { re: .43, im: .23 };
const a33 = { re: .23, im: .56 };

const {
fortranMatrixComplex64,
fortranMatrixComplex32
} = blas.helper;

// Some matrix data 3x3 array aka a_row_column

const a11 = { re: .2, im: -.11 };
const a21 = { re: .1, im: -.2 };
const a31 = { re: .3, im: .9 };
const a12 = { re: .4, im: .5 };
const a22 = { re: .9, im: -.34 };
const a32 = { re: -.2, im: .45 };
const a13 = { re: -.1, im: .89 };
const a23 = { re: .43, im: .23 };
const a33 = { re: .23, im: .56 };

//functional curry to prepare for different mappings of A()
const A32 = fortranMatrixComplex64([
a11, a21, a31, a12, a22, a32, a13, a23, a33
]);

//matrix 1
const m1 = A32(3, 3); // 3x3 matrix with rowBase=1, colBase=1

// mimic FORTRAN "COMPLEX*8 A(-2:1, -3:0)"
const m2 = A32(3, 3, -2, -3);

//same as FORTRAN default COMPLEX*8 A(3,3) !aka A(1:3,1:3)
const m3 = A32(3, 3, 1, 1)

/ double precision /
/ double precision /
/ double precision /

const A64 = fortranMatrixComplex64([
a11, a21, a31, a12, a22, a32, a13, a23, a33
]);

// matrix 1 FORTRAN "COMPLEX*16 A(-2:1, -3:0).
const m1 = A64(3, 3); // 3x3 matrix with rowBase=1, colBase=1

// mimic FORTRAN "COMPLEX*16 A(-2:1, -3:0)"
const m2 = A64(3, 3, -2, -3);

// same as FORTRAN default COMPLEX*16 A(3,3) !aka A(1:3,1:3)
const m3 = A64(3, 3, 1, 1);
`

`typescript
function scnrm2(n: number, x: FortranArr, incx: number): number;
function dznrm2(n: number, x: FortranArr, incx: number): number;
function snrm2(n: number, x: FortranArr, incx: number): number;
function dnrm2(n: number, x: FortranArr, incx: number): number;
`

See: _how to create fortranArr_.

Usage:

`javascript
const BLAS = require('blasjs');
const { scnrm2, dznrm2, snrm2, dnrm2 } = BLAS.level1;
`

`typescript
function srotg(p: { sa: number, sb: number, c: number, s: number } ): void;
function drotg(p: { sa: number, sb: number, c: number, s: number } ): void;
function crotg(ca: Complex, cb: Complex, c: { val: number }, s: Complex ): void
function zrotg(ca: Complex, cb: Complex, c: { val: number }, s: Complex ): void
`

Usage:

`javascript
const BLAS = require('blasjs');
const { srotg, drotg, crotg, zrotg } = BLAS.level1;
`

`typescript
function srotmg(p: { sd1: number, sd2: number, sx1: number, sy1: number, sparam: FortranArr }): void;
function drotmg(p: { sd1: number, sd2: number, sx1: number, sy1: number, sparam: FortranArr }): void;
`

See: _how to create fortranArr_.

Usage:

`javascript
const BLAS = require('blasjs');
const { srotmg, drotmg } = BLAS.level1;
`

`typescript
function srotm(n: number, sy: FortranArr, incx: number, sy: FortranArr, incy: number, sparam: FortranArr)): void;

function drotm(n: number, sy: FortranArr, incx: number, sy: FortranArr, incy: number, sparam: FortranArr)): void;
`

See: _how to create fortranArr_.

Usage:

`javascript
const BLAS = require('blasjs');
const { srotm, drotm } = BLAS.level1;
`

`typescript
function srot(n: number, sx: FortranArr, incx: number, sy: FortranArr, incy: number, c: number, s: number): void;
function drot(n: number, sx: FortranArr, incx: number, sy: FortranArr, incy: number, c: number, s: number): void;

function csrot: (n: number, cx: FortranArr, incx: number, cy: FortranArr, incy: number, c: number, s: number): void;
function zdrot: (n: number, cx: FortranArr, incx: number, cy: FortranArr, incy: number, c: number, s: number): void;
`

See: _how to create fortranArr_.

Usage:

`javascript
const BLAS = require('blasjs');
const { srot, drot, csrot, zdrot } = BLAS.level1;
`

`typescript
function sscal(n: number, sa: number, sx: FortranArr, incx: number): void;
function dscal(n: number, sa: number, sx: FortranArr, incx: number): void;
function cscal(n: number, ca: Complex,cx: FortranArr, incx: number): void;
function zscal(n: number, ca: Complex,cx: FortranArr, incx: number): void;
function csscal(n: number, sa: number, cx: FortranArr, incx: number): void;
function zdscal(n: number, sa: number, cx: FortranArr, incx: number): void;
`

See: _how to create fortranArr_.

Usage:

`javascript
const BLAS = require('blasjs');
const { sscal, dscal, cscal, zscal, csscal, zdscal } = BLAS.level1;
`

`typescript
function sasum(n: number, sx: FortranArr, incx: number): number;
function dasum(n: number, sx: FortranArr, incx: number): number;
function scasum(n: number, cx: FortranArr, incx: number): number;
function dzasum(n: number, cx: FortranArr, incx: number): number;
`

See: _how to create fortranArr_.

Usage:

`javascript
const BLAS = require('blasjs');
const { sasum, dasum, scasum, dzasum } = BLAS.level1;
`

`javascript
function sswap(n: number, sx: FortranArr, incx: number, sy: FortranArr, incy: number ): void;
function dswap(n: number, sx: FortranArr, incx: number, sy: FortranArr, incy: number ): void;
function cswap(n: number, cx: FortranArr, incx: number, cy: FortranArr, incy: number ): void;
function zswap(n: number, cx: FortranArr, incx: number, cy: FortranArr, incy: number ): void;
`

See: _how to create fortranArr_.

Usage:

`javascript
const BLAS = require('blasjs');
const { sswap, dswap, cswap, zswap } = BLAS.level1;
`

`javascript
function cdotu(n: number, cx: FortranArr, incx: number, cy: FortranArr, incy: number): Complex;

// first argument sx is made conjugate
function cdotc(n: number, sx: FortranArr, incx: number, sy: FortranArr, incy: number ): Complex;

function zdotu(n: number, cx: FortranArr, incx: number, cy: FortranArr, incy: number ): Complex;

// first argument sx is made conjugate
function zdotc(n: number, cx: FortranArr, incx: number, cy: FortranArr, incy: number ): Complex;
`

See: _how to create fortranArr_.

Usage:

`javascript
const BLAS = require('blasjs');
const { cdotu, cdotc, zdotu, zdotc } = BLAS.level1;
`

`javascript
function sdot(n: number, sx: FortranArr, incx: number, sy: FortranArr, incy: number): number;
function ddot(n: number, sx: FortranArr, incx: number, sy: FortranArr, incy: number): number;
function sdsdot(n: number, sx: FortranArr, incx: number, sy: FortranArr, incy: number): number;
function dsdot(n: number, sx: FortranArr, incx: number, sy: FortranArr, incy: number): number;
`

See: _how to create fortranArr_.

Usage:

`javascript
const BLAS = require('blasjs');
const { sdot, ddot, sdsdot, dsdot } = BLAS.level1;
`

`javascript
function isamax: (n: number, sx: FortranArr, incx: number): number;
function idamax: (n: number, sx: FortranArr, incx: number): number;
function icamax: (n: number, sx: FortranArr, incx: number): number;
function izamax: (n: number, sx: FortranArr, incx: number): number;
`

See: _how to create fortranArr_.

Usage:

`javascript
const BLAS = require('blasjs');
const { isamax, idamax, icamax, izamax } = BLAS.level1;
`

`javascript
function scopy (n: number, sx: FortranArr, incx: number, sy: FortranArr, incy: number): void;
function dcopy (n: number, sx: FortranArr, incx: number, sy: FortranArr, incy: number): void;
function ccopy (n: number, cx: FortranArr, incx: number, cy: FortranArr, incy: number): void;
function zcopy (n: number, cx: FortranArr, incx: number, cy: FortranArr, incy: number): void;
`

See: _how to create fortranArr_.

Usage:

`javascript
const BLAS = require('blasjs');
const { scopy, dcopy, ccopy, zcopy } = BLAS.level1;
`

`javascript
function saxpy(n: number, sa: number, sx: FortranArr, incx: number, sy: FortranArr, incy: number): void;
function daxpy(n: number, sa: number, sx: FortranArr, incx: number, sy: FortranArr, incy: number): void;
function caxpy(n: number, ca: Complex, cx: FortranArr, incx: number, cy: FortranArr, incy: number): void;
function zaxpy(n: number, ca: Complex, cx: FortranArr, incx: number, cy: FortranArr, incy: number): void;
`

See: _how to create fortranArr_.

Usage:

`javascript
const BLAS = require('blasjs');
const { saxpy, daxpy, caxpy, zaxpy } = BLAS.level1;
`

`typescript
function cher2|zher2(
uplo: "u" | "l",
n: number,
alpha: Complex,
x: FortranArr,
incx: number,
y: FortranArr,
incy: number,
a: Matrix,
lda: number): void;

function chpr2|zhpr2(
uplo: "u" | "l",
n: number,
alpha: Complex,
x: FortranArr,
incx: number,
y: FortranArr,
incy: number,
ap: FortranArr): void;
`

See: _how to create fortranArr_.

See: _how to create Matrix_.

Usage:

`javascript
const BLAS = require('blasjs');
const { cher2, zher2, chpr, zhpr } = BLAS.level2;
`

`typescript
function sspr2|dspr2(
uplo: "u" | "l",
n: number,
alpha: number,
x: FortranArr,
incx: number,
y: FortranArr,
incy: number,
ap: FortranArr):void;

function ssyr2|dsyr2(
uplo: 'u' | 'l',
n: number,
alpha: number,
x: FortranArr,
incx: number,
y: FortranArr,
incy: number,
A: Matrix,
lda: number): void;
`

See: _how to create fortranArr_.

See: _how to create Matrix_.

Usage:

`javascript
const BLAS = require('blasjs');
const { sspr2, dspr2, ssyr2, dsyr2 } = BLAS.level2;
`

`typescript
function sger|dger(
m: number,
n: number,
alpha: number,
x: FortranArr,
incx: number,
y: FortranArr,
incy: number,
a: Matrix,
lda: number):void;

function cgerc|zgerc(
m: number,
n: number,
alpha: Complex,
x: FortranArr,
incx: number,
y: FortranArr,
incy: number,
a: Matrix,
lda: number): void;

function cgeru|zgeru(
m: number,
n: number,
alpha: Complex,
x: FortranArr,
incx: number,
y: FortranArr,
incy: number,
a: Matrix,
lda: number): void;
`

See: _how to create fortranArr_.

See: _how to create Matrix_.

Usage:

`javascript
const BLAS = require('blasjs');
const { sger, dger, cgerc, zgerc, cgeru, zgeru } = BLAS.level2;
`

`typescript
function cher(
uplo: "u" | "l",
n: number,
alpha: number,
x: FortranArr,
incx: number,
a: Matrix,
lda: number): void;

function zher(
uplo: "u" | "l",
n: number,
alpha: number,
x: FortranArr,
incx: number,
a: Matrix,
lda: number): void;

function chpr(u
uplo: "u" | "l",
n: number,
alpha: number,
x: FortranArr,
incx: number,
ap: FortranArr): void;

function zhpr(
uplo: "u" | "l",
n: number,
alpha: number,
x: FortranArr,
incx: number,
ap: FortranArr): void;
`

See: _how to create fortranArr_.

See: _how to create Matrix_.

Usage:

`javascript
const BLAS = require('blasjs');
const { cher, zher, chpr, zhpr } = BLAS.level2;
`

`typescript
function sspr(
uplo: "u" | "l",
n: number,
alpha: number,
x: FortranArr,
incx: number,
ap: FortranArr): void;

function dspr(
uplo: "u" | "l",
n: number,
alpha: number,
x: FortranArr,
incx: number,
ap: FortranArr): void;

function ssyr(
uplo: "u" | "l",
n: number,
alpha: number,
x: FortranArr,
incx: number,
a: Matrix,
lda: number): void;

function dsyr(
uplo: "u" | "l",
n: number,
alpha: number,
x: FortranArr,
incx: number,
a: Matrix,
lda: number): void;
`

See: _how to create fortranArr_.

See: _how to create Matrix_.

Usage:

`javascript
const BLAS = require('blasjs');
const { sspr, dspr, ssyr, dsyr } = BLAS.level2;
`

``typescript

function cgbmv|zgbmv(
trans: 'n' | 't' | 'c',
m: number,
n: number,
kl: number,
ku: number,
alpha: Complex,
a: Matrix,
lda: number,
x: FortranArr,
incx: number,
beta: Complex,
y: FortranArr,
incy: number
): void;

function chbmv|zhbmv(
uplo: 'u' | 'l',
n: number,
k: number,
alpha: Complex,
a: Matrix,
lda: number,
x: FortranArr,
incx: number,
beta: Complex,
y: FortranArr,
incy: number
): void;

export function ssbmv|dsbmv(
uplo: string,
n: number,
k: number,
alpha: number,
a: Matrix,
lda: number,
x: FortranArr,
incx: number,
beta: number