org.nd4j.linalg.factory

Interface BlasWrapper<NDARRAY_TYPE extends INDArray>

public interface BlasWrapper<NDARRAY_TYPE extends INDArray>

This class provides a cleaner direct interface to the BLAS routines by extracting the parameters of the matrices from the matrices itself.

For example, you can just pass the vector and do not have to pass the length, corresponding DoubleBuffer, offset and step size explicitly.

Currently, all the general matrix routines are implemented.

Method Summary

Modifier and Type	Method and Description
double	asum(IComplexNDArray x)
double	asum(NDARRAY_TYPE x) Compute || x ||_1 (1-norm, sum of absolute values)
INDArray	axpy(double da, INDArray dx, INDArray dy)
NDARRAY_TYPE	axpy(float da, NDARRAY_TYPE dx, NDARRAY_TYPE dy) Compute y <- alpha * x + y (elementwise addition)
IComplexNDArray	axpy(IComplexNumber da, IComplexNDArray dx, IComplexNDArray dy)
void	checkInfo(String name, int info)
IComplexNDArray	copy(IComplexNDArray x, IComplexNDArray y)
NDARRAY_TYPE	copy(NDARRAY_TYPE x, NDARRAY_TYPE y) Compute y <- x (copy a matrix)
void	dcopy(int n, float[] dx, int dxIdx, int incx, float[] dy, int dyIdx, int incy)
double	dot(NDARRAY_TYPE x, NDARRAY_TYPE y) Compute x^T * y (dot product)
IComplexNumber	dotc(IComplexNDArray x, IComplexNDArray y) Compute x^T * y (dot product)
IComplexNumber	dotu(IComplexNDArray x, IComplexNDArray y) Compute x^T * y (dot product)
int	geev(char jobvl, char jobvr, NDARRAY_TYPE A, NDARRAY_TYPE WR, NDARRAY_TYPE WI, NDARRAY_TYPE VL, NDARRAY_TYPE VR)
void	gelsd(NDARRAY_TYPE A, NDARRAY_TYPE B) Generalized Least Squares via *GELSD.
INDArray	gemm(double alpha, INDArray a, INDArray b, double beta, INDArray c) ************************************************************************ BLAS Level 3
NDARRAY_TYPE	gemm(float alpha, NDARRAY_TYPE a, NDARRAY_TYPE b, float beta, NDARRAY_TYPE c) Compute c <- a*b + beta * c (general matrix matrix multiplication)
IComplexNDArray	gemm(IComplexNumber alpha, IComplexNDArray a, IComplexNDArray b, IComplexNumber beta, IComplexNDArray c)
INDArray	gemv(double alpha, INDArray a, INDArray x, double beta, INDArray y) ************************************************************************ BLAS Level 2
NDARRAY_TYPE	gemv(float alpha, NDARRAY_TYPE a, NDARRAY_TYPE x, float beta, NDARRAY_TYPE y) Compute y <- alpha*op(a)*x + beta * y (general matrix vector multiplication)
IComplexNDArray	gemv(IComplexDouble alpha, IComplexNDArray a, IComplexNDArray x, IComplexDouble beta, IComplexNDArray y)
IComplexNDArray	gemv(IComplexFloat alpha, IComplexNDArray a, IComplexNDArray x, IComplexFloat beta, IComplexNDArray y)
void	geqrf(NDARRAY_TYPE A, NDARRAY_TYPE tau)
INDArray	ger(double alpha, INDArray x, INDArray y, INDArray a)
NDARRAY_TYPE	ger(float alpha, NDARRAY_TYPE x, NDARRAY_TYPE y, NDARRAY_TYPE a) Compute A <- alpha * x * y^T + A (general rank-1 update)
IComplexNDArray	gerc(IComplexDouble alpha, IComplexNDArray x, IComplexNDArray y, IComplexNDArray a)
IComplexNDArray	gerc(IComplexFloat alpha, IComplexNDArray x, IComplexNDArray y, IComplexNDArray a) Compute A <- alpha * x * y^H + A (general rank-1 update)
IComplexNDArray	geru(IComplexDouble alpha, IComplexNDArray x, IComplexNDArray y, IComplexNDArray a)
IComplexNDArray	geru(IComplexFloat alpha, IComplexNDArray x, IComplexNDArray y, IComplexNDArray a) Compute A <- alpha * x * y^T + A (general rank-1 update)
NDARRAY_TYPE	gesv(NDARRAY_TYPE a, int[] ipiv, NDARRAY_TYPE b) ************************************************************************ LAPACK
int	iamax(IComplexNDArray x) Compute index of element with largest absolute value (complex version).
int	iamax(NDARRAY_TYPE x) Compute index of element with largest absolute value (index of absolute value maximum)
double	nrm2(IComplexNDArray x)
double	nrm2(NDARRAY_TYPE x) Compute || x ||_2 (2-norm)
void	ormqr(char side, char trans, NDARRAY_TYPE A, NDARRAY_TYPE tau, NDARRAY_TYPE C)
void	posv(char uplo, NDARRAY_TYPE A, NDARRAY_TYPE B)
void	saxpy(double alpha, INDArray x, INDArray y)
void	saxpy(float alpha, INDArray x, INDArray y) Abstraction over saxpy
INDArray	scal(double alpha, INDArray x)
NDARRAY_TYPE	scal(float alpha, NDARRAY_TYPE x) Compute x <- alpha * x (scale a matrix)
IComplexNDArray	scal(IComplexDouble alpha, IComplexNDArray x)
IComplexNDArray	scal(IComplexFloat alpha, IComplexNDArray x)
NDARRAY_TYPE	swap(NDARRAY_TYPE x, NDARRAY_TYPE y) Compute x <-> y (swap two matrices)
int	syev(char jobz, char uplo, NDARRAY_TYPE a, NDARRAY_TYPE w)
int	syevd(char jobz, char uplo, NDARRAY_TYPE A, NDARRAY_TYPE w)
int	syevr(char jobz, char range, char uplo, INDArray a, double vl, double vu, int il, int iu, double abstol, INDArray w, INDArray z, int[] isuppz)
int	syevr(char jobz, char range, char uplo, NDARRAY_TYPE a, float vl, float vu, int il, int iu, float abstol, NDARRAY_TYPE w, NDARRAY_TYPE z, int[] isuppz)
int	syevx(char jobz, char range, char uplo, INDArray a, double vl, double vu, int il, int iu, double abstol, INDArray w, INDArray z)
int	syevx(char jobz, char range, char uplo, NDARRAY_TYPE a, float vl, float vu, int il, int iu, float abstol, NDARRAY_TYPE w, NDARRAY_TYPE z)
int	sygvd(int itype, char jobz, char uplo, NDARRAY_TYPE A, NDARRAY_TYPE B, NDARRAY_TYPE W)
NDARRAY_TYPE	sysv(char uplo, NDARRAY_TYPE a, int[] ipiv, NDARRAY_TYPE b)

