org.nd4j.linalg.api.blas.impl

Class SparseBaseLevel1

java.lang.Object

org.nd4j.linalg.api.blas.impl.SparseBaseLevel

org.nd4j.linalg.api.blas.impl.SparseBaseLevel1

All Implemented Interfaces:

Level1

public abstract class SparseBaseLevel1
extends SparseBaseLevel
implements Level1

Author:

Audrey Loeffel

Constructor Summary

Constructors

Constructor and Description
SparseBaseLevel1()

Method Summary

Modifier and Type	Method and Description
double	asum(INDArray arr) Compute the sum of magnitude of the vector elements
double	asum(long n, DataBuffer x, int offsetX, int incrX) sum of magnitudes of all elements
void	axpy(long n, double alpha, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY) computes a vector-scalar product and adds the result to a vector.
void	axpy(long n, double alpha, INDArray x, INDArray y) Adds a scalar multiple of compressed sparse vector to a full-storage vector.
void	copy(INDArray x, INDArray y) copy a vector to another vector.
void	copy(long n, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY) copy a vector to another vector.
protected abstract double	dasum(long N, INDArray X, int incx)
protected abstract void	daxpyi(long N, double alpha, INDArray X, DataBuffer pointers, INDArray Y)
protected abstract double	ddoti(long N, INDArray X, DataBuffer indx, INDArray Y)
protected abstract double	dnrm2(long N, INDArray X, int incx)
double	dot(long n, DataBuffer dx, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY) Vector-vector dot product
double	dot(long n, double alpha, INDArray X, INDArray Y) computes a vector-vector dot product.
protected abstract void	droti(long N, INDArray X, DataBuffer indexes, INDArray Y, double c, double s)
protected abstract void	dscal(long N, double a, INDArray X, int incx)
protected abstract double	hasum(long N, INDArray X, int incx)
protected abstract void	haxpyi(long N, double alpha, INDArray X, DataBuffer pointers, INDArray Y)
protected abstract double	hdoti(long N, INDArray X, DataBuffer indx, INDArray Y)
protected abstract double	hnrm2(long N, INDArray X, int incx)
protected abstract void	hroti(long N, INDArray X, DataBuffer indexes, INDArray Y, double c, double s)
protected abstract void	hscal(long N, double a, INDArray X, int incx)
int	iamax(INDArray arr) Find the index of the element with maximum absolute value
int	iamax(long n, DataBuffer x, int offsetX, int incrX) Index of largest absolute value
int	iamax(long n, INDArray arr, int stride) finds the element of a vector that has the largest absolute value.
int	iamin(INDArray arr) Find the index of the element with maximum absolute value
protected abstract int	idamax(long N, INDArray X, int incx)
protected abstract int	idamin(long N, INDArray X, int incx)
protected abstract int	ihamax(long N, INDArray X, int incx)
protected abstract int	ihamin(long N, INDArray X, int incx)
protected abstract int	isamax(long N, INDArray X, int incx)
protected abstract int	isamin(long N, INDArray X, int incx)
double	nrm2(INDArray arr) Computes the Euclidean norm of a vector.
void	rot(long N, INDArray X, INDArray Y, double c, double s) Applies Givens rotation to sparse vectors one of which is in compressed form.
void	rotg(INDArray a, INDArray b, INDArray c, INDArray s) computes parameters for a Givens rotation.
void	rotmg(INDArray d1, INDArray d2, INDArray b1, double b2, INDArray P) computes the modified parameters for a Givens rotation.
protected abstract double	sasum(long N, INDArray X, int incx)
protected abstract void	saxpyi(long N, double alpha, INDArray X, DataBuffer pointers, INDArray Y)
void	scal(long N, double alpha, INDArray X) Computes the product of a vector by a scalar.
protected abstract double	sdoti(long N, INDArray X, DataBuffer indx, INDArray Y)
protected abstract double	snrm2(long N, INDArray X, int incx)
protected abstract void	sroti(long N, INDArray X, DataBuffer indexes, INDArray Y, double c, double s)
protected abstract void	sscal(long N, double a, INDArray X, int incx)
boolean	supportsDataBufferL1Ops() Can we use the axpy and copy methods that take a DataBuffer instead of an INDArray with this backend?
void	swap(INDArray x, INDArray y) swaps a vector with another vector.

