org.nd4j.linalg.factory

Class BaseBlasWrapper

java.lang.Object

org.nd4j.linalg.factory.BaseBlasWrapper

All Implemented Interfaces:

BlasWrapper

public abstract class BaseBlasWrapper
extends Object
implements BlasWrapper

Base implementation of a blas wrapper that delegates things to the underlying level. This is a migration tool to preserve the old api while allowing for migration to the newer one.

Author:

Adam Gibson

Constructor Summary

Constructors

Constructor and Description
BaseBlasWrapper()

Method Summary

Modifier and Type	Method and Description
double	asum(INDArray x) Compute || x ||_1 (1-norm, sum of absolute values)
INDArray	axpy(double da, INDArray dx, INDArray dy)
INDArray	axpy(float da, INDArray dx, INDArray dy) Compute y <- alpha * x + y (elementwise addition)
INDArray	axpy(Number da, INDArray dx, INDArray dy) Compute y <- y + x * alpha
void	checkInfo(String name, int info)
INDArray	copy(INDArray x, INDArray y) Compute y <- x (copy a matrix)
double	dot(INDArray x, INDArray y) Compute x^T * y (dot product)
int	geev(char jobvl, char jobvr, INDArray A, INDArray WR, INDArray WI, INDArray VL, INDArray VR)
void	gelsd(INDArray A, INDArray B) Generalized Least Squares via *GELSD.
INDArray	gemv(double alpha, INDArray a, INDArray x, double beta, INDArray y)
INDArray	gemv(float alpha, INDArray a, INDArray x, float beta, INDArray y) Compute y <- alpha*op(a)*x + beta * y (general matrix vector multiplication)
INDArray	gemv(Number alpha, INDArray a, INDArray x, double beta, INDArray y) ************************************************************************ BLAS Level 2
void	geqrf(INDArray A, INDArray tau)
INDArray	ger(double alpha, INDArray x, INDArray y, INDArray a)
INDArray	ger(float alpha, INDArray x, INDArray y, INDArray a) Compute A <- alpha * x * y^T + A (general rank-1 update)
INDArray	ger(Number alpha, INDArray x, INDArray y, INDArray a)
INDArray	gesv(INDArray a, int[] ipiv, INDArray b) ************************************************************************ LAPACK
int	iamax(INDArray x) Compute index of element with largest absolute value (index of absolute value maximum)
Lapack	lapack() LAPack interface
Level1	level1() Return the level 1 functions for this blas impl
Level2	level2() Return the level 2 functions for this blas impl
Level3	level3() Return the level 3 functions for this blas impl
double	nrm2(INDArray x) Compute || x ||_2 (2-norm)
void	ormqr(char side, char trans, INDArray A, INDArray tau, INDArray C)
void	posv(char uplo, INDArray A, INDArray 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)
INDArray	scal(float alpha, INDArray x) Compute x <- alpha * x (scale a matrix)
INDArray	swap(INDArray x, INDArray y) Compute x <-> y (swap two matrices)
int	syev(char jobz, char uplo, INDArray a, INDArray w)
int	syevd(char jobz, char uplo, INDArray A, INDArray 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, INDArray a, float vl, float vu, int il, int iu, float abstol, INDArray w, INDArray z, int[] isuppz)
int	syevr(char jobz, char range, char uplo, INDArray a, float vl, float vu, int il, int iu, Number abstol, INDArray w, INDArray 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, INDArray a, float vl, float vu, int il, int iu, float abstol, INDArray w, INDArray z)
int	sygvd(int itype, char jobz, char uplo, INDArray A, INDArray B, INDArray W)
INDArray	sysv(char uplo, INDArray a, int[] ipiv, INDArray b)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

BaseBlasWrapper

public BaseBlasWrapper()

Method Detail

lapack

public Lapack lapack()

Description copied from interface: BlasWrapper

LAPack interface

Specified by:

lapack in interface BlasWrapper

Returns:

level1

public Level1 level1()

Description copied from interface: BlasWrapper

Return the level 1 functions for this blas impl

Specified by:

level1 in interface BlasWrapper

Returns:

level2

public Level2 level2()

Description copied from interface: BlasWrapper

Return the level 2 functions for this blas impl

Specified by:

level2 in interface BlasWrapper

Returns:

level3

public Level3 level3()

Description copied from interface: BlasWrapper

Return the level 3 functions for this blas impl

Specified by:

level3 in interface BlasWrapper

Returns:

axpy

public INDArray axpy(Number da,
                     INDArray dx,
                     INDArray dy)

Description copied from interface: BlasWrapper

