luiscarbonell/nlapack

C++ bindings for LAPACK (Linear Algebra Package).

nLAPACK

Node >=6.9 C++ bindings for all single- and double-precision LAPACK (Linear Algebra Package) routines.

Requirements

Linux

$ sudo apt-get install libblas-dev liblapack-dev liblapacke-dev

MacOS

$ brew install lapack

Usage

$ npm install nlapack

LAPACK Linear Equation Computational Routines

Matrix Factorization

• ?getrf(m, n, a, lda, ipiv)
• ?getrf2(m, n, a, lda, ipiv)
• ?gbtrf(m, n, kl, ku, ab, ldab, ipiv)
• ?gttrf(n, dl, d, du, du2, ipiv)
• ?dttrfb(n, dl, d, du)
• ?potrf(uplo, n, a, lda)
• ?potrf2(uplo, n, a, lda)
• ?pstrf(uplo, n, a, lda, piv, rank, tol)
• ?pftrf(transr, uplo, n, a)
• ?pptrf(uplo, n, ap)
• ?pbtrf(uplo, n, kd, ab, ldab)
• ?pttrf(n, d, e)
• ?sytrf(uplo, n, a, lda, ipiv)
• ?sytrf_aa(uplo, n, a, lda, ipiv)
• ?sytrf_rook(uplo, n, a, lda, ipiv)
• ?hetrf(uplo, n, a, lda, ipiv)
• ?hetrf_aa(uplo, n, a, lda, ipiv)
• ?hetrf_rook(uplo, n, a, lda, ipiv)
• ?sptrf(uplo, n, ap, ipiv)
• ?hptrf(uplo, n, ap, ipiv)

Solving Systems of Linear Equations

• ?getrs(trans, n, nrhs, a, lda, ipiv, b, ldb)
• ?gbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb)
• ?gttrs(trans, n, nrhs, dl, d, du du2, ipiv, b, ldb)
• ?dttrsb(trans, n, nrhs, dl, d, du, b, ldb)
• ?potrs(uplo, n, nrhs, a, lda, b, ldb)
• ?pftrs(transr, uplo, n, nrhs, a, b, ldb)
• ?pptrs(uplo, n, nrhs, ap, b, ldb)
• ?pbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb)
• ?pttrs(n, nrhs, d, e, b, ldb)
• ?sytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb)
• ?sytrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb)
• ?sytrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb)
• ?hetrs()
• ?hetrs_aa()
• ?hetrs_rook()
• ?sytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb)
• ?hetrs2()
• ?sptrs(uplo, n, nrhs, ap, ipiv, b, ldb)
• ?hptrs()
• ?trtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb)
• ?tptrs(uplo, trans, diag, n, nrhs, ap, b, ldb)
• ?tbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb)

Estimating the Condition Number

• ?gecon(norm, n, a, lda, anorm, rcond)
• ?gbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond)
• ?gtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond)
• ?pocon(uplo, n, a, lda, anorm, rcond)
• ?ppcon(uplo, n, ap, anorm, rcond)
• ?pbcon(uplo, n, kd, ab, ldab, anorm, rcond)
• ?ptcon(uplo, d, e, anorm, rcond)
• ?sycon(uplo, n, a, lda, ipiv, anorm, rcond)
• ?sycon_rook(uplo, n, a, lda, ipiv, anorm, rcond)
• ?hecon(uplo, n, a, lda, ipiv, anorm, rcond)
• ?hecon_rook(uplo, n, a, lda, ipiv, anorm, rcond)
• ?spcon(uplo, n, ap, ipiv, anorm, rcond)
• ?trcon(norm, uplo, diag, n, a, lda, rcond)
• ?tpcon(norm, uplo, diag, n, ap, rcond)
• ?tbcon(norm, uplo, diag, n, kd, ab, ldab, rcond)

Refining the Solution and Estimating Its Error

• ?gerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr)
• ?gerfsx(trans, equed, n, nrhs, a, lda, af, ldaf, ipiv, r, c, b, ldb, x, ldx, rcond, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params)
• ?gbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr)
• ?gbrfsx(trans, equed, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, r, c, b, ldb, x, ldx, rcond, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params)
• ?gtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr)
• ?porfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr)
• ?porfsx(uplo, equed, n, nrhs, a, lda, af, ldaf, s, b, ldb, x, ldx, rcond, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params)
• ?pprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr)
• ?pbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr)
• ?ptrfs(n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr)
• ?syrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr)
• ?syrfsx(uplo, equed, n, nrhs, a, lda, af, ldaf, ipiv, s, b, ldb, x, ldx, rcond, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params)
• ?herfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr)
• ?herfsx(uplo, equed, n, nrhs, a, lda, af, ldaf, ipiv, s, b, ldb, x, ldx, rcond, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params)
• ?sprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr)
• ?hprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr)
• ?trrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr)
• ?tprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr)
• ?tbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr)

Matrix Inversion

• ?getri(n, a, lda, ipiv)
• ?potri(uplo, n, a, lda)
• ?pftri(transr, uplo, n, a)
• ?pptri(uplo, n, ap)
• ?sytri(uplo, n, a, lda, ipiv)
• ?sytri_rook(uplo, n, a, lda, ipiv)
• ?hetri(uplo, n, a, lda, ipiv)
• ?hetri_rook(uplo, n, a, lda, ipiv)
• ?sytri2(uplo, n, a, lda, ipiv)
• ?hetri2(uplo, n, a, lda, ipiv)
• ?sytri2x(uplo, n, a, lda, ipiv, nb)
• ?hetri2x(uplo, n, a, lda, ipiv, nb)
• ?sptri(uplo, n, ap, ipiv)
• ?hptri(uplo, n, ap, ipiv)
• ?trtri(uplo, diag, n, a, lda)
• ?tftri(transr, uplo, diag, n, a)
• ?tptri(uplo, diag, n, ap)

Matrix Equilibration

• ?geequ(m, n, a, lda, r, c, rowcnd, colcnd, amax)
• ?geequb(m, n, a, lda, r, c, rowcnd, colcnd, amax)
• ?gbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax)
• ?gbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax)
• ?poequ(n, a, lda, s, scond, amax)
• ?poequb(n, a, lda, s, scond, amax)
• ?ppequ(uplo, n, ap, s, scond, amax)
• ?pbequ(uplo, n, kd, ab, ldab, s, scond, amax)
• ?syequb(uplo, n, a, lda, s, scond, amax)
• ?heequb(uplo, n, a, lda, s, scond, amax)

LAPACK Utility Functions and Routines

• ilaver(vers_major, vers_minor, vers_patch)
• ?lamch(cmach)

LAPACK Test Functions and Routines

• ?latms(m, n, dist, iseed, sym, d, mode, cond, dmax, kl, ku, pack, a, lda)

Double precision functions expect Float64Array vectors, single precision functions expect Float32Array vectors.