java.lang.Object
- org.nd4j.linalg.api.blas.impl.BaseLevel
- - org.nd4j.linalg.api.blas.impl.BaseLevel1

All Implemented Interfaces:: Level1

public abstract class BaseLevel1
extends BaseLevel
implements Level1

Constructor Summary

Constructors
Constructor Description

BaseLevel1()

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`double`	`asum(long n, DataBuffer x, int offsetX, int incrX)`	sum of magnitudes of all elements
`double`	`asum(INDArray arr)`	computes the sum of magnitudes of all vector elements or, for a complex vector x, the sum
`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)`	computes a vector-scalar product and adds the result to a vector.
`void`	`copy(long n, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY)`	copy a vector to another vector.
`void`	`copy(INDArray x, INDArray y)`	swaps a vector with another vector.
`protected abstract double`	`dasum(long N, DataBuffer X, int offsetX, int incX)`
`protected abstract double`	`dasum(long N, INDArray X, int incX)`
`protected abstract void`	`daxpy(long N, double alpha, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY)`
`protected abstract void`	`daxpy(long N, double alpha, INDArray X, int incX, INDArray Y, int incY)`
`protected abstract void`	`dcopy(long n, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY)`
`protected abstract void`	`dcopy(long N, INDArray X, int incX, INDArray Y, int incY)`
`protected abstract double`	`ddot(long N, DataBuffer X, int offsetX, int incX, DataBuffer Y, int offsetY, int incY)`
`protected abstract double`	`ddot(long N, INDArray X, int incX, INDArray Y, int incY)`
`protected abstract double`	`dnrm2(long N, INDArray X, int incX)`
`double`	`dot(long n, double alpha, INDArray X, INDArray Y)`	computes a vector-vector dot product.
`double`	`dot(long n, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY)`	Vector-vector dot product
`protected abstract void`	`drot(long N, INDArray X, int incX, INDArray Y, int incY, double c, double s)`
`protected abstract void`	`drotg(double a, double b, double c, double s)`
`protected abstract void`	`drotm(long N, INDArray X, int incX, INDArray Y, int incY, INDArray P)`
`protected abstract void`	`drotmg(double d1, double d2, double b1, double b2, INDArray P)`
`protected abstract void`	`dscal(long N, double alpha, INDArray X, int incX)`
`protected abstract double`	`dsdot(long N, INDArray X, int incX, INDArray Y, int incY)`
`protected abstract void`	`dswap(long N, INDArray X, int incX, INDArray Y, int incY)`
`protected abstract float`	`hasum(long N, DataBuffer X, int offsetX, int incX)`
`protected abstract float`	`hasum(long N, INDArray X, int incX)`
`protected abstract void`	`haxpy(long N, float alpha, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY)`
`protected abstract void`	`haxpy(long N, float alpha, INDArray X, int incX, INDArray Y, int incY)`
`protected abstract float`	`hdot(long N, DataBuffer X, int offsetX, int incX, DataBuffer Y, int offsetY, int incY)`
`protected abstract float`	`hdot(long N, INDArray X, int incX, INDArray Y, int incY)`
`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`	`iamax(INDArray arr)`	finds the element of a vector that has the largest absolute value.
`int`	`iamin(INDArray arr)`	finds the element of a vector that has the minimum absolute value.
`protected abstract int`	`idamax(long N, DataBuffer X, int offsetX, int incX)`
`protected abstract int`	`idamax(long N, INDArray X, int incX)`
`protected abstract int`	`isamax(long N, DataBuffer X, int offsetX, int incX)`
`protected abstract int`	`isamax(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)`	performs rotation of points in the plane.
`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 float`	`sasum(long N, DataBuffer X, int offsetX, int incX)`
`protected abstract float`	`sasum(long N, INDArray X, int incX)`
`protected abstract void`	`saxpy(long N, float alpha, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY)`
`protected abstract void`	`saxpy(long N, float alpha, INDArray X, int incX, INDArray Y, int incY)`
`void`	`scal(long N, double alpha, INDArray X)`	computes a vector by a scalar product.
`protected abstract void`	`scopy(long n, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY)`
`protected abstract void`	`scopy(long N, INDArray X, int incX, INDArray Y, int incY)`
`protected abstract float`	`sdot(long N, DataBuffer X, int offsetX, int incX, DataBuffer Y, int offsetY, int incY)`
`protected abstract float`	`sdot(long N, INDArray X, int incX, INDArray Y, int incY)`
`protected abstract float`	`sdsdot(long N, float alpha, INDArray X, int incX, INDArray Y, int incY)`
`protected abstract float`	`snrm2(long N, INDArray X, int incX)`
`protected abstract void`	`srot(long N, INDArray X, int incX, INDArray Y, int incY, float c, float s)`
`protected abstract void`	`srotg(float a, float b, float c, float s)`
`protected abstract void`	`srotm(long N, INDArray X, int incX, INDArray Y, int incY, INDArray P)`
`protected abstract void`	`srotmg(float d1, float d2, float b1, float b2, INDArray P)`
`protected abstract void`	`sscal(long N, float alpha, INDArray X, int incX)`
`protected abstract void`	`sswap(long N, INDArray X, int incX, INDArray Y, int incY)`
`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
- BaseLevel1
```
public BaseLevel1()
```

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

Returns:

asum
```
public double asum(INDArray arr)
```
computes the sum of magnitudes of all vector elements or, for a complex vector x, the sum

Specified by:

asum in interface Level1

Parameters:

arr -

Returns:

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(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

iamax
```
public int iamax(INDArray arr)
```
finds the element of a vector that has the largest absolute value.

Specified by:

iamax in interface Level1

Parameters:

arr -

Returns:

iamin
```
public int iamin(INDArray arr)
```
finds the element of a vector that has the minimum absolute value.

Specified by:

iamin in interface Level1

Parameters:

arr -

Returns:

swap
```
public void swap(INDArray x,
                 INDArray y)