Methods inherited from class java.lang.Object

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

Constructor Detail

SparseBaseLevel1

public SparseBaseLevel1()

Method Detail

dot

public double dot(long n,
                  double alpha,
                  INDArray X,
                  INDArray Y)

computes a vector-vector dot product.

Specified by:

dot in interface Level1

Parameters:

n - number of accessed element

alpha -

X - an INDArray

Y - an INDArray

Returns:

the vector-vector dot product of X and Y

dot

public double dot(long n,
                  DataBuffer dx,
                  int offsetX,
                  int incrX,
                  DataBuffer y,
                  int offsetY,
                  int incrY)

Description copied from interface: Level1

Vector-vector dot product

Specified by:

dot in interface Level1

nrm2

public double nrm2(INDArray arr)

Computes the Euclidean norm of a vector.

Specified by:

nrm2 in interface Level1

Parameters:

arr - a vector

Returns:

the Euclidean norm of the vector

asum

public double asum(INDArray arr)

Compute the sum of magnitude of the vector elements

Specified by:

asum in interface Level1

Parameters:

arr - a vector

Returns:

the sum of magnitude of the vector elements

asum

public double asum(long n,
                   DataBuffer x,
                   int offsetX,
                   int incrX)

Description copied from interface: Level1

sum of magnitudes of all elements

Specified by:

asum in interface Level1

iamax

public int iamax(INDArray arr)

Find the index of the element with maximum absolute value

Specified by:

iamax in interface Level1

Parameters:

arr - a vector

Returns:

the index of the element with maximum absolute value

iamax

public int iamax(long n,
                 INDArray arr,
                 int stride)

Description copied from interface: Level1

finds the element of a vector that has the largest absolute value.

Specified by:

iamax in interface Level1

arr - the array to get the max index for

stride - the stride for the array

Returns:

iamax

public int iamax(long n,
                 DataBuffer x,
                 int offsetX,
                 int incrX)

Description copied from interface: Level1

Index of largest absolute value

Specified by:

iamax in interface Level1

iamin

public int iamin(INDArray arr)

Find the index of the element with maximum absolute value

Specified by:

iamin in interface Level1

Parameters:

arr - a vector

Returns:

the index of the element with minimum absolute value

swap

public void swap(INDArray x,
                 INDArray y)

Description copied from interface: Level1

swaps a vector with another vector.

Specified by:

swap in interface Level1

copy

public void copy(INDArray x,
                 INDArray y)

Description copied from interface: Level1

copy a vector to another vector.

Specified by:

copy in interface Level1

copy

public void copy(long n,
                 DataBuffer x,
                 int offsetX,
                 int incrX,
                 DataBuffer y,
                 int offsetY,
                 int incrY)

Description copied from interface: Level1

copy a vector to another vector.

Specified by:

copy in interface Level1

axpy

public void axpy(long n,
                 double alpha,
                 INDArray x,
                 INDArray y)

Adds a scalar multiple of compressed sparse vector to a full-storage vector.

Specified by:

axpy in interface Level1

Parameters:

n - The number of element

alpha -

x - a sparse vector

y - a dense vector

axpy

public void axpy(long n,
                 double alpha,
                 DataBuffer x,
                 int offsetX,
                 int incrX,
                 DataBuffer y,
                 int offsetY,
                 int incrY)

Description copied from interface: Level1

computes a vector-scalar product and adds the result to a vector. y = a*x + y

Specified by:

axpy in interface Level1

x - X

offsetX - offset of first element of X in buffer

incrX - increment/stride between elements of X in buffer

y - Y

offsetY - offset of first element of Y in buffer

incrY - increment/stride between elements of Y in buffer

rotg

