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

Methods

Modifier and Type	Method and Description
double	asum(IComplexNDArray x)
double	asum(NDARRAY_TYPE x) Compute || x ||_1 (1-norm, sum of absolute values)
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)
float	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.
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)
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)
void	geqrf(NDARRAY_TYPE A, NDARRAY_TYPE tau)
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(IComplexNumber alpha, IComplexNDArray x, IComplexNDArray y, IComplexNDArray a) Compute A <- alpha * x * y^H + A (general rank-1 update)
IComplexNDArray	geru(IComplexNumber 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)
NDARRAY_TYPE	scal(float alpha, NDARRAY_TYPE x) Compute x <- alpha * x (scale a matrix)
IComplexNDArray	scal(IComplexNumber 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, 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, 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

NDARRAY_TYPE scal(float alpha,
                NDARRAY_TYPE x)

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

scal

IComplexNDArray scal(IComplexNumber 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

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

float 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

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

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)

geru

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

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

gerc

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

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

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,
        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,
        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)