org.nd4j.linalg.api.blas.impl

Class BaseLevel1

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

Base class for level 1 functions, abstract headers pulled from: http://www.netlib.org/blas/blast-forum/cblas.h

Author:

Adam Gibson

Constructor Summary

Constructors

Constructor and Description
BaseLevel1()

Method Summary

Modifier and Type	Method and Description
IComplexNumber	asum(IComplexNDArray arr) computes the sum of magnitudes of all vector elements or, for a complex vector x, the sum
double	asum(INDArray arr) computes the sum of magnitudes of all vector elements or, for a complex vector x, the sum
double	asum(int n, DataBuffer x, int offsetX, int incrX) sum of magnitudes of all elements
void	axpy(int 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(int n, double alpha, INDArray x, INDArray y) computes a vector-scalar product and adds the result to a vector.
void	axpy(int n, IComplexNumber alpha, IComplexNDArray x, IComplexNDArray y) computes a vector-scalar product and adds the result to a vector.
protected abstract void	caxpy(int N, IComplexFloat alpha, IComplexNDArray X, int incX, IComplexNDArray Y, int incY)
protected abstract void	ccopy(int N, IComplexNDArray X, int incX, IComplexNDArray Y, int incY)
protected abstract void	cdotc_sub(int N, IComplexNDArray X, int incX, IComplexNDArray Y, int incY, IComplexNDArray dotc)
protected abstract void	cdotu_sub(int N, IComplexNDArray X, int incX, IComplexNDArray Y, int incY, IComplexNDArray dotu)
void	copy(IComplexNDArray x, IComplexNDArray y) copy a vector to another vector.
void	copy(INDArray x, INDArray y) swaps a vector with another vector.
void	copy(int n, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY) copy a vector to another vector.
protected abstract void	cscal(int N, IComplexFloat alpha, IComplexNDArray X, int incX)
protected abstract void	csscal(int N, float alpha, IComplexNDArray X, int incX)
protected abstract void	cswap(int N, IComplexNDArray X, int incX, IComplexNDArray Y, int incY)
protected abstract double	dasum(int N, DataBuffer X, int offsetX, int incX)
protected abstract double	dasum(int N, INDArray X, int incX)
protected abstract void	daxpy(int N, double alpha, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY)
protected abstract void	daxpy(int N, double alpha, INDArray X, int incX, INDArray Y, int incY)
protected abstract void	dcopy(int n, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY)
protected abstract void	dcopy(int N, INDArray X, int incX, INDArray Y, int incY)
protected abstract double	ddot(int N, DataBuffer X, int offsetX, int incX, DataBuffer Y, int offsetY, int incY)
protected abstract double	ddot(int N, INDArray X, int incX, INDArray Y, int incY)
protected abstract double	dnrm2(int N, INDArray X, int incX)
double	dot(int n, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY) Vector-vector dot product
double	dot(int n, double alpha, INDArray X, INDArray Y) computes a vector-vector dot product.
IComplexNumber	dot(int n, IComplexNumber alpha, IComplexNDArray X, IComplexNDArray Y) computes a vector-vector dot product.
protected abstract void	drot(int 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(int 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(int N, double alpha, INDArray X, int incX)
protected abstract double	dsdot(int N, INDArray X, int incX, INDArray Y, int incY)
protected abstract void	dswap(int N, INDArray X, int incX, INDArray Y, int incY)
protected abstract double	dzasum(int N, IComplexNDArray X, int incX)
protected abstract double	dznrm2(int N, IComplexNDArray X, int incX)
protected abstract float	hasum(int N, DataBuffer X, int offsetX, int incX)
protected abstract float	hasum(int N, INDArray X, int incX)
protected abstract void	haxpy(int N, float alpha, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY)
protected abstract void	haxpy(int N, float alpha, INDArray X, int incX, INDArray Y, int incY)
protected abstract float	hdot(int N, DataBuffer X, int offsetX, int incX, DataBuffer Y, int offsetY, int incY)
protected abstract float	hdot(int N, INDArray X, int incX, INDArray Y, int incY)
int	iamax(IComplexNDArray arr) 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	iamax(int n, DataBuffer x, int offsetX, int incrX) Index of largest absolute value
int	iamax(int n, INDArray arr, int stride) finds the element of a vector that has the largest absolute value.
int	iamin(IComplexNDArray arr) finds the element of a vector that has the minimum absolute value.
int	iamin(INDArray arr) finds the element of a vector that has the minimum absolute value.
protected abstract int	icamax(int N, IComplexNDArray X, int incX)
protected abstract int	idamax(int N, DataBuffer X, int offsetX, int incX)
protected abstract int	idamax(int N, INDArray X, int incX)
protected abstract int	isamax(int N, DataBuffer X, int offsetX, int incX)
protected abstract int	isamax(int N, INDArray X, int incX)
protected abstract int	izamax(int N, IComplexNDArray X, int incX)
IComplexNumber	nrm2(IComplexNDArray arr) computes the Euclidean norm of a vector.
double	nrm2(INDArray arr) computes the Euclidean norm of a vector.
void	rot(int N, IComplexNDArray X, IComplexNDArray Y, IComplexNumber c, IComplexNumber s) performs rotation of points in the plane.
void	rot(int 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(IComplexNDArray d1, IComplexNDArray d2, IComplexNDArray b1, IComplexNumber b2, IComplexNDArray P) computes the modified 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(int N, DataBuffer X, int offsetX, int incX)
protected abstract float	sasum(int N, INDArray X, int incX)
protected abstract void	saxpy(int N, float alpha, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY)
protected abstract void	saxpy(int N, float alpha, INDArray X, int incX, INDArray Y, int incY)
void	scal(int N, double alpha, INDArray X) computes a vector by a scalar product.
void	scal(int N, IComplexNumber alpha, IComplexNDArray X) computes a vector by a scalar product.
protected abstract float	scasum(int N, IComplexNDArray X, int incX)
protected abstract float	scnrm2(int N, IComplexNDArray X, int incX)
protected abstract void	scopy(int n, DataBuffer x, int offsetX, int incrX, DataBuffer y, int offsetY, int incrY)
protected abstract void	scopy(int N, INDArray X, int incX, INDArray Y, int incY)
protected abstract float	sdot(int N, DataBuffer X, int offsetX, int incX, DataBuffer Y, int offsetY, int incY)
protected abstract float	sdot(int N, INDArray X, int incX, INDArray Y, int incY)
protected abstract float	sdsdot(int N, float alpha, INDArray X, int incX, INDArray Y, int incY)
protected abstract float	snrm2(int N, INDArray X, int incX)
protected abstract void	srot(int 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(int 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(int N, float alpha, INDArray X, int incX)
protected abstract void	sswap(int 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(IComplexNDArray x, IComplexNDArray y)
void	swap(INDArray x, INDArray y) swaps a vector with another vector.
protected abstract void	zaxpy(int N, IComplexDouble alpha, IComplexNDArray X, int incX, IComplexNDArray Y, int incY)
protected abstract void	zcopy(int N, IComplexNDArray X, int incX, IComplexNDArray Y, int incY)
protected abstract void	zdotc_sub(int N, IComplexNDArray X, int incX, IComplexNDArray Y, int incY, IComplexNDArray dotc)
protected abstract void	zdotu_sub(int N, IComplexNDArray X, int incX, IComplexNDArray Y, int incY, IComplexNDArray dotu)
protected abstract void	zdscal(int N, double alpha, IComplexNDArray X, int incX)
protected abstract void	zscal(int N, IComplexDouble alpha, IComplexNDArray X, int incX)
protected abstract void	zswap(int N, IComplexNDArray X, int incX, IComplexNDArray Y, int incY)

Methods inherited from class org.nd4j.linalg.api.blas.impl.BaseLevel

getDoubleData, getDoubleData, getFloatData, getFloatData

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(int n,
                  double alpha,
                  INDArray X,
                  INDArray Y)

computes a vector-vector dot product.

Specified by:

dot in interface Level1

Parameters:

n -

alpha -

X -

Y -

Returns:

dot

public double dot(int 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

dot

public IComplexNumber dot(int n,
                          IComplexNumber alpha,
                          IComplexNDArray X,
                          IComplexNDArray Y)

computes a vector-vector dot product.

Specified by:

dot in interface Level1

Parameters:

n -

alpha -

X -

Y -

Returns:

nrm2

public double nrm2(INDArray arr)

computes the Euclidean norm of a vector.

Specified by:

nrm2 in interface Level1

Parameters:

arr -

Returns:

nrm2

public IComplexNumber nrm2(IComplexNDArray 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(int n,
                   DataBuffer x,
                   int offsetX,
                   int incrX)

Description copied from interface: Level1

sum of magnitudes of all elements

Specified by:

asum in interface Level1

asum

public IComplexNumber asum(IComplexNDArray 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 - the array to get the sum for

Returns:

iamax

public int iamax(int 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

Parameters:

n - the length to iterate for

arr - the array to get the max index for

stride - the stride for the array

Returns:

iamax

public int iamax(int 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:

iamax

public int iamax(IComplexNDArray 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:

iamin

public int iamin(IComplexNDArray 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 -

swap

public void swap(IComplexNDArray x,
                 IComplexNDArray y)

Specified by:

swap in interface Level1

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

copy

public void copy(IComplexNDArray x,
                 IComplexNDArray y)

copy a vector to another vector.

Specified by:

copy in interface Level1

Parameters:

x -

y -

axpy

public void axpy(int 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(int 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

Parameters:

n - number of operations

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

axpy

public void axpy(int n,
                 IComplexNumber alpha,
                 IComplexNDArray x,
                 IComplexNDArray y)

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

Specified by:

axpy in interface Level1

Parameters:

n -

alpha -

x -

y -

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

rot

public void rot(int N,
                IComplexNDArray X,
                IComplexNDArray Y,
                IComplexNumber c,
                IComplexNumber 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 -

rotmg

public void rotmg(IComplexNDArray d1,
                  IComplexNDArray d2,
                  IComplexNDArray b1,
                  IComplexNumber b2,
                  IComplexNDArray 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(int N,
                 double alpha,
                 INDArray X)

computes a vector by a scalar product.

Specified by:

scal in interface Level1

Parameters:

N -

alpha -

X -

scal

public void scal(int N,
                 IComplexNumber alpha,
                 IComplexNDArray X)

computes a vector by a scalar product.

Specified by:

scal in interface Level1

Parameters:

N -

alpha -

X -

sdsdot

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

dsdot

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

hdot

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

hdot

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

sdot

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

sdot

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

ddot

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

ddot

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

cdotu_sub

protected abstract void cdotu_sub(int N,
                                  IComplexNDArray X,
                                  int incX,
                                  IComplexNDArray Y,
                                  int incY,
                                  IComplexNDArray dotu)

cdotc_sub

protected abstract void cdotc_sub(int N,
                                  IComplexNDArray X,
                                  int incX,
                                  IComplexNDArray Y,
                                  int incY,
                                  IComplexNDArray dotc)

zdotu_sub

protected abstract void zdotu_sub(int N,
                                  IComplexNDArray X,
                                  int incX,
                                  IComplexNDArray Y,
                                  int incY,
                                  IComplexNDArray dotu)

zdotc_sub

protected abstract void zdotc_sub(int N,
                                  IComplexNDArray X,
                                  int incX,
                                  IComplexNDArray Y,
                                  int incY,
                                  IComplexNDArray dotc)

snrm2

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

hasum

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

hasum

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

sasum

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

sasum

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

dnrm2

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

dasum

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

dasum

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

scnrm2

protected abstract float scnrm2(int N,
                                IComplexNDArray X,
                                int incX)

scasum

protected abstract float scasum(int N,
                                IComplexNDArray X,
                                int incX)

dznrm2

protected abstract double dznrm2(int N,
                                 IComplexNDArray X,
                                 int incX)

dzasum

protected abstract double dzasum(int N,
                                 IComplexNDArray X,
                                 int incX)

isamax

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

isamax

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

idamax

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

idamax

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

icamax

protected abstract int icamax(int N,
                              IComplexNDArray X,
                              int incX)

izamax

protected abstract int izamax(int N,
                              IComplexNDArray X,
                              int incX)

sswap

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

scopy

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

scopy

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

haxpy

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

saxpy

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

haxpy

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

saxpy

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

dswap

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

dcopy

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

dcopy

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

daxpy

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

daxpy

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

cswap

protected abstract void cswap(int N,
                              IComplexNDArray X,
                              int incX,
                              IComplexNDArray Y,
                              int incY)

ccopy

protected abstract void ccopy(int N,
                              IComplexNDArray X,
                              int incX,
                              IComplexNDArray Y,
                              int incY)

caxpy

protected abstract void caxpy(int N,
                              IComplexFloat alpha,
                              IComplexNDArray X,
                              int incX,
                              IComplexNDArray Y,
                              int incY)

zswap

protected abstract void zswap(int N,
                              IComplexNDArray X,
                              int incX,
                              IComplexNDArray Y,
                              int incY)

zcopy

protected abstract void zcopy(int N,
                              IComplexNDArray X,
                              int incX,
                              IComplexNDArray Y,
                              int incY)

zaxpy

protected abstract void zaxpy(int N,
                              IComplexDouble alpha,
                              IComplexNDArray X,
                              int incX,
                              IComplexNDArray Y,
                              int incY)

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(int N,
                             INDArray X,
                             int incX,
                             INDArray Y,
                             int incY,
                             float c,
                             float s)

srotm

protected abstract void srotm(int 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(int N,
                             INDArray X,
                             int incX,
                             INDArray Y,
                             int incY,
                             double c,
                             double s)

drotm

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

sscal

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

dscal

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

cscal

protected abstract void cscal(int N,
                              IComplexFloat alpha,
                              IComplexNDArray X,
                              int incX)

zscal

protected abstract void zscal(int N,
                              IComplexDouble alpha,
                              IComplexNDArray X,
                              int incX)

csscal

protected abstract void csscal(int N,
                               float alpha,
                               IComplexNDArray X,
                               int incX)

zdscal

protected abstract void zdscal(int N,
                               double alpha,
                               IComplexNDArray 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