public void rotg(INDArray a,
                 INDArray b,
                 INDArray c,
                 INDArray s)

Description copied from interface: Level1

computes parameters for a Givens rotation.

Specified by:

rotg in interface Level1

rot

public void rot(long N,
                INDArray X,
                INDArray Y,
                double c,
                double s)

Applies Givens rotation to sparse vectors one of which is in compressed form.

Specified by:

rot in interface Level1

Parameters:

N - The number of elements in vectors X and Y

X - a sparse vector

Y - a full-storage vector

c - a scalar

s - a scalar

rotmg

public void rotmg(INDArray d1,
                  INDArray d2,
                  INDArray b1,
                  double b2,
                  INDArray P)

Description copied from interface: Level1

computes the modified parameters for a Givens rotation.

Specified by:

rotmg in interface Level1

scal

public void scal(long N,
                 double alpha,
                 INDArray X)

Computes the product of a vector by a scalar.

Specified by:

scal in interface Level1

Parameters:

N - The number of elements of the vector X

alpha - a scalar

X - a vector

supportsDataBufferL1Ops

public boolean supportsDataBufferL1Ops()

Description copied from interface: Level1

Can we use the axpy and copy methods that take a DataBuffer instead of an INDArray with this backend?

Specified by:

supportsDataBufferL1Ops in interface Level1

ddoti

protected abstract double ddoti(long N,
                                INDArray X,
                                DataBuffer indx,
                                INDArray Y)

sdoti

protected abstract double sdoti(long N,
                                INDArray X,
                                DataBuffer indx,
                                INDArray Y)

hdoti

protected abstract double hdoti(long N,
                                INDArray X,
                                DataBuffer indx,
                                INDArray Y)

snrm2

protected abstract double snrm2(long N,
                                INDArray X,
                                int incx)

dnrm2

protected abstract double dnrm2(long N,
                                INDArray X,
                                int incx)

hnrm2

protected abstract double hnrm2(long N,
                                INDArray X,
                                int incx)

dasum

protected abstract double dasum(long N,
                                INDArray X,
                                int incx)

sasum

protected abstract double sasum(long N,
                                INDArray X,
                                int incx)

hasum

protected abstract double hasum(long N,
                                INDArray X,
                                int incx)

isamax

protected abstract int isamax(long N,
                              INDArray X,
                              int incx)

idamax

protected abstract int idamax(long N,
                              INDArray X,
                              int incx)

ihamax

protected abstract int ihamax(long N,
                              INDArray X,
                              int incx)

isamin

protected abstract int isamin(long N,
                              INDArray X,
                              int incx)

idamin

protected abstract int idamin(long N,
                              INDArray X,
                              int incx)

ihamin

protected abstract int ihamin(long N,
                              INDArray X,
                              int incx)

daxpyi

protected abstract void daxpyi(long N,
                               double alpha,
                               INDArray X,
                               DataBuffer pointers,
                               INDArray Y)

saxpyi

protected abstract void saxpyi(long N,
                               double alpha,
                               INDArray X,
                               DataBuffer pointers,
                               INDArray Y)

haxpyi

protected abstract void haxpyi(long N,
                               double alpha,
                               INDArray X,
                               DataBuffer pointers,
                               INDArray Y)

droti

protected abstract void droti(long N,
                              INDArray X,
                              DataBuffer indexes,
                              INDArray Y,
                              double c,
                              double s)

sroti

protected abstract void sroti(long N,
                              INDArray X,
                              DataBuffer indexes,
                              INDArray Y,
                              double c,
                              double s)

hroti

protected abstract void hroti(long N,
                              INDArray X,
                              DataBuffer indexes,
                              INDArray Y,
                              double c,
                              double s)

dscal

protected abstract void dscal(long N,
                              double a,
                              INDArray X,
                              int incx)

sscal

protected abstract void sscal(long N,
                              double a,
                              INDArray X,
                              int incx)

hscal

protected abstract void hscal(long N,
                              double a,
                              INDArray X,
                              int incx)