Compute y <- y + x * alpha

Specified by:

axpy in interface BlasWrapper

Parameters:

da - the alpha to multiply by

Returns:

gemv

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

Description copied from interface: BlasWrapper

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

Specified by:

gemv in interface BlasWrapper

ger

public INDArray ger(Number alpha,
                    INDArray x,
                    INDArray y,
                    INDArray a)

Specified by:

ger in interface BlasWrapper

syevr

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

Specified by:

syevr in interface BlasWrapper

swap

public INDArray swap(INDArray x,
                     INDArray y)

Description copied from interface: BlasWrapper

Compute x <-> y (swap two matrices)

Specified by:

swap in interface BlasWrapper

scal

public INDArray scal(double alpha,
                     INDArray x)

Specified by:

scal in interface BlasWrapper

scal

public INDArray scal(float alpha,
                     INDArray x)

Description copied from interface: BlasWrapper

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

Specified by:

scal in interface BlasWrapper

copy

public INDArray copy(INDArray x,
                     INDArray y)

Description copied from interface: BlasWrapper

Compute y <- x (copy a matrix)

Specified by:

copy in interface BlasWrapper

axpy

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

Specified by:

axpy in interface BlasWrapper

axpy

public INDArray axpy(float da,
                     INDArray dx,
                     INDArray dy)

Description copied from interface: BlasWrapper

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

Specified by:

axpy in interface BlasWrapper

dot

public double dot(INDArray x,
                  INDArray y)

Description copied from interface: BlasWrapper

Compute x^T * y (dot product)

Specified by:

dot in interface BlasWrapper

nrm2

public double nrm2(INDArray x)

Description copied from interface: BlasWrapper

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

Specified by:

nrm2 in interface BlasWrapper

asum

public double asum(INDArray x)

Description copied from interface: BlasWrapper

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

Specified by:

asum in interface BlasWrapper

iamax

public int iamax(INDArray x)

Description copied from interface: BlasWrapper

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

Specified by:

iamax in interface BlasWrapper

gemv

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

Specified by:

gemv in interface BlasWrapper

gemv

public INDArray gemv(float alpha,
                     INDArray a,
                     INDArray x,
                     float beta,
                     INDArray y)

Description copied from interface: BlasWrapper

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

Specified by:

gemv in interface BlasWrapper

ger

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

Specified by:

ger in interface BlasWrapper

ger

public INDArray ger(float alpha,
                    INDArray x,
                    INDArray y,
                    INDArray a)

Description copied from interface: BlasWrapper

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

Specified by:

ger in interface BlasWrapper

gesv

public INDArray gesv(INDArray a,
                     int[] ipiv,
                     INDArray b)

Description copied from interface: BlasWrapper

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

Specified by:

gesv in interface BlasWrapper

checkInfo

public void checkInfo(String name,
                      int info)

Specified by:

checkInfo in interface BlasWrapper

sysv

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

Specified by:

sysv in interface BlasWrapper

syev

public int syev(char jobz,
                char uplo,
                INDArray a,
                INDArray w)

Specified by:

syev in interface BlasWrapper

syevx

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

Specified by:

syevx in interface BlasWrapper

syevx

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

Specified by:

syevx in interface BlasWrapper

syevd

public int syevd(char jobz,
                 char uplo,
                 INDArray A,
                 INDArray w)

Specified by:

syevd in interface BlasWrapper

syevr

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

Specified by:

syevr in interface BlasWrapper

syevr

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

Specified by:

syevr in interface BlasWrapper

posv

public void posv(char uplo,
                 INDArray A,
                 INDArray B)

Specified by:

posv in interface BlasWrapper

geev

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

Specified by:

geev in interface BlasWrapper

sygvd

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

Specified by:

sygvd in interface BlasWrapper

gelsd

public void gelsd(INDArray A,
                  INDArray B)

Description copied from interface: BlasWrapper

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.

Specified by:

gelsd in interface BlasWrapper

Parameters:

A - an (m,n) matrix

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

geqrf

public void geqrf(INDArray A,
                  INDArray tau)

Specified by:

geqrf in interface BlasWrapper

ormqr

public void ormqr(char side,
                  char trans,
                  INDArray A,
                  INDArray tau,
                  INDArray C)

Specified by:

ormqr in interface BlasWrapper

saxpy

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

Specified by:

saxpy in interface BlasWrapper

saxpy

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

Description copied from interface: BlasWrapper

Abstraction over saxpy

Specified by:

saxpy in interface BlasWrapper

Parameters:

alpha - the alpha to scale by

x - the ndarray to use

y - the ndarray to use