Method Detail

swap

NDARRAY_TYPE swap(NDARRAY_TYPE x,
                  NDARRAY_TYPE y)

Compute x <-> y (swap two matrices)

scal

INDArray scal(double alpha,
              INDArray x)

scal

NDARRAY_TYPE scal(float alpha,
                  NDARRAY_TYPE x)

Compute x <- alpha * x (scale a matrix)

scal

IComplexNDArray scal(IComplexFloat alpha,
                     IComplexNDArray x)

scal

IComplexNDArray scal(IComplexDouble alpha,
                     IComplexNDArray x)

copy

NDARRAY_TYPE copy(NDARRAY_TYPE x,
                  NDARRAY_TYPE y)

Compute y <- x (copy a matrix)

copy

IComplexNDArray copy(IComplexNDArray x,
                     IComplexNDArray y)

axpy

INDArray axpy(double da,
              INDArray dx,
              INDArray dy)

axpy

NDARRAY_TYPE axpy(float da,
                  NDARRAY_TYPE dx,
                  NDARRAY_TYPE dy)

Compute y <- alpha * x + y (elementwise addition)

axpy

IComplexNDArray axpy(IComplexNumber da,
                     IComplexNDArray dx,
                     IComplexNDArray dy)

dot

double dot(NDARRAY_TYPE x,
           NDARRAY_TYPE y)

Compute x^T * y (dot product)

dotc

IComplexNumber dotc(IComplexNDArray x,
                    IComplexNDArray y)

Compute x^T * y (dot product)

dotu

IComplexNumber dotu(IComplexNDArray x,
                    IComplexNDArray y)

Compute x^T * y (dot product)

nrm2

double nrm2(NDARRAY_TYPE x)

Compute || x ||_2 (2-norm)

nrm2

double nrm2(IComplexNDArray x)

asum

double asum(NDARRAY_TYPE x)

Compute || x ||_1 (1-norm, sum of absolute values)

asum

double asum(IComplexNDArray x)

iamax

int iamax(NDARRAY_TYPE x)

Compute index of element with largest absolute value (index of absolute value maximum)

iamax

int iamax(IComplexNDArray x)

Compute index of element with largest absolute value (complex version).

Parameters:

x - matrix

Returns:

index of element with largest absolute value.

gemv

INDArray gemv(double alpha,
              INDArray a,
              INDArray x,
              double beta,
              INDArray y)

************************************************************************ BLAS Level 2

gemv

NDARRAY_TYPE gemv(float alpha,
                  NDARRAY_TYPE a,
                  NDARRAY_TYPE x,
                  float beta,
                  NDARRAY_TYPE y)

Compute y <- alpha*op(a)*x + beta * y (general matrix vector multiplication)

ger

INDArray ger(double alpha,
             INDArray x,
             INDArray y,
             INDArray a)

ger

NDARRAY_TYPE ger(float alpha,
                 NDARRAY_TYPE x,
                 NDARRAY_TYPE y,
                 NDARRAY_TYPE a)

Compute A <- alpha * x * y^T + A (general rank-1 update)

gemv

IComplexNDArray gemv(IComplexDouble alpha,
                     IComplexNDArray a,
                     IComplexNDArray x,
                     IComplexDouble beta,
                     IComplexNDArray y)

gemv