```
swaps a vector with another vector.

Specified by:

swap in interface Level1

Parameters:

x -

y -

copy
```
public void copy(INDArray x,
                 INDArray y)
```
swaps a vector with another vector.

Specified by:

copy in interface Level1

Parameters:

x -

y -

copy

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

copy a vector to another vector.

Specified by:: copy in interface Level1

axpy

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

computes a vector-scalar product and adds the result to a vector.

Specified by:: axpy in interface Level1
Parameters:: n -; alpha -; x -; y -

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)

computes parameters for a Givens rotation.

Specified by:: rotg in interface Level1
Parameters:: a -; b -; c -; s -

rot

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

performs rotation of points in the plane.

Specified by:: rot in interface Level1
Parameters:: N -; X -; Y -; c -; s -

rotmg

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

computes the modified parameters for a Givens rotation.

Specified by:: rotmg in interface Level1
Parameters:: d1 -; d2 -; b1 -; b2 -; P -

scal

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

computes a vector by a scalar product.

Specified by:: scal in interface Level1
Parameters:: N -; alpha -; X -

sdsdot

protected abstract float sdsdot(long N,
                                float alpha,
                                INDArray X,
                                int incX,
                                INDArray Y,
                                int incY)

dsdot

protected abstract double dsdot(long N,
                                INDArray X,
                                int incX,
                                INDArray Y,
                                int incY)

hdot

protected abstract float hdot(long N,
                              INDArray X,
                              int incX,
                              INDArray Y,
                              int incY)

hdot

protected abstract float hdot(long N,
                              DataBuffer X,
                              int offsetX,
                              int incX,
                              DataBuffer Y,
                              int offsetY,
                              int incY)

sdot

protected abstract float sdot(long N,
                              INDArray X,
                              int incX,
                              INDArray Y,
                              int incY)

sdot

protected abstract float sdot(long N,
                              DataBuffer X,
                              int offsetX,
                              int incX,
                              DataBuffer Y,
                              int offsetY,
                              int incY)

ddot

protected abstract double ddot(long N,
                               INDArray X,
                               int incX,
                               INDArray Y,
                               int incY)

ddot

protected abstract double ddot(long N,
                               DataBuffer X,
                               int offsetX,
                               int incX,
                               DataBuffer Y,
                               int offsetY,
                               int incY)

snrm2

protected abstract float snrm2(long N,
                               INDArray X,
                               int incX)

hasum

protected abstract float hasum(long N,
                               INDArray X,
                               int incX)

hasum

protected abstract float hasum(long N,
                               DataBuffer X,
                               int offsetX,
                               int incX)

sasum

protected abstract float sasum(long N,
                               INDArray X,
                               int incX)

sasum

protected abstract float sasum(long N,
                               DataBuffer X,
                               int offsetX,
                               int incX)

dnrm2

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

dasum

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

dasum

protected abstract double dasum(long N,
                                DataBuffer X,
                                int offsetX,
                                int incX)

isamax

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

isamax

protected abstract int isamax(long N,
                              DataBuffer X,
                              int offsetX,
                              int incX)

idamax

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

idamax

protected abstract int idamax(long N,
                              DataBuffer X,
                              int offsetX,
                              int incX)

sswap

protected abstract void sswap(long N,
                              INDArray X,
                              int incX,
                              INDArray Y,
                              int incY)

scopy

protected abstract void scopy(long N,
                              INDArray X,
                              int incX,
                              INDArray Y,
                              int incY)

scopy

protected abstract void scopy(long n,
                              DataBuffer x,
                              int offsetX,
                              int incrX,
                              DataBuffer y,
                              int offsetY,
                              int incrY)

haxpy

protected abstract void haxpy(long N,
                              float alpha,
                              INDArray X,
                              int incX,
                              INDArray Y,
                              int incY)

saxpy

protected abstract void saxpy(long N,
                              float alpha,
                              INDArray X,
                              int incX,
                              INDArray Y,
                              int incY)

haxpy

protected abstract void haxpy(long N,
                              float alpha,
                              DataBuffer x,
                              int offsetX,
                              int incrX,
                              DataBuffer y,
                              int offsetY,
                              int incrY)

saxpy

protected abstract void saxpy(long N,
                              float alpha,
                              DataBuffer x,
                              int offsetX,
                              int incrX,
                              DataBuffer y,
                              int offsetY,
                              int incrY)

dswap

protected abstract void dswap(long N,
                              INDArray X,
                              int incX,
                              INDArray Y,
                              int incY)

dcopy

protected abstract void dcopy(long N,
                              INDArray X,
                              int incX,
                              INDArray Y,
                              int incY)

dcopy

protected abstract void dcopy(long n,
                              DataBuffer x,
                              int offsetX,
                              int incrX,
                              DataBuffer y,
                              int offsetY,
                              int incrY)

daxpy

protected abstract void daxpy(long N,
                              double alpha,
                              INDArray X,
                              int incX,
                              INDArray Y,
                              int incY)

daxpy

protected abstract void daxpy(long N,
                              double alpha,
                              DataBuffer x,
                              int offsetX,
                              int incrX,
                              DataBuffer y,
                              int offsetY,
                              int incrY)

srotg

protected abstract void srotg(float a,
                              float b,
                              float c,
                              float s)

srotmg

protected abstract void srotmg(float d1,
                               float d2,
                               float b1,
                               float b2,
                               INDArray P)

srot

protected abstract void srot(long N,
                             INDArray X,
                             int incX,
                             INDArray Y,
                             int incY,
                             float c,
                             float s)

srotm

protected abstract void srotm(long N,
                              INDArray X,
                              int incX,
                              INDArray Y,
                              int incY,
                              INDArray P)

drotg

protected abstract void drotg(double a,
                              double b,
                              double c,
                              double s)

drotmg

protected abstract void drotmg(double d1,
                               double d2,
                               double b1,
                               double b2,
                               INDArray P)

drot

protected abstract void drot(long N,
                             INDArray X,
                             int incX,
                             INDArray Y,
                             int incY,
                             double c,
                             double s)

drotm

protected abstract void drotm(long N,
                              INDArray X,
                              int incX,
                              INDArray Y,
                              int incY,
                              INDArray P)

sscal

protected abstract void sscal(long N,
                              float alpha,
                              INDArray X,
                              int incX)

dscal

protected abstract void dscal(long N,
                              double alpha,
                              INDArray X,
                              int incX)

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

Class BaseLevel1

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

BaseLevel1

Method Detail

dot

dot

nrm2

asum

asum

iamax

iamax

iamax

iamin

swap

copy

copy

axpy

axpy

rotg

rot

rotmg

scal

sdsdot

dsdot

hdot

hdot

sdot

sdot

ddot

ddot

snrm2

hasum

hasum

sasum

sasum

dnrm2

dasum

dasum

isamax

isamax

idamax

idamax

sswap

scopy

scopy

haxpy

saxpy

haxpy

saxpy

dswap

dcopy

dcopy

daxpy

daxpy

srotg

srotmg

srot

srotm

drotg

drotmg

drot

drotm

sscal

dscal

supportsDataBufferL1Ops