IComplexNDArray gemv(IComplexFloat alpha,
                     IComplexNDArray a,
                     IComplexNDArray x,
                     IComplexFloat beta,
                     IComplexNDArray y)

geru

IComplexNDArray geru(IComplexDouble alpha,
                     IComplexNDArray x,
                     IComplexNDArray y,
                     IComplexNDArray a)

geru

IComplexNDArray geru(IComplexFloat alpha,
                     IComplexNDArray x,
                     IComplexNDArray y,
                     IComplexNDArray a)

Compute A <- alpha * x * y^T + A (general rank-1 update)

gerc

IComplexNDArray gerc(IComplexFloat alpha,
                     IComplexNDArray x,
                     IComplexNDArray y,
                     IComplexNDArray a)

Compute A <- alpha * x * y^H + A (general rank-1 update)

gerc

IComplexNDArray gerc(IComplexDouble alpha,
                     IComplexNDArray x,
                     IComplexNDArray y,
                     IComplexNDArray a)

gemm

INDArray gemm(double alpha,
              INDArray a,
              INDArray b,
              double beta,
              INDArray c)

************************************************************************ BLAS Level 3

gemm

NDARRAY_TYPE gemm(float alpha,
                  NDARRAY_TYPE a,
                  NDARRAY_TYPE b,
                  float beta,
                  NDARRAY_TYPE c)

Compute c <- a*b + beta * c (general matrix matrix multiplication)

gemm

IComplexNDArray gemm(IComplexNumber alpha,
                     IComplexNDArray a,
                     IComplexNDArray b,
                     IComplexNumber beta,
                     IComplexNDArray c)

gesv

NDARRAY_TYPE gesv(NDARRAY_TYPE a,
                  int[] ipiv,
                  NDARRAY_TYPE b)

************************************************************************ LAPACK

checkInfo

void checkInfo(String name,
               int info)

sysv

NDARRAY_TYPE sysv(char uplo,
                  NDARRAY_TYPE a,
                  int[] ipiv,
                  NDARRAY_TYPE b)

syev

int syev(char jobz,
         char uplo,
         NDARRAY_TYPE a,
         NDARRAY_TYPE w)

syevx

int syevx(char jobz,
          char range,
          char uplo,
          INDArray a,
          double vl,
          double vu,
          int il,
          int iu,
          double abstol,
          INDArray w,
          INDArray z)

syevx

int syevx(char jobz,
          char range,
          char uplo,
          NDARRAY_TYPE a,
          float vl,
          float vu,
          int il,
          int iu,
          float abstol,
          NDARRAY_TYPE w,
          NDARRAY_TYPE z)

syevd

int syevd(char jobz,
          char uplo,
          NDARRAY_TYPE A,
          NDARRAY_TYPE w)

syevr

int syevr(char jobz,
          char range,
          char uplo,
          INDArray a,
          double vl,
          double vu,
          int il,
          int iu,
          double abstol,
          INDArray w,
          INDArray z,
          int[] isuppz)

syevr

int syevr(char jobz,
          char range,
          char uplo,
          NDARRAY_TYPE a,
          float vl,
          float vu,
          int il,
          int iu,
          float abstol,
          NDARRAY_TYPE w,
          NDARRAY_TYPE z,
          int[] isuppz)

posv

void posv(char uplo,
          NDARRAY_TYPE A,
          NDARRAY_TYPE B)

geev

int geev(char jobvl,
         char jobvr,
         NDARRAY_TYPE A,
         NDARRAY_TYPE WR,
         NDARRAY_TYPE WI,
         NDARRAY_TYPE VL,
         NDARRAY_TYPE VR)

sygvd

int sygvd(int itype,
          char jobz,
          char uplo,
          NDARRAY_TYPE A,
          NDARRAY_TYPE B,
          NDARRAY_TYPE W)

gelsd

void gelsd(NDARRAY_TYPE A,
           NDARRAY_TYPE B)

Generalized Least Squares via *GELSD.

Note that B must be padded to contain the solution matrix. This occurs when A has fewer rows than columns.

For example: in A * X = B, A is (m,n), X is (n,k) and B is (m,k). Now if m < n, since B is overwritten to contain the solution (in classical LAPACK style), B needs to be padded to be an (n,k) matrix.

Likewise, if m > n, the solution consists only of the first n rows of B.

Parameters:

A - an (m,n) matrix

B - an (max(m,n), k) matrix (well, at least)

geqrf

void geqrf(NDARRAY_TYPE A,
           NDARRAY_TYPE tau)

ormqr

void ormqr(char side,
           char trans,
           NDARRAY_TYPE A,
           NDARRAY_TYPE tau,
           NDARRAY_TYPE C)

dcopy

void dcopy(int n,
           float[] dx,
           int dxIdx,
           int incx,
           float[] dy,
           int dyIdx,
           int incy)

saxpy

void saxpy(double alpha,
           INDArray x,
           INDArray y)

saxpy

void saxpy(float alpha,
           INDArray x,
           INDArray y)

Abstraction over saxpy

Parameters:

alpha - the alpha to scale by

x - the ndarray to use

y - the ndarray to use