Uses of Interface
org.nd4j.linalg.api.ndarray.INDArray

Packages that use INDArray

Package	Description
org.nd4j.linalg.api.buffer
org.nd4j.linalg.api.complex
org.nd4j.linalg.api.instrumentation
org.nd4j.linalg.api.io
org.nd4j.linalg.api.ndarray
org.nd4j.linalg.api.ops
org.nd4j.linalg.api.ops.executioner
org.nd4j.linalg.api.ops.factory
org.nd4j.linalg.api.ops.impl.accum
org.nd4j.linalg.api.ops.impl.accum.distances
org.nd4j.linalg.api.ops.impl.scalar
org.nd4j.linalg.api.ops.impl.scalar.comparison
org.nd4j.linalg.api.ops.impl.transforms
org.nd4j.linalg.api.ops.impl.transforms.arithmetic
org.nd4j.linalg.api.ops.impl.transforms.comparison
org.nd4j.linalg.api.rng
org.nd4j.linalg.api.rng.distribution
org.nd4j.linalg.api.rng.distribution.factory
org.nd4j.linalg.api.rng.distribution.impl
org.nd4j.linalg.benchmark
org.nd4j.linalg.convolution
org.nd4j.linalg.dataset
org.nd4j.linalg.dataset.api
org.nd4j.linalg.dataset.api.iterator.fetcher
org.nd4j.linalg.dimensionalityreduction
org.nd4j.linalg.eigen
org.nd4j.linalg.factory
org.nd4j.linalg.fft
org.nd4j.linalg.indexing
org.nd4j.linalg.learning
org.nd4j.linalg.lossfunctions
org.nd4j.linalg.ops.transforms
org.nd4j.linalg.util

Uses of INDArray in org.nd4j.linalg.api.buffer

Methods in org.nd4j.linalg.api.buffer with parameters of type INDArray

Modifier and Type	Method and Description
static void	BufferReaper.destroy(INDArray... arrs) Frees data used by the given ndarrays

Constructor parameters in org.nd4j.linalg.api.buffer with type arguments of type INDArray

Constructor and Description
BufferReaper(ReferenceQueue<INDArray> queue, ReferenceQueue<DataBuffer> buffer)
BufferReaper(Runnable target, ReferenceQueue<INDArray> queue, ReferenceQueue<DataBuffer> buffer)
BufferReaper(Runnable target, String name, ReferenceQueue<INDArray> queue, ReferenceQueue<DataBuffer> buffer)
BufferReaper(String name, ReferenceQueue<INDArray> queue, ReferenceQueue<DataBuffer> buffer)
BufferReaper(ThreadGroup group, Runnable target, ReferenceQueue<INDArray> queue, ReferenceQueue<DataBuffer> buffer)
BufferReaper(ThreadGroup group, Runnable target, String name, long stackSize, ReferenceQueue<INDArray> queue, ReferenceQueue<DataBuffer> buffer)
BufferReaper(ThreadGroup group, Runnable target, String name, ReferenceQueue<INDArray> queue, ReferenceQueue<DataBuffer> buffer)
BufferReaper(ThreadGroup group, String name, ReferenceQueue<INDArray> queue, ReferenceQueue<DataBuffer> buffer)

Uses of INDArray in org.nd4j.linalg.api.complex

Subinterfaces of INDArray in org.nd4j.linalg.api.complex

Modifier and Type	Interface and Description
interface	IComplexNDArray Complex numbers

Classes in org.nd4j.linalg.api.complex that implement INDArray

Modifier and Type	Class and Description
class	BaseComplexNDArray ComplexNDArray for complex numbers.
class	LinearViewComplexNDArray Row vector view of an ndarray

Methods in org.nd4j.linalg.api.complex that return INDArray

Modifier and Type	Method and Description
INDArray	BaseComplexNDArray.assign(INDArray arr) Assign all of the elements in the given ndarray to this nedarray
protected INDArray	BaseComplexNDArray.create(int[] shape, char ordering)
INDArray	BaseComplexNDArray.getReal()
INDArray	IComplexNDArray.getReal() Gets the real portion of this complex ndarray
INDArray	BaseComplexNDArray.imag() Get imaginary part of the matrix.
INDArray	IComplexNDArray.imag()
INDArray	BaseComplexNDArray.putScalar(int[] i, double value)
INDArray	IComplexNDArray.putScalar(int[] i, IComplexNumber complexNumber)
INDArray	BaseComplexNDArray.real() Get realComponent part of the matrix.
INDArray	IComplexNDArray.real()

Methods in org.nd4j.linalg.api.complex with parameters of type INDArray

Modifier and Type	Method and Description
IComplexNDArray	BaseComplexNDArray.add(IComplexNumber n, INDArray result)
IComplexNDArray	IComplexNDArray.add(IComplexNumber n, INDArray result)
IComplexNDArray	BaseComplexNDArray.add(INDArray other) copy addition of two matrices
IComplexNDArray	IComplexNDArray.add(INDArray other) copy addition of two matrices
IComplexNDArray	BaseComplexNDArray.add(INDArray other, INDArray result) copy addition of two matrices
IComplexNDArray	IComplexNDArray.add(INDArray other, INDArray result) copy addition of two matrices
IComplexNDArray	BaseComplexNDArray.add(Number n, INDArray result)
IComplexNDArray	IComplexNDArray.add(Number n, INDArray result)
IComplexNDArray	BaseComplexNDArray.addColumnVector(INDArray columnVector) In place addition of a column vector
IComplexNDArray	IComplexNDArray.addColumnVector(INDArray columnVector) In place addition of a column vector
IComplexNDArray	BaseComplexNDArray.addi(IComplexNumber n, INDArray result)
IComplexNDArray	IComplexNDArray.addi(IComplexNumber n, INDArray result)
IComplexNDArray	BaseComplexNDArray.addi(INDArray other) in place addition of two matrices
IComplexNDArray	IComplexNDArray.addi(INDArray other) in place addition of two matrices
IComplexNDArray	BaseComplexNDArray.addi(INDArray other, INDArray result) in place addition of two matrices
IComplexNDArray	IComplexNDArray.addi(INDArray other, INDArray result) in place addition of two matrices
IComplexNDArray	BaseComplexNDArray.addi(Number n, INDArray result)
IComplexNDArray	IComplexNDArray.addi(Number n, INDArray result)
IComplexNDArray	BaseComplexNDArray.addiColumnVector(INDArray columnVector) In place addition of a column vector
IComplexNDArray	IComplexNDArray.addiColumnVector(INDArray columnVector) In place addition of a column vector
IComplexNDArray	BaseComplexNDArray.addiRowVector(INDArray rowVector) In place addition of a column vector
IComplexNDArray	IComplexNDArray.addiRowVector(INDArray rowVector) In place addition of a column vector
IComplexNDArray	BaseComplexNDArray.addRowVector(INDArray rowVector) In place addition of a column vector
IComplexNDArray	IComplexNDArray.addRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseComplexNDArray.assign(INDArray arr) Assign all of the elements in the given ndarray to this nedarray
void	BaseComplexNDArray.checkDimensions(INDArray other) Validate dimensions are equal
void	IComplexNDArray.checkDimensions(INDArray other) Validate dimensions are equal
protected void	LinearViewComplexNDArray.collectRows(INDArray slice)
protected void	BaseComplexNDArray.copyFromReal(INDArray real)
protected void	BaseComplexNDArray.copyRealTo(INDArray arr)
protected IComplexNDArray	BaseComplexNDArray.create(INDArray baseNDArray)
double	BaseComplexNDArray.distance1(INDArray other) Returns the (1-norm) distance.
double	BaseComplexNDArray.distance2(INDArray other) Returns the (euclidean) distance.
IComplexNDArray	BaseComplexNDArray.div(IComplexNumber n, INDArray result)
IComplexNDArray	IComplexNDArray.div(IComplexNumber n, INDArray result)
IComplexNDArray	BaseComplexNDArray.div(INDArray other) in place (element wise) division of two matrices
IComplexNDArray	IComplexNDArray.div(INDArray other) in place (element wise) division of two matrices
IComplexNDArray	BaseComplexNDArray.div(INDArray other, INDArray result) copy (element wise) division of two matrices
IComplexNDArray	IComplexNDArray.div(INDArray other, INDArray result) copy (element wise) division of two matrices
IComplexNDArray	BaseComplexNDArray.div(Number n, INDArray result)
IComplexNDArray	IComplexNDArray.div(Number n, INDArray result)
IComplexNDArray	BaseComplexNDArray.divColumnVector(INDArray columnVector) In place addition of a column vector
IComplexNDArray	IComplexNDArray.divColumnVector(INDArray columnVector) In place addition of a column vector
IComplexNDArray	BaseComplexNDArray.divi(IComplexNumber n, INDArray result)
IComplexNDArray	IComplexNDArray.divi(IComplexNumber n, INDArray result)
IComplexNDArray	BaseComplexNDArray.divi(INDArray other) in place (element wise) division of two matrices
IComplexNDArray	IComplexNDArray.divi(INDArray other) in place (element wise) division of two matrices
IComplexNDArray	BaseComplexNDArray.divi(INDArray other, INDArray result) in place (element wise) division of two matrices
IComplexNDArray	IComplexNDArray.divi(INDArray other, INDArray result) in place (element wise) division of two matrices
IComplexNDArray	BaseComplexNDArray.divi(Number n, INDArray result)
IComplexNDArray	IComplexNDArray.divi(Number n, INDArray result)
IComplexNDArray	BaseComplexNDArray.diviColumnVector(INDArray columnVector) In place addition of a column vector
IComplexNDArray	IComplexNDArray.diviColumnVector(INDArray columnVector) In place addition of a column vector
IComplexNDArray	BaseComplexNDArray.diviRowVector(INDArray rowVector) In place addition of a column vector
IComplexNDArray	IComplexNDArray.diviRowVector(INDArray rowVector) In place addition of a column vector
IComplexNDArray	BaseComplexNDArray.divRowVector(INDArray rowVector) In place addition of a column vector
IComplexNDArray	IComplexNDArray.divRowVector(INDArray rowVector) In place addition of a column vector
protected IComplexNDArray	BaseComplexNDArray.doColumnWise(INDArray columnVector, char operation)
protected IComplexNDArray	BaseComplexNDArray.doRowWise(INDArray rowVector, char operation)
IComplexNDArray	BaseComplexNDArray.eps(INDArray other) epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
IComplexNDArray	IComplexNDArray.eps(INDArray other) epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
IComplexNDArray	BaseComplexNDArray.epsi(INDArray other) In place epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
IComplexNDArray	IComplexNDArray.epsi(INDArray other) In place epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
IComplexNDArray	BaseComplexNDArray.eq(INDArray other)
IComplexNDArray	IComplexNDArray.eq(INDArray other)
IComplexNDArray	BaseComplexNDArray.eqi(INDArray other)
IComplexNDArray	IComplexNDArray.eqi(INDArray other)
IComplexNDArray	BaseComplexNDArray.gt(INDArray other)
IComplexNDArray	IComplexNDArray.gt(INDArray other)
IComplexNDArray	BaseComplexNDArray.gti(INDArray other)
IComplexNDArray	IComplexNDArray.gti(INDArray other)
IComplexNDArray	BaseComplexNDArray.lt(INDArray other)
IComplexNDArray	IComplexNDArray.lt(INDArray other)
IComplexNDArray	BaseComplexNDArray.lti(INDArray other)
IComplexNDArray	IComplexNDArray.lti(INDArray other)
IComplexNDArray	BaseComplexNDArray.mmul(INDArray other) Perform a copy matrix multiplication
IComplexNDArray	IComplexNDArray.mmul(INDArray other) Perform a copy matrix multiplication
IComplexNDArray	BaseComplexNDArray.mmul(INDArray other, INDArray result) Perform an copy matrix multiplication
IComplexNDArray	IComplexNDArray.mmul(INDArray other, INDArray result) Perform an copy matrix multiplication
IComplexNDArray	BaseComplexNDArray.mmuli(INDArray other) Perform an copy matrix multiplication
IComplexNDArray	IComplexNDArray.mmuli(INDArray other) Perform an copy matrix multiplication
IComplexNDArray	BaseComplexNDArray.mmuli(INDArray other, INDArray result) Perform an copy matrix multiplication
IComplexNDArray	IComplexNDArray.mmuli(INDArray other, INDArray result) Perform an copy matrix multiplication
IComplexNDArray	BaseComplexNDArray.mul(IComplexNumber n, INDArray result)
IComplexNDArray	IComplexNDArray.mul(IComplexNumber n, INDArray result)
IComplexNDArray	BaseComplexNDArray.mul(INDArray other) copy (element wise) multiplication of two matrices
IComplexNDArray	IComplexNDArray.mul(INDArray other) copy (element wise) multiplication of two matrices
IComplexNDArray	BaseComplexNDArray.mul(INDArray other, INDArray result) copy (element wise) multiplication of two matrices
IComplexNDArray	IComplexNDArray.mul(INDArray other, INDArray result) copy (element wise) multiplication of two matrices
IComplexNDArray	BaseComplexNDArray.mul(Number n, INDArray result)
IComplexNDArray	IComplexNDArray.mul(Number n, INDArray result)
IComplexNDArray	BaseComplexNDArray.mulColumnVector(INDArray columnVector) In place addition of a column vector
IComplexNDArray	IComplexNDArray.mulColumnVector(INDArray columnVector) In place addition of a column vector
IComplexNDArray	BaseComplexNDArray.muli(IComplexNumber n, INDArray result)
IComplexNDArray	IComplexNDArray.muli(IComplexNumber n, INDArray result)
IComplexNDArray	BaseComplexNDArray.muli(INDArray other) in place (element wise) multiplication of two matrices
IComplexNDArray	IComplexNDArray.muli(INDArray other) in place (element wise) multiplication of two matrices
IComplexNDArray	BaseComplexNDArray.muli(INDArray other, INDArray result) in place (element wise) multiplication of two matrices
IComplexNDArray	IComplexNDArray.muli(INDArray other, INDArray result) in place (element wise) multiplication of two matrices
IComplexNDArray	BaseComplexNDArray.muli(Number n, INDArray result)
IComplexNDArray	IComplexNDArray.muli(Number n, INDArray result)
IComplexNDArray	BaseComplexNDArray.muliColumnVector(INDArray columnVector) In place addition of a column vector
IComplexNDArray	IComplexNDArray.muliColumnVector(INDArray columnVector) In place addition of a column vector
IComplexNDArray	BaseComplexNDArray.muliRowVector(INDArray rowVector) In place addition of a column vector
IComplexNDArray	IComplexNDArray.muliRowVector(INDArray rowVector) In place addition of a column vector
IComplexNDArray	BaseComplexNDArray.mulRowVector(INDArray rowVector) In place addition of a column vector
IComplexNDArray	IComplexNDArray.mulRowVector(INDArray rowVector) In place addition of a column vector
IComplexNDArray	BaseComplexNDArray.neq(INDArray other)
IComplexNDArray	IComplexNDArray.neq(INDArray other)
IComplexNDArray	BaseComplexNDArray.neqi(INDArray other)
IComplexNDArray	IComplexNDArray.neqi(INDArray other)
IComplexNDArray	BaseComplexNDArray.put(int[] indices, INDArray element) Inserts the element at the specified index
IComplexNDArray	IComplexNDArray.put(int[] indices, INDArray element) Inserts the element at the specified index
IComplexNDArray	BaseComplexNDArray.put(int i, INDArray element) Inserts the element at the specified index
IComplexNDArray	IComplexNDArray.put(int i, INDArray element) Inserts the element at the specified index
IComplexNDArray	BaseComplexNDArray.put(int i, int j, INDArray element) Inserts the element at the specified index
IComplexNDArray	IComplexNDArray.put(int i, int j, INDArray element) Inserts the element at the specified index
IComplexNDArray	BaseComplexNDArray.put(NDArrayIndex[] indices, INDArray element)
IComplexNDArray	BaseComplexNDArray.putColumn(int column, INDArray toPut) Insert a column in to this array Will throw an exception if this ndarray is not a matrix
IComplexNDArray	IComplexNDArray.putColumn(int column, INDArray toPut) Insert a column in to this array Will throw an exception if this ndarray is not a matrix
IComplexNDArray	BaseComplexNDArray.putRow(int row, INDArray toPut) Insert a row in to this array Will throw an exception if this ndarray is not a matrix
IComplexNDArray	IComplexNDArray.putRow(int row, INDArray toPut) Insert a row in to this array Will throw an exception if this ndarray is not a matrix
IComplexNDArray	BaseComplexNDArray.putSlice(int slice, INDArray put) Assigns the given matrix (put) to the specified slice
IComplexNDArray	IComplexNDArray.putSlice(int slice, INDArray put) Assigns the given matrix (put) to the specified slice
IComplexNDArray	BaseComplexNDArray.rdiv(IComplexNumber n, INDArray result)
IComplexNDArray	IComplexNDArray.rdiv(IComplexNumber n, INDArray result)
IComplexNDArray	BaseComplexNDArray.rdiv(INDArray other) Reverse division
IComplexNDArray	IComplexNDArray.rdiv(INDArray other) Reverse division
IComplexNDArray	BaseComplexNDArray.rdiv(INDArray other, INDArray result) Reverse division
IComplexNDArray	IComplexNDArray.rdiv(INDArray other, INDArray result) Reverse division
IComplexNDArray	BaseComplexNDArray.rdiv(Number n, INDArray result)
IComplexNDArray	IComplexNDArray.rdiv(Number n, INDArray result)
IComplexNDArray	BaseComplexNDArray.rdivColumnVector(INDArray columnVector)
IComplexNDArray	IComplexNDArray.rdivColumnVector(INDArray columnVector)
IComplexNDArray	BaseComplexNDArray.rdivi(IComplexNumber n, INDArray result)
IComplexNDArray	IComplexNDArray.rdivi(IComplexNumber n, INDArray result)
IComplexNDArray	BaseComplexNDArray.rdivi(INDArray other) Reverse divsion (in place)
IComplexNDArray	IComplexNDArray.rdivi(INDArray other) Reverse divsion (in place)
IComplexNDArray	BaseComplexNDArray.rdivi(INDArray other, INDArray result) Reverse division (in-place)
IComplexNDArray	IComplexNDArray.rdivi(INDArray other, INDArray result) Reverse division (in-place)
IComplexNDArray	BaseComplexNDArray.rdivi(Number n, INDArray result)
IComplexNDArray	IComplexNDArray.rdivi(Number n, INDArray result)
IComplexNDArray	BaseComplexNDArray.rdiviColumnVector(INDArray columnVector)
IComplexNDArray	IComplexNDArray.rdiviColumnVector(INDArray columnVector)
IComplexNDArray	BaseComplexNDArray.rdiviRowVector(INDArray rowVector)
IComplexNDArray	IComplexNDArray.rdiviRowVector(INDArray rowVector)
IComplexNDArray	BaseComplexNDArray.rdivRowVector(INDArray rowVector)
IComplexNDArray	IComplexNDArray.rdivRowVector(INDArray rowVector)
IComplexNDArray	BaseComplexNDArray.rsub(IComplexNumber n, INDArray result)
IComplexNDArray	IComplexNDArray.rsub(IComplexNumber n, INDArray result)
IComplexNDArray	BaseComplexNDArray.rsub(INDArray other)
IComplexNDArray	IComplexNDArray.rsub(INDArray other)
IComplexNDArray	BaseComplexNDArray.rsub(INDArray other, INDArray result) Reverse subtraction
IComplexNDArray	IComplexNDArray.rsub(INDArray other, INDArray result) Reverse subtraction
IComplexNDArray	BaseComplexNDArray.rsub(Number n, INDArray result)
IComplexNDArray	IComplexNDArray.rsub(Number n, INDArray result)
IComplexNDArray	BaseComplexNDArray.rsubColumnVector(INDArray columnVector)
IComplexNDArray	IComplexNDArray.rsubColumnVector(INDArray columnVector)
IComplexNDArray	BaseComplexNDArray.rsubi(IComplexNumber n, INDArray result)
IComplexNDArray	IComplexNDArray.rsubi(IComplexNumber n, INDArray result)
IComplexNDArray	BaseComplexNDArray.rsubi(INDArray other)
IComplexNDArray	IComplexNDArray.rsubi(INDArray other)
IComplexNDArray	BaseComplexNDArray.rsubi(INDArray other, INDArray result) Reverse subtraction (in-place)
IComplexNDArray	IComplexNDArray.rsubi(INDArray other, INDArray result) Reverse subtraction (in-place)
IComplexNDArray	BaseComplexNDArray.rsubi(Number n, INDArray result)
IComplexNDArray	IComplexNDArray.rsubi(Number n, INDArray result)
IComplexNDArray	BaseComplexNDArray.rsubiColumnVector(INDArray columnVector)
IComplexNDArray	IComplexNDArray.rsubiColumnVector(INDArray columnVector)
IComplexNDArray	BaseComplexNDArray.rsubiRowVector(INDArray rowVector)
IComplexNDArray	IComplexNDArray.rsubiRowVector(INDArray rowVector)
IComplexNDArray	BaseComplexNDArray.rsubRowVector(INDArray rowVector)
IComplexNDArray	IComplexNDArray.rsubRowVector(INDArray rowVector)
double	BaseComplexNDArray.squaredDistance(INDArray other) Returns the squared (Euclidean) distance.
IComplexNDArray	BaseComplexNDArray.sub(IComplexNumber n, INDArray result)
IComplexNDArray	IComplexNDArray.sub(IComplexNumber n, INDArray result)
IComplexNDArray	BaseComplexNDArray.sub(INDArray other) copy subtraction of two matrices
IComplexNDArray	IComplexNDArray.sub(INDArray other) copy subtraction of two matrices
IComplexNDArray	BaseComplexNDArray.sub(INDArray other, INDArray result) copy subtraction of two matrices
IComplexNDArray	IComplexNDArray.sub(INDArray other, INDArray result) copy subtraction of two matrices
IComplexNDArray	BaseComplexNDArray.sub(Number n, INDArray result)
IComplexNDArray	IComplexNDArray.sub(Number n, INDArray result)
IComplexNDArray	BaseComplexNDArray.subColumnVector(INDArray columnVector) In place addition of a column vector
IComplexNDArray	IComplexNDArray.subColumnVector(INDArray columnVector) In place addition of a column vector
IComplexNDArray	BaseComplexNDArray.subi(IComplexNumber n, INDArray result)
IComplexNDArray	IComplexNDArray.subi(IComplexNumber n, INDArray result)
IComplexNDArray	BaseComplexNDArray.subi(INDArray other) in place subtraction of two matrices
IComplexNDArray	IComplexNDArray.subi(INDArray other) in place subtraction of two matrices
IComplexNDArray	BaseComplexNDArray.subi(INDArray other, INDArray result) in place subtraction of two matrices
IComplexNDArray	IComplexNDArray.subi(INDArray other, INDArray result) in place subtraction of two matrices
IComplexNDArray	BaseComplexNDArray.subi(Number n, INDArray result)
IComplexNDArray	IComplexNDArray.subi(Number n, INDArray result)
IComplexNDArray	BaseComplexNDArray.subiColumnVector(INDArray columnVector) In place addition of a column vector
IComplexNDArray	IComplexNDArray.subiColumnVector(INDArray columnVector) In place addition of a column vector
IComplexNDArray	BaseComplexNDArray.subiRowVector(INDArray rowVector) In place addition of a column vector
IComplexNDArray	IComplexNDArray.subiRowVector(INDArray rowVector) In place addition of a column vector
IComplexNDArray	BaseComplexNDArray.subRowVector(INDArray rowVector) In place addition of a column vector
IComplexNDArray	IComplexNDArray.subRowVector(INDArray rowVector) In place addition of a column vector

Constructors in org.nd4j.linalg.api.complex with parameters of type INDArray

Constructor and Description
BaseComplexNDArray(INDArray m) Construct a complex matrix from a realComponent matrix.
BaseComplexNDArray(INDArray m, char ordering) Construct a complex matrix from a realComponent matrix.
BaseComplexNDArray(INDArray m, int[] stride) Create with the specified ndarray as the real component and the given stride
BaseComplexNDArray(INDArray m, int[] stride, char ordering) Initialize the given ndarray as the real component

Uses of INDArray in org.nd4j.linalg.api.instrumentation

Methods in org.nd4j.linalg.api.instrumentation with parameters of type INDArray

Modifier and Type	Method and Description
void	InMemoryInstrumentation.log(INDArray toLog)
void	Instrumentation.log(INDArray toLog) Log the given ndarray
void	InMemoryInstrumentation.log(INDArray toLog, String status)
void	Instrumentation.log(INDArray toLog, String status) Log the given ndarray

Constructors in org.nd4j.linalg.api.instrumentation with parameters of type INDArray

Constructor and Description
LogEntry(INDArray toLog)
LogEntry(INDArray toLog, StackTraceElement[] stackTraceElements)
LogEntry(INDArray toLog, StackTraceElement[] stackTraceElements, String status)
LogEntry(INDArray toLog, String status)

Uses of INDArray in org.nd4j.linalg.api.io

Methods in org.nd4j.linalg.api.io that return INDArray

Modifier and Type	Method and Description
INDArray	NDArrayIO.read(File file) Read in an ndarray from a file
INDArray	BaseNDArrayIO.read(File file) Read in an ndarray from a file
INDArray	NDArrayIO.read(InputStream is) Read in an ndrray from an input stream

Methods in org.nd4j.linalg.api.io with parameters of type INDArray

Modifier and Type	Method and Description
void	NDArrayIO.write(INDArray out, File to) Write an ndarray to the output stream
void	BaseNDArrayIO.write(INDArray out, File to) Write an ndarray to the output stream
void	NDArrayIO.write(INDArray out, OutputStream to) Write an ndarray to the output stream

Uses of INDArray in org.nd4j.linalg.api.ndarray

Classes in org.nd4j.linalg.api.ndarray that implement INDArray

Modifier and Type	Class and Description
class	BaseNDArray NDArray: (think numpy) A few things of note.
class	LinearViewNDArray Row vector view of an ndarray

Fields in org.nd4j.linalg.api.ndarray declared as INDArray

Modifier and Type	Field and Description
protected INDArray	BaseNDArray.linearView

Fields in org.nd4j.linalg.api.ndarray with type parameters of type INDArray

Modifier and Type	Field and Description
protected WeakReference<INDArray>	BaseNDArray.ref

Methods in org.nd4j.linalg.api.ndarray that return INDArray

Modifier and Type	Method and Description
INDArray	INDArray.add(INDArray other) copy addition of two matrices
INDArray	BaseNDArray.add(INDArray other) copy addition of two matrices
INDArray	INDArray.add(INDArray other, INDArray result) copy addition of two matrices
INDArray	BaseNDArray.add(INDArray other, INDArray result) copy addition of two matrices
INDArray	INDArray.add(Number n) Scalar addition (cloning)
INDArray	BaseNDArray.add(Number n)
INDArray	INDArray.add(Number n, INDArray result)
INDArray	BaseNDArray.add(Number n, INDArray result)
INDArray	INDArray.addColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.addColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	INDArray.addi(INDArray other) in place addition of two matrices
INDArray	BaseNDArray.addi(INDArray other) in place addition of two matrices
INDArray	INDArray.addi(INDArray other, INDArray result) in place addition of two matrices
INDArray	BaseNDArray.addi(INDArray other, INDArray result) in place addition of two matrices
INDArray	INDArray.addi(Number n) In place scalar addition
INDArray	BaseNDArray.addi(Number n)
INDArray	INDArray.addi(Number n, INDArray result) In place addition
INDArray	BaseNDArray.addi(Number n, INDArray result)
INDArray	INDArray.addiColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.addiColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	INDArray.addiRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.addiRowVector(INDArray rowVector) In place addition of a column vector
INDArray	INDArray.addRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.addRowVector(INDArray rowVector) In place addition of a column vector
INDArray	INDArray.assign(INDArray arr) Assign all of the elements in the given ndarray to this ndarray
INDArray	BaseNDArray.assign(INDArray arr) Assign all of the elements in the given ndarray to this ndarray
INDArray	INDArray.assign(Number value) Set the value of the ndarray to the specified value
INDArray	BaseNDArray.assign(Number value) Set the value of the ndarray to the specified value
INDArray	INDArray.broadcast(int... shape) Broadcasts this ndarray to be the specified shape
INDArray	BaseNDArray.broadcast(int[] shape) Broadcasts this ndarray to be the specified shape
INDArray	INDArray.cond(Condition condition) 1 in the ndarray if the element matches the condition 0 otherwise
INDArray	BaseNDArray.cond(Condition condition)
INDArray	INDArray.condi(Condition condition) 1 in the ndarray if the element matches the condition 0 otherwise
INDArray	BaseNDArray.condi(Condition condition)
protected INDArray	BaseNDArray.create(BaseNDArray baseNDArray)
protected INDArray	BaseNDArray.create(DataBuffer buffer)
protected INDArray	BaseNDArray.create(DataBuffer data, int[] shape, int offset)
protected INDArray	BaseNDArray.create(DataBuffer data, int[] newShape, int[] newStrides, int offset)
protected INDArray	BaseNDArray.create(DataBuffer data, int[] newShape, int[] newStrides, int offset, char ordering)
protected INDArray	BaseNDArray.create(int[] shape)
protected INDArray	BaseNDArray.create(int[] shape, char ordering)
protected INDArray	BaseNDArray.create(int[] shape, int[] strides, int offset)
protected INDArray	BaseNDArray.create(int rows, int length)
protected INDArray	BaseNDArray.createScalar(double d)
INDArray	INDArray.cumsum(int dimension) Cumulative sum along a dimension (in place)
INDArray	BaseNDArray.cumsum(int dimension) Cumulative sum along a dimension (in place)
INDArray	INDArray.cumsumi(int dimension) Cumulative sum along a dimension
INDArray	BaseNDArray.cumsumi(int dimension) Cumulative sum along a dimension
INDArray	INDArray.dimShuffle(Object[] rearrange, int[] newOrder, boolean[] broadCastable) Dimshuffle: an extension of permute that adds the ability to broadcast various dimensions.
INDArray	BaseNDArray.dimShuffle(Object[] rearrange, int[] newOrder, boolean[] broadCastable) Dimshuffle: an extension of permute that adds the ability to broadcast various dimensions.
INDArray	INDArray.div(INDArray other) in place (element wise) division of two matrices
INDArray	BaseNDArray.div(INDArray other) in place (element wise) division of two matrices
INDArray	INDArray.div(INDArray other, INDArray result) copy (element wise) division of two matrices
INDArray	BaseNDArray.div(INDArray other, INDArray result) copy (element wise) division of two matrices
INDArray	INDArray.div(Number n) Division by a number
INDArray	BaseNDArray.div(Number n)
INDArray	INDArray.div(Number n, INDArray result)
INDArray	BaseNDArray.div(Number n, INDArray result)
INDArray	INDArray.divColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.divColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	INDArray.divi(INDArray other) in place (element wise) division of two matrices
INDArray	BaseNDArray.divi(INDArray other) in place (element wise) division of two matrices
INDArray	INDArray.divi(INDArray other, INDArray result) in place (element wise) division of two matrices
INDArray	BaseNDArray.divi(INDArray other, INDArray result) in place (element wise) division of two matrices
INDArray	INDArray.divi(Number n) In place scalar division
INDArray	BaseNDArray.divi(Number n)
INDArray	INDArray.divi(Number n, INDArray result) In place division of this ndarray
INDArray	BaseNDArray.divi(Number n, INDArray result)
INDArray	INDArray.diviColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.diviColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	INDArray.diviRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.diviRowVector(INDArray rowVector) In place addition of a column vector
INDArray	INDArray.divRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.divRowVector(INDArray rowVector) In place addition of a column vector
protected INDArray	BaseNDArray.doColumnWise(INDArray columnVector, char operation) Do a row wise op (a,s,m,d) a : add s : subtract m : multiply d : divide h : reverse subtraction t : reverse division
protected INDArray	BaseNDArray.doRowWise(INDArray rowVector, char operation) Do a row wise op (a,s,m,d) a : add s : subtract m : multiply d : divide h : reverse subtraction t : reverse division
INDArray	INDArray.dup() Return a copy of this ndarray
INDArray	BaseNDArray.dup()
INDArray	INDArray.eps(INDArray other) epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.eps(INDArray other) epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	INDArray.eps(Number other) Returns an ndarray with 1 if the element is epsilon equals
INDArray	BaseNDArray.eps(Number other) Returns an ndarray with 1 if the element is epsilon equals
INDArray	INDArray.epsi(INDArray other) In place epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.epsi(INDArray other) In place epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	INDArray.epsi(Number other) Returns an ndarray with 1 if the element is epsilon equals
INDArray	BaseNDArray.epsi(Number other) Returns an ndarray with 1 if the element is epsilon equals
INDArray	INDArray.eq(INDArray other) equal than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.eq(INDArray other)
INDArray	INDArray.eq(Number other) Returns an ndarray with 1 if the element is less than the given element 0 other wise
INDArray	BaseNDArray.eq(Number other)
INDArray	INDArray.eqi(INDArray other) In place equal than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.eqi(INDArray other)
INDArray	INDArray.eqi(Number other) In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.eqi(Number other)
INDArray	INDArray.get(NDArrayIndex... indexes) Returns a subset of this array based on the specified indexes
INDArray	BaseNDArray.get(NDArrayIndex... indexes) Returns a subset of this array based on the specified indexes
INDArray	INDArray.getColumn(int i) Returns the specified column.
INDArray	BaseNDArray.getColumn(int c) Get the specified column
INDArray	INDArray.getColumns(int[] columns) Get a list of specified columns
INDArray	BaseNDArray.getColumns(int[] cindices) Get whole columns from the passed indices.
INDArray	INDArray.getRow(int i) Returns the specified row.
INDArray	BaseNDArray.getRow(int r) Get a copy of a row.
INDArray	INDArray.getRows(int[] rows) Get a list of rows
INDArray	BaseNDArray.getRows(int[] rindices) Get whole rows from the passed indices.
INDArray	BaseNDArray.getScalar(int... indexes) Fetch a particular number on a multi dimensional scale.
INDArray	INDArray.getScalar(int i) Returns the element at the specified index
INDArray	BaseNDArray.getScalar(int i)
INDArray	INDArray.getScalar(int[] indices) Returns the elements at the the specified indices
INDArray	INDArray.getScalar(int row, int column) Returns the element at the specified row/column This will throw an exception if the
INDArray	BaseNDArray.getScalar(int row, int column) Returns the element at the specified row/column This will throw an exception if the
INDArray	INDArray.gt(INDArray other) greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.gt(INDArray other)
INDArray	INDArray.gt(Number other) Greater than boolean (copying)(
INDArray	BaseNDArray.gt(Number other)
INDArray	INDArray.gti(INDArray other) In place greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.gti(INDArray other)
INDArray	INDArray.gti(Number other) In place greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.gti(Number other)
INDArray	LinearViewNDArray.linearView()
INDArray	INDArray.linearView() Returns a linear view reference of shape 1,length(ndarray)
INDArray	BaseNDArray.linearView() Returns a linear view reference of shape 1,length(ndarray)
INDArray	LinearViewNDArray.linearViewColumnOrder()
INDArray	INDArray.linearViewColumnOrder() Returns a linear view reference of shape 1,length(ndarray)
INDArray	BaseNDArray.linearViewColumnOrder()
INDArray	INDArray.lt(INDArray other) less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.lt(INDArray other)
INDArray	INDArray.lt(Number other) Returns an ndarray with 1 if the element is less than the given element 0 other wise
INDArray	BaseNDArray.lt(Number other)
INDArray	INDArray.lti(INDArray other) In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.lti(INDArray other)
INDArray	INDArray.lti(Number other) In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.lti(Number other)
INDArray	INDArray.max(int dimension) Returns the overall max of this ndarray
INDArray	BaseNDArray.max(int dimension) Returns the overall max of this ndarray
INDArray	INDArray.mean(int dimension) Returns the overall mean of this ndarray
INDArray	BaseNDArray.mean(int dimension) Returns the overall mean of this ndarray
INDArray	INDArray.min(int dimension) Returns the overall min of this ndarray
INDArray	BaseNDArray.min(int dimension) Returns the overall min of this ndarray
INDArray	INDArray.mmul(INDArray other) Perform a copy matrix multiplication
INDArray	BaseNDArray.mmul(INDArray other) Perform a copy matrix multiplication
INDArray	INDArray.mmul(INDArray other, INDArray result) Perform an copy matrix multiplication
INDArray	BaseNDArray.mmul(INDArray other, INDArray result) Perform an copy matrix multiplication
INDArray	INDArray.mmuli(INDArray other) Perform an copy matrix multiplication
INDArray	BaseNDArray.mmuli(INDArray other) Perform an copy matrix multiplication
INDArray	INDArray.mmuli(INDArray other, INDArray result) Perform an copy matrix multiplication
INDArray	BaseNDArray.mmuli(INDArray other, INDArray result) Perform an copy matrix multiplication
INDArray	INDArray.mul(INDArray other) copy (element wise) multiplication of two matrices
INDArray	BaseNDArray.mul(INDArray other) copy (element wise) multiplication of two matrices
INDArray	INDArray.mul(INDArray other, INDArray result) copy (element wise) multiplication of two matrices
INDArray	BaseNDArray.mul(INDArray other, INDArray result) copy (element wise) multiplication of two matrices
INDArray	INDArray.mul(Number n) Scalar multiplication (copy)
INDArray	BaseNDArray.mul(Number n)
INDArray	INDArray.mul(Number n, INDArray result)
INDArray	BaseNDArray.mul(Number n, INDArray result)
INDArray	INDArray.mulColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.mulColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	INDArray.muli(INDArray other) in place (element wise) multiplication of two matrices
INDArray	BaseNDArray.muli(INDArray other) in place (element wise) multiplication of two matrices
INDArray	INDArray.muli(INDArray other, INDArray result) in place (element wise) multiplication of two matrices
INDArray	BaseNDArray.muli(INDArray other, INDArray result) in place (element wise) multiplication of two matrices
INDArray	INDArray.muli(Number n) In place scalar multiplication
INDArray	BaseNDArray.muli(Number n)
INDArray	INDArray.muli(Number n, INDArray result) In place multiplication of this ndarray
INDArray	BaseNDArray.muli(Number n, INDArray result)
INDArray	INDArray.muliColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.muliColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	INDArray.muliRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.muliRowVector(INDArray rowVector) In place addition of a column vector
INDArray	INDArray.mulRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.mulRowVector(INDArray rowVector) In place addition of a column vector
INDArray	INDArray.neg() Returns the ndarray negative (cloned)
INDArray	BaseNDArray.neg() Negate each element.
INDArray	INDArray.negi() In place setting of the negative version of this ndarray
INDArray	BaseNDArray.negi() Negate each element (in-place).
INDArray	INDArray.neq(INDArray other)
INDArray	BaseNDArray.neq(INDArray other)
INDArray	INDArray.neq(Number other)
INDArray	BaseNDArray.neq(Number other)
INDArray	INDArray.neqi(INDArray other)
INDArray	BaseNDArray.neqi(INDArray other)
INDArray	INDArray.neqi(Number other)
INDArray	BaseNDArray.neqi(Number other)
protected INDArray	BaseNDArray.newShape(int[] newShape, char ordering)
INDArray	INDArray.norm1(int dimension) Returns the norm1 along the specified dimension
INDArray	BaseNDArray.norm1(int dimension) Returns the norm1 along the specified dimension
INDArray	INDArray.norm2(int dimension) Returns the norm2 along the specified dimension
INDArray	BaseNDArray.norm2(int dimension) Returns the norm2 along the specified dimension
INDArray	INDArray.normmax(int dimension) Returns the normmax along the specified dimension
INDArray	BaseNDArray.normmax(int dimension) Returns the normmax along the specified dimension
INDArray	INDArray.permute(int... rearrange) See: http://www.mathworks.com/help/matlab/ref/permute.html
INDArray	BaseNDArray.permute(int[] rearrange) See: http://www.mathworks.com/help/matlab/ref/permute.htsliceml
INDArray	INDArray.prod(int dimension) Returns the product along a given dimension
INDArray	BaseNDArray.prod(int dimension) Returns the product along a given dimension
INDArray	INDArray.put(int[] indices, INDArray element) Inserts the element at the specified index
INDArray	BaseNDArray.put(int[] indices, INDArray element) Inserts the element at the specified index
INDArray	INDArray.put(int i, INDArray element) Inserts the element at the specified index
INDArray	BaseNDArray.put(int i, INDArray element) Inserts the element at the specified index
INDArray	INDArray.put(int i, int j, INDArray element) Inserts the element at the specified index
INDArray	BaseNDArray.put(int i, int j, INDArray element) Inserts the element at the specified index
INDArray	INDArray.put(int i, int j, Number element) Inserts the element at the specified index
INDArray	BaseNDArray.put(int i, int j, Number element) Inserts the element at the specified index
INDArray	INDArray.put(NDArrayIndex[] indices, INDArray element) Put the elements of the ndarray in to the specified indices
INDArray	BaseNDArray.put(NDArrayIndex[] indices, INDArray element)
INDArray	INDArray.put(NDArrayIndex[] indices, Number element) Put the elements of the ndarray in to the specified indices
INDArray	BaseNDArray.put(NDArrayIndex[] indices, Number element)
INDArray	INDArray.putColumn(int column, INDArray toPut) Insert a column in to this array Will throw an exception if this ndarray is not a matrix
INDArray	BaseNDArray.putColumn(int column, INDArray toPut) Insert a column in to this array Will throw an exception if this ndarray is not a matrix
INDArray	INDArray.putRow(int row, INDArray toPut) Insert a row in to this array Will throw an exception if this ndarray is not a matrix
INDArray	BaseNDArray.putRow(int row, INDArray toPut) Insert a row in to this array Will throw an exception if this ndarray is not a matrix
INDArray	INDArray.putScalar(int[] i, double value) Insert the item at the specified indices
INDArray	BaseNDArray.putScalar(int[] indexes, double value)
INDArray	INDArray.putScalar(int[] indexes, float value)
INDArray	BaseNDArray.putScalar(int[] indexes, float value)
INDArray	INDArray.putScalar(int[] indexes, int value)
INDArray	BaseNDArray.putScalar(int[] indexes, int value)
INDArray	LinearViewNDArray.putScalar(int i, double value)
INDArray	INDArray.putScalar(int i, double value) Insert the number linearly in to the ndarray
INDArray	BaseNDArray.putScalar(int i, double value)
INDArray	INDArray.putScalar(int i, float value) Insert a scalar float at the specified index
INDArray	BaseNDArray.putScalar(int i, float value)
INDArray	INDArray.putScalar(int i, int value) Insert a scalar int at the specified index
INDArray	BaseNDArray.putScalar(int i, int value)
INDArray	INDArray.putSlice(int slice, INDArray put) Assigns the given matrix (put) to the specified slice
INDArray	BaseNDArray.putSlice(int slice, INDArray put) Assigns the given matrix (put) to the specified slice
INDArray	INDArray.ravel() Returns a flattened version (row vector) of this ndarray
INDArray	BaseNDArray.ravel() Flattens the array for linear indexing
INDArray	INDArray.rdiv(INDArray other) Reverse division
INDArray	BaseNDArray.rdiv(INDArray other) Reverse division
INDArray	INDArray.rdiv(INDArray other, INDArray result) Reverse division
INDArray	BaseNDArray.rdiv(INDArray other, INDArray result) Reverse division
INDArray	INDArray.rdiv(Number n) Reverse division
INDArray	BaseNDArray.rdiv(Number n)
INDArray	INDArray.rdiv(Number n, INDArray result) Reverse division (number / ndarray)
INDArray	BaseNDArray.rdiv(Number n, INDArray result)
INDArray	INDArray.rdivColumnVector(INDArray columnVector) In place reverse division of a column vector
INDArray	BaseNDArray.rdivColumnVector(INDArray columnVector)
INDArray	INDArray.rdivi(INDArray other) Reverse divsion (in place)
INDArray	BaseNDArray.rdivi(INDArray other) Reverse divsion (in place)
INDArray	INDArray.rdivi(INDArray other, INDArray result) Reverse division (in-place)
INDArray	BaseNDArray.rdivi(INDArray other, INDArray result) Reverse division (in-place)
INDArray	INDArray.rdivi(Number n) In place reverse division
INDArray	BaseNDArray.rdivi(Number n)
INDArray	INDArray.rdivi(Number n, INDArray result) Reverse in place division
INDArray	BaseNDArray.rdivi(Number n, INDArray result)
INDArray	INDArray.rdiviColumnVector(INDArray columnVector) In place reverse divison of a column vector
INDArray	BaseNDArray.rdiviColumnVector(INDArray columnVector)
INDArray	INDArray.rdiviRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.rdiviRowVector(INDArray rowVector)
INDArray	INDArray.rdivRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.rdivRowVector(INDArray rowVector)
INDArray	INDArray.repmat(int... shape) Replicate and tile array to fill out to the given shape
INDArray	BaseNDArray.repmat(int[] shape) Replicate and tile array to fill out to the given shape
INDArray	INDArray.reshape(int... newShape) Reshapes the ndarray (can't change the length of the ndarray)
INDArray	BaseNDArray.reshape(int[] shape) Reshape the ndarray in to the specified dimensions, possible errors being thrown for invalid shapes
INDArray	INDArray.reshape(int rows, int columns) Reshapes the ndarray (can't change the length of the ndarray)
INDArray	BaseNDArray.reshape(int newRows, int newColumns) Reshape the matrix.
INDArray	INDArray.rsub(INDArray other)
INDArray	BaseNDArray.rsub(INDArray other)
INDArray	INDArray.rsub(INDArray other, INDArray result) Reverse subtraction
INDArray	BaseNDArray.rsub(INDArray other, INDArray result) Reverse subtraction
INDArray	INDArray.rsub(Number n) Reverse subtraction with duplicates
INDArray	BaseNDArray.rsub(Number n)
INDArray	INDArray.rsub(Number n, INDArray result) Reverse subtraction
INDArray	BaseNDArray.rsub(Number n, INDArray result)
INDArray	INDArray.rsubColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.rsubColumnVector(INDArray columnVector)
INDArray	INDArray.rsubi(INDArray other)
INDArray	BaseNDArray.rsubi(INDArray other)
INDArray	INDArray.rsubi(INDArray other, INDArray result) Reverse subtraction (in-place)
INDArray	BaseNDArray.rsubi(INDArray other, INDArray result) Reverse subtraction (in-place)
INDArray	INDArray.rsubi(Number n)
INDArray	BaseNDArray.rsubi(Number n)
INDArray	INDArray.rsubi(Number n, INDArray result) Reverse in place subtraction
INDArray	BaseNDArray.rsubi(Number n, INDArray result)
INDArray	INDArray.rsubiColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.rsubiColumnVector(INDArray columnVector)
INDArray	INDArray.rsubiRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.rsubiRowVector(INDArray rowVector)
INDArray	INDArray.rsubRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.rsubRowVector(INDArray rowVector)
INDArray	INDArray.slice(int i) Returns the specified slice of this ndarray
INDArray	BaseNDArray.slice(int slice) Returns the specified slice of this matrix.
INDArray	INDArray.slice(int i, int dimension) Returns the specified slice of this ndarray
INDArray	BaseNDArray.slice(int slice, int dimension) Returns the slice of this from the specified dimension
INDArray	INDArray.std(int dimension) Standard deviation of an ndarray along a dimension
INDArray	BaseNDArray.std(int dimension) Standard deviation of an ndarray along a dimension
INDArray	INDArray.sub(INDArray other) copy subtraction of two matrices
INDArray	BaseNDArray.sub(INDArray other) copy subtraction of two matrices
INDArray	INDArray.sub(INDArray other, INDArray result) copy subtraction of two matrices
INDArray	BaseNDArray.sub(INDArray other, INDArray result) copy subtraction of two matrices
INDArray	INDArray.sub(Number n) Scalar subtraction (copied)
INDArray	BaseNDArray.sub(Number n)
INDArray	INDArray.sub(Number n, INDArray result)
INDArray	BaseNDArray.sub(Number n, INDArray result)
INDArray	INDArray.subArray(int[] offsets, int[] shape, int[] stride)
INDArray	BaseNDArray.subArray(int[] offsets, int[] shape, int[] stride)
INDArray	INDArray.subColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.subColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	INDArray.subi(INDArray other) in place subtraction of two matrices
INDArray	BaseNDArray.subi(INDArray other) in place subtraction of two matrices
INDArray	INDArray.subi(INDArray other, INDArray result) in place subtraction of two matrices
INDArray	BaseNDArray.subi(INDArray other, INDArray result) in place subtraction of two matrices
INDArray	INDArray.subi(Number n) In place scalar subtraction
INDArray	BaseNDArray.subi(Number n)
INDArray	INDArray.subi(Number n, INDArray result) In place subtraction of this ndarray
INDArray	BaseNDArray.subi(Number n, INDArray result)
INDArray	INDArray.subiColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.subiColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	INDArray.subiRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.subiRowVector(INDArray rowVector) In place addition of a column vector
INDArray	INDArray.subRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.subRowVector(INDArray rowVector) In place addition of a column vector
INDArray	INDArray.sum(int dimension) Returns the sum along the last dimension of this ndarray
INDArray	BaseNDArray.sum(int dimension) Returns the sum along the last dimension of this ndarray
INDArray	INDArray.swapAxes(int dimension, int with) Mainly here for people coming from numpy.
INDArray	BaseNDArray.swapAxes(int dimension, int with) Mainly here for people coming from numpy.
INDArray	INDArray.transpose() Flip the rows and columns of a matrix
INDArray	BaseNDArray.transpose() Return transposed copy of this matrix.
INDArray	INDArray.transposei() Flip the rows and columns of a matrix
INDArray	BaseNDArray.transposei() Return transposed version of this matrix.
INDArray	INDArray.var(int dimension) Returns the overall variance of this ndarray
INDArray	BaseNDArray.var(int dimension) Returns the overall variance of this ndarray
INDArray	LinearViewNDArray.vectorAlongDimension(int index, int dimension)
INDArray	INDArray.vectorAlongDimension(int index, int dimension) Get the vector along a particular dimension
INDArray	BaseNDArray.vectorAlongDimension(int index, int dimension) Get the vector along a particular dimension

Methods in org.nd4j.linalg.api.ndarray with parameters of type INDArray

Modifier and Type	Method and Description
INDArray	INDArray.add(INDArray other) copy addition of two matrices
INDArray	BaseNDArray.add(INDArray other) copy addition of two matrices
INDArray	INDArray.add(INDArray other, INDArray result) copy addition of two matrices
INDArray	BaseNDArray.add(INDArray other, INDArray result) copy addition of two matrices
INDArray	INDArray.add(Number n, INDArray result)
INDArray	BaseNDArray.add(Number n, INDArray result)
INDArray	INDArray.addColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.addColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	INDArray.addi(INDArray other) in place addition of two matrices
INDArray	BaseNDArray.addi(INDArray other) in place addition of two matrices
INDArray	INDArray.addi(INDArray other, INDArray result) in place addition of two matrices
INDArray	BaseNDArray.addi(INDArray other, INDArray result) in place addition of two matrices
INDArray	INDArray.addi(Number n, INDArray result) In place addition
INDArray	BaseNDArray.addi(Number n, INDArray result)
INDArray	INDArray.addiColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.addiColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	INDArray.addiRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.addiRowVector(INDArray rowVector) In place addition of a column vector
INDArray	INDArray.addRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.addRowVector(INDArray rowVector) In place addition of a column vector
protected void	BaseNDArray.assertColumnVector(INDArray column)
protected void	BaseNDArray.assertRowVector(INDArray rowVector)
protected void	BaseNDArray.assertSlice(INDArray put, int slice)
INDArray	INDArray.assign(INDArray arr) Assign all of the elements in the given ndarray to this ndarray
INDArray	BaseNDArray.assign(INDArray arr) Assign all of the elements in the given ndarray to this ndarray
void	INDArray.checkDimensions(INDArray other) Validate dimensions are equal
void	BaseNDArray.checkDimensions(INDArray other)
protected void	LinearViewNDArray.collectRows(INDArray slice)
protected void	BaseNDArray.copyRealTo(INDArray arr)
double	INDArray.distance1(INDArray other) Returns the (1-norm) distance.
double	BaseNDArray.distance1(INDArray other) Returns the (1-norm) distance.
double	INDArray.distance2(INDArray other) Returns the (euclidean) distance.
double	BaseNDArray.distance2(INDArray other) Returns the (euclidean) distance.
INDArray	INDArray.div(INDArray other) in place (element wise) division of two matrices
INDArray	BaseNDArray.div(INDArray other) in place (element wise) division of two matrices
INDArray	INDArray.div(INDArray other, INDArray result) copy (element wise) division of two matrices
INDArray	BaseNDArray.div(INDArray other, INDArray result) copy (element wise) division of two matrices
INDArray	INDArray.div(Number n, INDArray result)
INDArray	BaseNDArray.div(Number n, INDArray result)
INDArray	INDArray.divColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.divColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	INDArray.divi(INDArray other) in place (element wise) division of two matrices
INDArray	BaseNDArray.divi(INDArray other) in place (element wise) division of two matrices
INDArray	INDArray.divi(INDArray other, INDArray result) in place (element wise) division of two matrices
INDArray	BaseNDArray.divi(INDArray other, INDArray result) in place (element wise) division of two matrices
INDArray	INDArray.divi(Number n, INDArray result) In place division of this ndarray
INDArray	BaseNDArray.divi(Number n, INDArray result)
INDArray	INDArray.diviColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.diviColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	INDArray.diviRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.diviRowVector(INDArray rowVector) In place addition of a column vector
INDArray	INDArray.divRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.divRowVector(INDArray rowVector) In place addition of a column vector
protected INDArray	BaseNDArray.doColumnWise(INDArray columnVector, char operation) Do a row wise op (a,s,m,d) a : add s : subtract m : multiply d : divide h : reverse subtraction t : reverse division
protected INDArray	BaseNDArray.doRowWise(INDArray rowVector, char operation) Do a row wise op (a,s,m,d) a : add s : subtract m : multiply d : divide h : reverse subtraction t : reverse division
INDArray	INDArray.eps(INDArray other) epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.eps(INDArray other) epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	INDArray.epsi(INDArray other) In place epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.epsi(INDArray other) In place epsilon equals than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	INDArray.eq(INDArray other) equal than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.eq(INDArray other)
INDArray	INDArray.eqi(INDArray other) In place equal than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.eqi(INDArray other)
INDArray	INDArray.gt(INDArray other) greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.gt(INDArray other)
INDArray	INDArray.gti(INDArray other) In place greater than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.gti(INDArray other)
INDArray	INDArray.lt(INDArray other) less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.lt(INDArray other)
INDArray	INDArray.lti(INDArray other) In place less than comparison: If the given number is less than the comparison number the item is 0 otherwise 1
INDArray	BaseNDArray.lti(INDArray other)
INDArray	INDArray.mmul(INDArray other) Perform a copy matrix multiplication
INDArray	BaseNDArray.mmul(INDArray other) Perform a copy matrix multiplication
INDArray	INDArray.mmul(INDArray other, INDArray result) Perform an copy matrix multiplication
INDArray	BaseNDArray.mmul(INDArray other, INDArray result) Perform an copy matrix multiplication
INDArray	INDArray.mmuli(INDArray other) Perform an copy matrix multiplication
INDArray	BaseNDArray.mmuli(INDArray other) Perform an copy matrix multiplication
INDArray	INDArray.mmuli(INDArray other, INDArray result) Perform an copy matrix multiplication
INDArray	BaseNDArray.mmuli(INDArray other, INDArray result) Perform an copy matrix multiplication
INDArray	INDArray.mul(INDArray other) copy (element wise) multiplication of two matrices
INDArray	BaseNDArray.mul(INDArray other) copy (element wise) multiplication of two matrices
INDArray	INDArray.mul(INDArray other, INDArray result) copy (element wise) multiplication of two matrices
INDArray	BaseNDArray.mul(INDArray other, INDArray result) copy (element wise) multiplication of two matrices
INDArray	INDArray.mul(Number n, INDArray result)
INDArray	BaseNDArray.mul(Number n, INDArray result)
INDArray	INDArray.mulColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.mulColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	INDArray.muli(INDArray other) in place (element wise) multiplication of two matrices
INDArray	BaseNDArray.muli(INDArray other) in place (element wise) multiplication of two matrices
INDArray	INDArray.muli(INDArray other, INDArray result) in place (element wise) multiplication of two matrices
INDArray	BaseNDArray.muli(INDArray other, INDArray result) in place (element wise) multiplication of two matrices
INDArray	INDArray.muli(Number n, INDArray result) In place multiplication of this ndarray
INDArray	BaseNDArray.muli(Number n, INDArray result)
INDArray	INDArray.muliColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.muliColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	INDArray.muliRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.muliRowVector(INDArray rowVector) In place addition of a column vector
INDArray	INDArray.mulRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.mulRowVector(INDArray rowVector) In place addition of a column vector
INDArray	INDArray.neq(INDArray other)
INDArray	BaseNDArray.neq(INDArray other)
INDArray	INDArray.neqi(INDArray other)
INDArray	BaseNDArray.neqi(INDArray other)
INDArray	INDArray.put(int[] indices, INDArray element) Inserts the element at the specified index
INDArray	BaseNDArray.put(int[] indices, INDArray element) Inserts the element at the specified index
INDArray	INDArray.put(int i, INDArray element) Inserts the element at the specified index
INDArray	BaseNDArray.put(int i, INDArray element) Inserts the element at the specified index
INDArray	INDArray.put(int i, int j, INDArray element) Inserts the element at the specified index
INDArray	BaseNDArray.put(int i, int j, INDArray element) Inserts the element at the specified index
INDArray	INDArray.put(NDArrayIndex[] indices, INDArray element) Put the elements of the ndarray in to the specified indices
INDArray	BaseNDArray.put(NDArrayIndex[] indices, INDArray element)
INDArray	INDArray.putColumn(int column, INDArray toPut) Insert a column in to this array Will throw an exception if this ndarray is not a matrix
INDArray	BaseNDArray.putColumn(int column, INDArray toPut) Insert a column in to this array Will throw an exception if this ndarray is not a matrix
INDArray	INDArray.putRow(int row, INDArray toPut) Insert a row in to this array Will throw an exception if this ndarray is not a matrix
INDArray	BaseNDArray.putRow(int row, INDArray toPut) Insert a row in to this array Will throw an exception if this ndarray is not a matrix
INDArray	INDArray.putSlice(int slice, INDArray put) Assigns the given matrix (put) to the specified slice
INDArray	BaseNDArray.putSlice(int slice, INDArray put) Assigns the given matrix (put) to the specified slice
INDArray	INDArray.rdiv(INDArray other) Reverse division
INDArray	BaseNDArray.rdiv(INDArray other) Reverse division
INDArray	INDArray.rdiv(INDArray other, INDArray result) Reverse division
INDArray	BaseNDArray.rdiv(INDArray other, INDArray result) Reverse division
INDArray	INDArray.rdiv(Number n, INDArray result) Reverse division (number / ndarray)
INDArray	BaseNDArray.rdiv(Number n, INDArray result)
INDArray	INDArray.rdivColumnVector(INDArray columnVector) In place reverse division of a column vector
INDArray	BaseNDArray.rdivColumnVector(INDArray columnVector)
INDArray	INDArray.rdivi(INDArray other) Reverse divsion (in place)
INDArray	BaseNDArray.rdivi(INDArray other) Reverse divsion (in place)
INDArray	INDArray.rdivi(INDArray other, INDArray result) Reverse division (in-place)
INDArray	BaseNDArray.rdivi(INDArray other, INDArray result) Reverse division (in-place)
INDArray	INDArray.rdivi(Number n, INDArray result) Reverse in place division
INDArray	BaseNDArray.rdivi(Number n, INDArray result)
INDArray	INDArray.rdiviColumnVector(INDArray columnVector) In place reverse divison of a column vector
INDArray	BaseNDArray.rdiviColumnVector(INDArray columnVector)
INDArray	INDArray.rdiviRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.rdiviRowVector(INDArray rowVector)
INDArray	INDArray.rdivRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.rdivRowVector(INDArray rowVector)
INDArray	INDArray.rsub(INDArray other)
INDArray	BaseNDArray.rsub(INDArray other)
INDArray	INDArray.rsub(INDArray other, INDArray result) Reverse subtraction
INDArray	BaseNDArray.rsub(INDArray other, INDArray result) Reverse subtraction
INDArray	INDArray.rsub(Number n, INDArray result) Reverse subtraction
INDArray	BaseNDArray.rsub(Number n, INDArray result)
INDArray	INDArray.rsubColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.rsubColumnVector(INDArray columnVector)
INDArray	INDArray.rsubi(INDArray other)
INDArray	BaseNDArray.rsubi(INDArray other)
INDArray	INDArray.rsubi(INDArray other, INDArray result) Reverse subtraction (in-place)
INDArray	BaseNDArray.rsubi(INDArray other, INDArray result) Reverse subtraction (in-place)
INDArray	INDArray.rsubi(Number n, INDArray result) Reverse in place subtraction
INDArray	BaseNDArray.rsubi(Number n, INDArray result)
INDArray	INDArray.rsubiColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.rsubiColumnVector(INDArray columnVector)
INDArray	INDArray.rsubiRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.rsubiRowVector(INDArray rowVector)
INDArray	INDArray.rsubRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.rsubRowVector(INDArray rowVector)
double	INDArray.squaredDistance(INDArray other) Returns the squared (Euclidean) distance.
double	BaseNDArray.squaredDistance(INDArray other) Returns the squared (Euclidean) distance.
INDArray	INDArray.sub(INDArray other) copy subtraction of two matrices
INDArray	BaseNDArray.sub(INDArray other) copy subtraction of two matrices
INDArray	INDArray.sub(INDArray other, INDArray result) copy subtraction of two matrices
INDArray	BaseNDArray.sub(INDArray other, INDArray result) copy subtraction of two matrices
INDArray	INDArray.sub(Number n, INDArray result)
INDArray	BaseNDArray.sub(Number n, INDArray result)
INDArray	INDArray.subColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.subColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	INDArray.subi(INDArray other) in place subtraction of two matrices
INDArray	BaseNDArray.subi(INDArray other) in place subtraction of two matrices
INDArray	INDArray.subi(INDArray other, INDArray result) in place subtraction of two matrices
INDArray	BaseNDArray.subi(INDArray other, INDArray result) in place subtraction of two matrices
INDArray	INDArray.subi(Number n, INDArray result) In place subtraction of this ndarray
INDArray	BaseNDArray.subi(Number n, INDArray result)
INDArray	INDArray.subiColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	BaseNDArray.subiColumnVector(INDArray columnVector) In place addition of a column vector
INDArray	INDArray.subiRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.subiRowVector(INDArray rowVector) In place addition of a column vector
INDArray	INDArray.subRowVector(INDArray rowVector) In place addition of a column vector
INDArray	BaseNDArray.subRowVector(INDArray rowVector) In place addition of a column vector

Method parameters in org.nd4j.linalg.api.ndarray with type arguments of type INDArray

Modifier and Type	Method and Description
void	INDArray.sliceVectors(List<INDArray> list)
void	BaseNDArray.sliceVectors(List<INDArray> list) Flattens the array for linear indexing

Constructors in org.nd4j.linalg.api.ndarray with parameters of type INDArray

Constructor and Description
LinearViewNDArray(INDArray wrapped) Create the linear view from the given array

Constructor parameters in org.nd4j.linalg.api.ndarray with type arguments of type INDArray

Constructor and Description
BaseNDArray(List<INDArray> slices, int[] shape) Create an ndarray from the specified slices.
BaseNDArray(List<INDArray> slices, int[] shape, char ordering) Create an ndarray from the specified slices.
BaseNDArray(List<INDArray> slices, int[] shape, int[] stride) Create an ndarray from the specified slices.
BaseNDArray(List<INDArray> slices, int[] shape, int[] stride, char ordering) Create an ndarray from the specified slices.

Uses of INDArray in org.nd4j.linalg.api.ops

Fields in org.nd4j.linalg.api.ops declared as INDArray

Modifier and Type	Field and Description
protected INDArray	BaseOp.x
protected INDArray	BaseOp.y
protected INDArray	BaseOp.z

Methods in org.nd4j.linalg.api.ops that return INDArray

Modifier and Type	Method and Description
INDArray	BaseLossFunction.input()
INDArray	LossFunction.input() The true
INDArray	BaseLossFunction.output()
INDArray	LossFunction.output() The guess
INDArray	BaseOp.x()
INDArray	Op.x() The origin ndarray
INDArray	BaseOp.y()
INDArray	Op.y() The pairwise op ndarray
INDArray	BaseOp.z()
INDArray	Op.z() The resulting ndarray

Methods in org.nd4j.linalg.api.ops with parameters of type INDArray

Modifier and Type	Method and Description
void	BaseAccumulation.init(INDArray x, INDArray y, INDArray z, int n)
void	BaseOp.init(INDArray x, INDArray y, INDArray z, int n)
void	Op.init(INDArray x, INDArray y, INDArray z, int n) Initialize the operation based on the parameters
void	BaseOp.setX(INDArray x)
void	Op.setX(INDArray x) set x (the input ndarray)
void	BaseOp.setY(INDArray y)
void	Op.setY(INDArray y) set y(the pairwise ndarray)
void	BaseOp.setZ(INDArray z)
void	Op.setZ(INDArray z) set z (the solution ndarray)

Constructors in org.nd4j.linalg.api.ops with parameters of type INDArray

Constructor and Description
BaseAccumulation(INDArray x)
BaseAccumulation(INDArray x, INDArray y)
BaseAccumulation(INDArray x, INDArray y, INDArray z, int n) Initialize with the given input, pairwise transform, result, and number of elements
BaseAccumulation(INDArray x, INDArray y, int n)
BaseLossFunction(INDArray x)
BaseLossFunction(INDArray x, INDArray y)
BaseLossFunction(INDArray x, INDArray y, INDArray z, int n)
BaseLossFunction(INDArray x, INDArray y, int n)
BaseOp(INDArray x) An op for one ndarray
BaseOp(INDArray x, INDArray z) Specify an alternative result array
BaseOp(INDArray x, INDArray y, INDArray z, int n)
BaseOp(INDArray x, INDArray z, int n) Specify an alternative output array
BaseScalarOp(INDArray x, IComplexNumber num)
BaseScalarOp(INDArray x, INDArray y, INDArray z, int n, IComplexNumber num)
BaseScalarOp(INDArray x, INDArray y, INDArray z, int n, Number num)
BaseScalarOp(INDArray x, Number num)
BaseTransformOp(INDArray x)
BaseTransformOp(INDArray x, INDArray z)
BaseTransformOp(INDArray x, INDArray y, INDArray z, int n)
BaseTransformOp(INDArray x, INDArray z, int n)

Uses of INDArray in org.nd4j.linalg.api.ops.executioner

Methods in org.nd4j.linalg.api.ops.executioner that return INDArray

Modifier and Type	Method and Description
INDArray	OpExecutioner.exec(Accumulation accumulation, int dimension) Execute an accumulation along a dimension
INDArray	DefaultOpExecutioner.exec(Accumulation op, int dimension)
INDArray	OpExecutioner.execAndReturn(Op op) Execute and return a result ndarray from the given op
INDArray	DefaultOpExecutioner.execAndReturn(Op op)
INDArray	OpExecutioner.execAndReturn(ScalarOp op) Execute and return the result from an accumulation
INDArray	DefaultOpExecutioner.execAndReturn(ScalarOp op)
INDArray	OpExecutioner.execAndReturn(ScalarOp op, int dimension) Execute and return the result from an accumulation
INDArray	DefaultOpExecutioner.execAndReturn(ScalarOp op, int dimension)
INDArray	OpExecutioner.execAndReturn(TransformOp op) Execute the operation
INDArray	DefaultOpExecutioner.execAndReturn(TransformOp op)
INDArray	OpExecutioner.execAndReturn(TransformOp op, int dimension) Execute the operation
INDArray	DefaultOpExecutioner.execAndReturn(TransformOp op, int dimension)

Uses of INDArray in org.nd4j.linalg.api.ops.factory

Methods in org.nd4j.linalg.api.ops.factory with parameters of type INDArray

Modifier and Type	Method and Description
Accumulation	OpFactory.createAccum(String name, INDArray x) Accumulation operation
Accumulation	DefaultOpFactory.createAccum(String name, INDArray x)
Accumulation	OpFactory.createAccum(String name, INDArray x, INDArray y)
Accumulation	DefaultOpFactory.createAccum(String name, INDArray x, INDArray y)
Accumulation	OpFactory.createAccum(String name, INDArray x, INDArray y, INDArray z) Accumulation operation
Accumulation	DefaultOpFactory.createAccum(String name, INDArray x, INDArray y, INDArray z)
LossFunction	OpFactory.createLossFunction(String name, INDArray x, INDArray y) Create a loss function with the given inputs and outputs
LossFunction	DefaultOpFactory.createLossFunction(String name, INDArray x, INDArray y)
TransformOp	OpFactory.createTransform(String name, INDArray x)
TransformOp	DefaultOpFactory.createTransform(String name, INDArray x)
TransformOp	OpFactory.createTransform(String name, INDArray x, INDArray y)
TransformOp	DefaultOpFactory.createTransform(String name, INDArray x, INDArray y)
TransformOp	OpFactory.createTransform(String name, INDArray x, INDArray y, INDArray z)
TransformOp	DefaultOpFactory.createTransform(String name, INDArray x, INDArray y, INDArray z)

Uses of INDArray in org.nd4j.linalg.api.ops.impl.accum

Methods in org.nd4j.linalg.api.ops.impl.accum with parameters of type INDArray

Modifier and Type	Method and Description
void	Variance.init(INDArray x, INDArray y, INDArray z, int n)
void	Min.init(INDArray x, INDArray y, INDArray z, int n)
void	IAMax.init(INDArray x, INDArray y, INDArray z, int n)
void	Bias.init(INDArray x, INDArray y, INDArray z, int n)
void	Max.init(INDArray x, INDArray y, INDArray z, int n)

Constructors in org.nd4j.linalg.api.ops.impl.accum with parameters of type INDArray

Constructor and Description
Bias(INDArray x)
Bias(INDArray x, INDArray y)
Bias(INDArray x, INDArray y, INDArray z, int n)
Bias(INDArray x, INDArray y, int n)
Dot(INDArray x)
Dot(INDArray x, INDArray y)
Dot(INDArray x, INDArray y, INDArray z, int n)
Dot(INDArray x, INDArray y, int n)
IAMax(INDArray x)
IAMax(INDArray x, INDArray y)
IAMax(INDArray x, INDArray y, int n)
Max(INDArray x)
Max(INDArray x, INDArray y)
Max(INDArray x, INDArray y, int n)
Mean(INDArray x)
Mean(INDArray x, INDArray y)
Mean(INDArray x, INDArray y, INDArray z, int n)
Mean(INDArray x, INDArray y, int n)
Min(INDArray x)
Min(INDArray x, INDArray y)
Min(INDArray x, INDArray y, INDArray z, int n)
Min(INDArray x, INDArray y, int n)
Norm1(INDArray x)
Norm1(INDArray x, INDArray y)
Norm1(INDArray x, INDArray y, INDArray z, int n)
Norm1(INDArray x, INDArray y, int n)
Norm2(INDArray x)
Norm2(INDArray x, INDArray y)
Norm2(INDArray x, INDArray y, INDArray z, int n)
Norm2(INDArray x, INDArray y, int n)
NormMax(INDArray x)
NormMax(INDArray x, INDArray y)
NormMax(INDArray x, INDArray y, INDArray z, int n)
NormMax(INDArray x, INDArray y, int n)
Prod(INDArray x)
Prod(INDArray x, INDArray y)
Prod(INDArray x, INDArray y, INDArray z, int n)
Prod(INDArray x, INDArray y, int n)
StandardDeviation(INDArray x)
StandardDeviation(INDArray x, INDArray y)
StandardDeviation(INDArray x, INDArray y, int n)
Sum(INDArray x)
Sum(INDArray x, INDArray y)
Sum(INDArray x, INDArray y, INDArray z, int n)
Sum(INDArray x, INDArray y, int n)
Variance(INDArray x)
Variance(INDArray x, boolean biasCorrected)
Variance(INDArray x, INDArray y)
Variance(INDArray x, INDArray y, boolean biasCorrected)
Variance(INDArray x, INDArray y, INDArray z, int n)
Variance(INDArray x, INDArray y, INDArray z, int n, boolean biasCorrected)
Variance(INDArray x, INDArray y, int n)
Variance(INDArray x, INDArray y, int n, boolean biasCorrected)

Uses of INDArray in org.nd4j.linalg.api.ops.impl.accum.distances

Methods in org.nd4j.linalg.api.ops.impl.accum.distances with parameters of type INDArray

Modifier and Type	Method and Description
void	CosineSimilarity.init(INDArray x, INDArray y, INDArray z, int n)

Constructors in org.nd4j.linalg.api.ops.impl.accum.distances with parameters of type INDArray

Constructor and Description
CosineSimilarity(INDArray x)
CosineSimilarity(INDArray x, INDArray y)
CosineSimilarity(INDArray x, INDArray y, INDArray z, int n)
CosineSimilarity(INDArray x, INDArray y, int n)
EuclideanDistance(INDArray x)
EuclideanDistance(INDArray x, INDArray y)
EuclideanDistance(INDArray x, INDArray y, INDArray z, int n)
EuclideanDistance(INDArray x, INDArray y, int n)
ManhattanDistance(INDArray x)
ManhattanDistance(INDArray x, INDArray y)
ManhattanDistance(INDArray x, INDArray y, INDArray z, int n)
ManhattanDistance(INDArray x, INDArray y, int n)

Uses of INDArray in org.nd4j.linalg.api.ops.impl.scalar

Methods in org.nd4j.linalg.api.ops.impl.scalar with parameters of type INDArray

Modifier and Type	Method and Description
void	ScalarMax.init(INDArray x, INDArray y, INDArray z, int n)

Constructors in org.nd4j.linalg.api.ops.impl.scalar with parameters of type INDArray

Constructor and Description
ScalarAdd(INDArray arr)
ScalarAdd(INDArray x, IComplexNumber num)
ScalarAdd(INDArray x, INDArray y, INDArray z, int n, IComplexNumber num)
ScalarAdd(INDArray x, INDArray y, INDArray z, int n, Number num)
ScalarAdd(INDArray x, Number num)
ScalarDivision(INDArray x, IComplexNumber num)
ScalarDivision(INDArray x, INDArray y, INDArray z, int n, IComplexNumber num)
ScalarDivision(INDArray x, INDArray y, INDArray z, int n, Number num)
ScalarDivision(INDArray x, Number num)
ScalarMax(INDArray x, IComplexNumber num)
ScalarMax(INDArray x, INDArray y, INDArray z, int n, IComplexNumber num)
ScalarMax(INDArray x, INDArray y, INDArray z, int n, Number num)
ScalarMax(INDArray x, Number num)
ScalarMultiplication(INDArray x)
ScalarMultiplication(INDArray x, IComplexNumber num)
ScalarMultiplication(INDArray x, INDArray y, INDArray z, int n, IComplexNumber num)
ScalarMultiplication(INDArray x, INDArray y, INDArray z, int n, Number num)
ScalarMultiplication(INDArray x, Number num)
ScalarReverseDivision(INDArray x, IComplexNumber num)
ScalarReverseDivision(INDArray x, INDArray y, INDArray z, int n, IComplexNumber num)
ScalarReverseDivision(INDArray x, INDArray y, INDArray z, int n, Number num)
ScalarReverseDivision(INDArray x, Number num)
ScalarReverseSubtraction(INDArray x, IComplexNumber num)
ScalarReverseSubtraction(INDArray x, INDArray y, INDArray z, int n, IComplexNumber num)
ScalarReverseSubtraction(INDArray x, INDArray y, INDArray z, int n, Number num)
ScalarReverseSubtraction(INDArray x, Number num)
ScalarSubtraction(INDArray x)
ScalarSubtraction(INDArray x, IComplexNumber num)
ScalarSubtraction(INDArray x, INDArray y, INDArray z, int n, IComplexNumber num)
ScalarSubtraction(INDArray x, INDArray y, INDArray z, int n, Number num)
ScalarSubtraction(INDArray x, Number num)

Uses of INDArray in org.nd4j.linalg.api.ops.impl.scalar.comparison

Constructors in org.nd4j.linalg.api.ops.impl.scalar.comparison with parameters of type INDArray

Constructor and Description
ScalarEquals(INDArray x)
ScalarEquals(INDArray x, IComplexNumber num)
ScalarEquals(INDArray x, INDArray y, INDArray z, int n, IComplexNumber num)
ScalarEquals(INDArray x, INDArray y, INDArray z, int n, Number num)
ScalarEquals(INDArray x, Number num)
ScalarGreaterThan(INDArray x, IComplexNumber num)
ScalarGreaterThan(INDArray x, INDArray y, INDArray z, int n, IComplexNumber num)
ScalarGreaterThan(INDArray x, INDArray y, INDArray z, int n, Number num)
ScalarGreaterThan(INDArray x, Number num)
ScalarGreaterThanOrEqual(INDArray x, IComplexNumber num)
ScalarGreaterThanOrEqual(INDArray x, INDArray y, INDArray z, int n, IComplexNumber num)
ScalarGreaterThanOrEqual(INDArray x, INDArray y, INDArray z, int n, Number num)
ScalarGreaterThanOrEqual(INDArray x, Number num)
ScalarLessThan(INDArray x, IComplexNumber num)
ScalarLessThan(INDArray x, INDArray y, INDArray z, int n, IComplexNumber num)
ScalarLessThan(INDArray x, INDArray y, INDArray z, int n, Number num)
ScalarLessThan(INDArray x, Number num)
ScalarLessThanOrEqual(INDArray x, IComplexNumber num)
ScalarLessThanOrEqual(INDArray x, INDArray y, INDArray z, int n, IComplexNumber num)
ScalarLessThanOrEqual(INDArray x, INDArray y, INDArray z, int n, Number num)
ScalarLessThanOrEqual(INDArray x, Number num)
ScalarNotEquals(INDArray x, IComplexNumber num)
ScalarNotEquals(INDArray x, INDArray y, INDArray z, int n, IComplexNumber num)
ScalarNotEquals(INDArray x, INDArray y, INDArray z, int n, Number num)
ScalarNotEquals(INDArray x, Number num)
ScalarSetValue(INDArray x, IComplexNumber num)
ScalarSetValue(INDArray x, INDArray y, INDArray z, int n, IComplexNumber num)
ScalarSetValue(INDArray x, INDArray y, INDArray z, int n, Number num)
ScalarSetValue(INDArray x, Number num)

Uses of INDArray in org.nd4j.linalg.api.ops.impl.transforms

Methods in org.nd4j.linalg.api.ops.impl.transforms with parameters of type INDArray

Modifier and Type	Method and Description
void	SetRange.init(INDArray x, INDArray y, INDArray z, int n)
void	Pow.init(INDArray x, INDArray y, INDArray z, int n)
void	SoftMax.init(INDArray x, INDArray y, INDArray z, int n)
void	Stabilize.init(INDArray x, INDArray y, INDArray z, int n)
void	VectorFFT.setX(INDArray x)
void	VectorIFFT.setX(INDArray x)
void	VectorFFT.setY(INDArray y)
void	VectorFFT.setZ(INDArray z)
void	VectorIFFT.setZ(INDArray z)

Constructors in org.nd4j.linalg.api.ops.impl.transforms with parameters of type INDArray

Constructor and Description
Abs(INDArray x)
Abs(INDArray x, INDArray z)
Abs(INDArray x, INDArray y, INDArray z, int n)
Abs(INDArray x, INDArray z, int n)
ACos(INDArray x)
ACos(INDArray x, INDArray y)
ACos(INDArray x, INDArray y, INDArray z, int n)
ACos(INDArray indArray, INDArray indArray1, int length)
ASin(INDArray x)
ASin(INDArray x, INDArray z)
ASin(INDArray x, INDArray y, INDArray z, int n)
ASin(INDArray x, INDArray z, int n)
ATan(INDArray x)
ATan(INDArray x, INDArray z)
ATan(INDArray x, INDArray y, INDArray z, int n)
ATan(INDArray x, INDArray z, int n)
Ceil(INDArray x)
Ceil(INDArray x, INDArray z)
Ceil(INDArray x, INDArray y, INDArray z, int n)
Ceil(INDArray x, INDArray z, int n)
Cos(INDArray x)
Cos(INDArray x, INDArray z)
Cos(INDArray x, INDArray y, INDArray z, int n)
Cos(INDArray x, INDArray z, int n)
Exp(INDArray x)
Exp(INDArray x, INDArray z)
Exp(INDArray x, INDArray y, INDArray z, int n)
Exp(INDArray x, INDArray z, int n)
Floor(INDArray x)
Floor(INDArray x, INDArray z)
Floor(INDArray x, INDArray y, INDArray z, int n)
Floor(INDArray x, INDArray z, int n)
HardTanh(INDArray x)
HardTanh(INDArray x, INDArray z)
HardTanh(INDArray x, INDArray y, INDArray z, int n)
HardTanh(INDArray x, INDArray z, int n)
HardTanhDerivative(INDArray x)
HardTanhDerivative(INDArray x, INDArray z)
HardTanhDerivative(INDArray x, INDArray y, INDArray z, int n)
HardTanhDerivative(INDArray x, INDArray z, int n)
Identity(INDArray x)
Identity(INDArray x, INDArray z)
Identity(INDArray x, INDArray y, INDArray z, int n)
Identity(INDArray x, INDArray z, int n)
LinearIndex(INDArray x)
LinearIndex(INDArray x, boolean wholeArray)
LinearIndex(INDArray x, INDArray z, boolean wholeArray)
LinearIndex(INDArray x, INDArray y, INDArray z, int n, boolean wholeArray)
LinearIndex(INDArray x, INDArray z, int n, boolean wholeArray)
Log(INDArray x)
Log(INDArray x, INDArray z)
Log(INDArray x, INDArray y, INDArray z, int n)
Log(INDArray x, INDArray z, int n)
MaxOut(INDArray x)
MaxOut(INDArray x, INDArray z)
MaxOut(INDArray x, INDArray y, INDArray z, int n)
MaxOut(INDArray x, INDArray z, int n)
Negative(INDArray x)
Negative(INDArray x, INDArray z)
Negative(INDArray x, INDArray y, INDArray z, int n)
Negative(INDArray x, INDArray z, int n)
OneMinus(INDArray x)
OneMinus(INDArray x, INDArray z)
OneMinus(INDArray x, INDArray y, INDArray z, int n)
OneMinus(INDArray x, INDArray z, int n)
Ones(INDArray x)
Ones(INDArray x, INDArray z)
Ones(INDArray x, INDArray y, INDArray z, int n)
Ones(INDArray x, INDArray z, int n)
Pow(INDArray x, double pow)
Pow(INDArray x, INDArray z, double pow)
Pow(INDArray x, INDArray y, INDArray z, int n, double pow)
Pow(INDArray x, INDArray z, int n, double pow)
RectifedLinear(INDArray x)
RectifedLinear(INDArray x, double cutoff)
RectifedLinear(INDArray x, INDArray z)
RectifedLinear(INDArray x, INDArray z, double cutoff)
RectifedLinear(INDArray x, INDArray y, INDArray z, int n)
RectifedLinear(INDArray x, INDArray y, INDArray z, int n, double cutoff)
RectifedLinear(INDArray x, INDArray z, int n)
RectifedLinear(INDArray x, INDArray z, int n, double cutoff)
Round(INDArray x)
Round(INDArray x, INDArray z)
Round(INDArray x, INDArray y, INDArray z, int n)
Round(INDArray x, INDArray z, int n)
SetRange(INDArray x)
SetRange(INDArray x, double min, double max)
SetRange(INDArray x, INDArray z, double min, double max)
SetRange(INDArray x, INDArray y, INDArray z, int n, double min, double max)
SetRange(INDArray x, INDArray z, int n, double min, double max)
Sigmoid(INDArray ndArray)
Sigmoid(INDArray x, INDArray z)
Sigmoid(INDArray x, INDArray y, INDArray z, int n)
Sigmoid(INDArray x, INDArray z, int n)
SigmoidDerivative(INDArray x)
SigmoidDerivative(INDArray x, INDArray z)
SigmoidDerivative(INDArray x, INDArray y, INDArray z, int n)
SigmoidDerivative(INDArray x, INDArray z, int n)
Sign(INDArray x)
Sign(INDArray x, INDArray z)
Sign(INDArray x, INDArray y, INDArray z, int n)
Sign(INDArray x, INDArray z, int n)
Sin(INDArray x)
Sin(INDArray x, INDArray z)
Sin(INDArray x, INDArray y, INDArray z, int n)
Sin(INDArray x, INDArray z, int n)
SoftMax(INDArray x)
SoftMax(INDArray x, INDArray z)
SoftMax(INDArray x, INDArray y, INDArray z, int n)
SoftMax(INDArray x, INDArray z, int n)
SoftMaxDerivative(INDArray x)
SoftMaxDerivative(INDArray x, INDArray z)
SoftMaxDerivative(INDArray x, INDArray y, INDArray z, int n)
SoftMaxDerivative(INDArray x, INDArray z, int n)
Sqrt(INDArray x)
Sqrt(INDArray x, INDArray z)
Sqrt(INDArray x, INDArray y, INDArray z, int n)
Sqrt(INDArray x, INDArray z, int n)
Stabilize(INDArray x, double k)
Stabilize(INDArray x, INDArray z, double k)
Stabilize(INDArray x, INDArray y, INDArray z, int n, double k)
Stabilize(INDArray x, INDArray z, int n, double k)
Tanh(INDArray x)
Tanh(INDArray x, INDArray z)
Tanh(INDArray x, INDArray y, INDArray z, int n)
Tanh(INDArray x, INDArray z, int n)
VectorFFT(INDArray x)
VectorFFT(INDArray x, INDArray y, INDArray z, int n, int fftLength)
VectorFFT(INDArray x, INDArray z, int fftLength)
VectorFFT(INDArray x, INDArray z, int n, int fftLength)
VectorFFT(INDArray x, int fftLength)
VectorIFFT(INDArray x)
VectorIFFT(INDArray x, INDArray y, INDArray z, int n, int fftLength)
VectorIFFT(INDArray x, INDArray z, int fftLength)
VectorIFFT(INDArray x, INDArray z, int n, int fftLength)
VectorIFFT(INDArray x, int fftLength)

Uses of INDArray in org.nd4j.linalg.api.ops.impl.transforms.arithmetic

Methods in org.nd4j.linalg.api.ops.impl.transforms.arithmetic with parameters of type INDArray

Modifier and Type	Method and Description
void	DivOp.init(INDArray x, INDArray y, INDArray z, int n)
void	AddOp.init(INDArray x, INDArray y, INDArray z, int n)
void	CopyOp.init(INDArray x, INDArray y, INDArray z, int n)
void	SubOp.init(INDArray x, INDArray y, INDArray z, int n)
void	MulOp.init(INDArray x, INDArray y, INDArray z, int n)

Constructors in org.nd4j.linalg.api.ops.impl.transforms.arithmetic with parameters of type INDArray

Constructor and Description
AddOp(INDArray x)
AddOp(INDArray x, INDArray z)
AddOp(INDArray x, INDArray xDup, INDArray z)
AddOp(INDArray x, INDArray y, INDArray z, int n)
AddOp(INDArray x, INDArray z, int n)
CopyOp(INDArray x)
CopyOp(INDArray x, INDArray z)
CopyOp(INDArray x, INDArray xDup, INDArray z)
CopyOp(INDArray x, INDArray y, INDArray z, int n)
CopyOp(INDArray x, INDArray z, int n)
DivOp(INDArray x)
DivOp(INDArray x, INDArray z)
DivOp(INDArray x, INDArray y, INDArray z, int n)
DivOp(INDArray x, INDArray z, int n)
MulOp(INDArray x)
MulOp(INDArray x, INDArray z)
MulOp(INDArray x, INDArray xDup, INDArray x1)
MulOp(INDArray x, INDArray y, INDArray z, int n)
MulOp(INDArray x, INDArray z, int n)
SubOp(INDArray x)
SubOp(INDArray x, INDArray z)
SubOp(INDArray x, INDArray y, INDArray z, int n)
SubOp(INDArray x, INDArray z, int n)

Uses of INDArray in org.nd4j.linalg.api.ops.impl.transforms.comparison

Constructors in org.nd4j.linalg.api.ops.impl.transforms.comparison with parameters of type INDArray

Constructor and Description
Eps(INDArray x)
Eps(INDArray x, INDArray z)
Eps(INDArray x, INDArray y, INDArray z, int n)
Eps(INDArray x, INDArray z, int n)
EqualTo(INDArray x)
EqualTo(INDArray x, INDArray z)
EqualTo(INDArray x, INDArray y, INDArray z, int n)
EqualTo(INDArray x, INDArray z, int n)
GreaterThan(INDArray x)
GreaterThan(INDArray x, INDArray z)
GreaterThan(INDArray x, INDArray y, INDArray z, int n)
GreaterThan(INDArray x, INDArray z, int n)
GreaterThanOrEqual(INDArray x)
GreaterThanOrEqual(INDArray x, INDArray z)
GreaterThanOrEqual(INDArray x, INDArray y, INDArray z, int n)
GreaterThanOrEqual(INDArray x, INDArray z, int n)
LessThan(INDArray x)
LessThan(INDArray ndArray, INDArray dup)
LessThan(INDArray x, INDArray y, INDArray z, int n)
LessThan(INDArray x, INDArray z, int n)
LessThanOrEqual(INDArray x)
LessThanOrEqual(INDArray x, INDArray z)
LessThanOrEqual(INDArray x, INDArray y, INDArray z, int n)
LessThanOrEqual(INDArray x, INDArray z, int n)
Max(INDArray x)
Max(INDArray ndArray, INDArray dup)
Max(INDArray x, INDArray y, INDArray z, int n)
Max(INDArray x, INDArray z, int n)
Min(INDArray x)
Min(INDArray x, INDArray z)
Min(INDArray x, INDArray y, INDArray z, int n)
Min(INDArray x, INDArray z, int n)
NotEqualTo(INDArray x)
NotEqualTo(INDArray x, INDArray z)
NotEqualTo(INDArray x, INDArray y, INDArray z, int n)
NotEqualTo(INDArray x, INDArray z, int n)

Uses of INDArray in org.nd4j.linalg.api.rng

Methods in org.nd4j.linalg.api.rng that return INDArray

Modifier and Type	Method and Description
INDArray	Random.nextDouble(int[] shape) Generate a gaussian number ndarray of the specified shape
INDArray	DefaultRandom.nextDouble(int[] shape)
INDArray	Random.nextFloat(int[] shape) Generate a gaussian number ndarray of the specified shape
INDArray	DefaultRandom.nextFloat(int[] shape)
INDArray	Random.nextGaussian(int[] shape) Generate a gaussian number ndarray of the specified shape
INDArray	DefaultRandom.nextGaussian(int[] shape)
INDArray	Random.nextInt(int[] shape) Generate a random set of integers of the specified shape.
INDArray	DefaultRandom.nextInt(int[] shape)
INDArray	Random.nextInt(int n, int[] shape) Generate a random set of integers of the specified shape.
INDArray	DefaultRandom.nextInt(int n, int[] shape)

Uses of INDArray in org.nd4j.linalg.api.rng.distribution

Methods in org.nd4j.linalg.api.rng.distribution that return INDArray

Modifier and Type	Method and Description
INDArray	Distribution.sample(int[] shape) Sample the given shape
INDArray	BaseDistribution.sample(int[] shape)

Uses of INDArray in org.nd4j.linalg.api.rng.distribution.factory

Methods in org.nd4j.linalg.api.rng.distribution.factory with parameters of type INDArray

Modifier and Type	Method and Description
Distribution	DefaultDistributionFactory.createBinomial(int n, INDArray p)
Distribution	DistributionFactory.createBinomial(int n, INDArray p) Create a distribution
Distribution	DefaultDistributionFactory.createNormal(INDArray mean, double std)
Distribution	DistributionFactory.createNormal(INDArray mean, double std) Create a normal distribution with the given mean and std

Uses of INDArray in org.nd4j.linalg.api.rng.distribution.impl

Methods in org.nd4j.linalg.api.rng.distribution.impl that return INDArray

Modifier and Type	Method and Description
INDArray	NormalDistribution.sample(int[] shape)
INDArray	BinomialDistribution.sample(int[] shape)

Constructors in org.nd4j.linalg.api.rng.distribution.impl with parameters of type INDArray

Constructor and Description
BinomialDistribution(int n, INDArray p)
NormalDistribution(double standardDeviation, INDArray means)
NormalDistribution(INDArray mean, double std)
NormalDistribution(Random rng, double standardDeviation, INDArray means)

Uses of INDArray in org.nd4j.linalg.benchmark

Constructors in org.nd4j.linalg.benchmark with parameters of type INDArray

Constructor and Description
TimeOperations(INDArray n)
TimeOperations(INDArray n, int numTimesRun)

Uses of INDArray in org.nd4j.linalg.convolution

Methods in org.nd4j.linalg.convolution that return INDArray

Modifier and Type	Method and Description
INDArray	BaseConvolution.conv2d(IComplexNDArray input, IComplexNDArray kernel, Convolution.Type type)
INDArray	ConvolutionInstance.conv2d(IComplexNDArray input, IComplexNDArray kernel, Convolution.Type type)
static INDArray	Convolution.conv2d(IComplexNDArray input, IComplexNDArray kernel, Convolution.Type type)
INDArray	BaseConvolution.conv2d(INDArray input, INDArray kernel, Convolution.Type type) 2d convolution (aka the last 2 dimensions
INDArray	ConvolutionInstance.conv2d(INDArray input, INDArray kernel, Convolution.Type type) 2d convolution (aka the last 2 dimensions
static INDArray	Convolution.conv2d(INDArray input, INDArray kernel, Convolution.Type type) 2d convolution (aka the last 2 dimensions
INDArray	BaseConvolution.convn(INDArray input, INDArray kernel, Convolution.Type type) ND Convolution
INDArray	ConvolutionInstance.convn(INDArray input, INDArray kernel, Convolution.Type type) ND Convolution
static INDArray	Convolution.convn(INDArray input, INDArray kernel, Convolution.Type type) ND Convolution
INDArray	ConvolutionInstance.convn(INDArray input, INDArray kernel, Convolution.Type type, int[] axes) ND Convolution
INDArray	DefaultConvolutionInstance.convn(INDArray input, INDArray kernel, Convolution.Type type, int[] axes) ND Convolution
static INDArray	Convolution.convn(INDArray input, INDArray kernel, Convolution.Type type, int[] axes) ND Convolution

Methods in org.nd4j.linalg.convolution with parameters of type INDArray

Modifier and Type	Method and Description
INDArray	BaseConvolution.conv2d(INDArray input, INDArray kernel, Convolution.Type type) 2d convolution (aka the last 2 dimensions
INDArray	ConvolutionInstance.conv2d(INDArray input, INDArray kernel, Convolution.Type type) 2d convolution (aka the last 2 dimensions
static INDArray	Convolution.conv2d(INDArray input, INDArray kernel, Convolution.Type type) 2d convolution (aka the last 2 dimensions
INDArray	BaseConvolution.convn(INDArray input, INDArray kernel, Convolution.Type type) ND Convolution
INDArray	ConvolutionInstance.convn(INDArray input, INDArray kernel, Convolution.Type type) ND Convolution
static INDArray	Convolution.convn(INDArray input, INDArray kernel, Convolution.Type type) ND Convolution
INDArray	ConvolutionInstance.convn(INDArray input, INDArray kernel, Convolution.Type type, int[] axes) ND Convolution
INDArray	DefaultConvolutionInstance.convn(INDArray input, INDArray kernel, Convolution.Type type, int[] axes) ND Convolution
static INDArray	Convolution.convn(INDArray input, INDArray kernel, Convolution.Type type, int[] axes) ND Convolution

Uses of INDArray in org.nd4j.linalg.dataset

Methods in org.nd4j.linalg.dataset that return INDArray

Modifier and Type	Method and Description
INDArray	DataSet.exampleMaxs()
INDArray	DataSet.exampleMeans()
INDArray	DataSet.exampleSums()
INDArray	DataSet.getFeatureMatrix() Get the feature matrix (inputs for the data)
INDArray	DataSet.getFeatures()
INDArray	DataSet.getLabels() Returns the labels for the dataset

Methods in org.nd4j.linalg.dataset with parameters of type INDArray

Modifier and Type	Method and Description
void	DataSet.addFeatureVector(INDArray toAdd) Adds a feature for each example on to the current feature vector
void	DataSet.addFeatureVector(INDArray feature, int example) The feature to add, and the example/row number
void	DataSet.setFeatures(INDArray features)
void	DataSet.setLabels(INDArray labels)

Constructors in org.nd4j.linalg.dataset with parameters of type INDArray

Constructor and Description
DataSet(INDArray first, INDArray second) Creates a dataset with the specified input matrix and labels

Uses of INDArray in org.nd4j.linalg.dataset.api

Methods in org.nd4j.linalg.dataset.api that return INDArray

Modifier and Type	Method and Description
INDArray	DataSet.exampleMaxs()
INDArray	DataSet.exampleMeans()
INDArray	DataSet.exampleSums()
INDArray	DataSet.getFeatureMatrix()
INDArray	DataSet.getFeatures()
INDArray	DataSet.getLabels()

Methods in org.nd4j.linalg.dataset.api with parameters of type INDArray

Modifier and Type	Method and Description
void	DataSet.addFeatureVector(INDArray toAdd)
void	DataSet.addFeatureVector(INDArray feature, int example)
void	DataSet.setFeatures(INDArray features)
void	DataSet.setLabels(INDArray labels)

Uses of INDArray in org.nd4j.linalg.dataset.api.iterator.fetcher

Methods in org.nd4j.linalg.dataset.api.iterator.fetcher that return INDArray

Modifier and Type	Method and Description
protected INDArray	BaseDataFetcher.createInputMatrix(int numRows) Creates a feature vector
protected INDArray	BaseDataFetcher.createOutputMatrix(int numRows)
protected INDArray	BaseDataFetcher.createOutputVector(int outcomeLabel) Creates an output label matrix

Uses of INDArray in org.nd4j.linalg.dimensionalityreduction

Methods in org.nd4j.linalg.dimensionalityreduction that return INDArray

Modifier and Type	Method and Description
static INDArray	PCA.pca(INDArray X, int nDims, boolean normalize) Reduce the dimension of x to the specified number of dimensions.

Methods in org.nd4j.linalg.dimensionalityreduction with parameters of type INDArray

Modifier and Type	Method and Description
static INDArray	PCA.pca(INDArray X, int nDims, boolean normalize) Reduce the dimension of x to the specified number of dimensions.

Uses of INDArray in org.nd4j.linalg.eigen

Fields in org.nd4j.linalg.eigen declared as INDArray

Modifier and Type	Field and Description
static INDArray	Eigen.dummy

Methods in org.nd4j.linalg.eigen that return INDArray

Modifier and Type	Method and Description
static INDArray	Eigen.symmetricGeneralizedEigenvalues(INDArray A) Compute generalized eigenvalues of the problem A x = L B x.
static INDArray	Eigen.symmetricGeneralizedEigenvalues(INDArray A, INDArray B) Compute generalized eigenvalues of the problem A x = L B x.

Methods in org.nd4j.linalg.eigen with parameters of type INDArray

Modifier and Type	Method and Description
static IComplexNDArray	Eigen.eigenvalues(INDArray A) Computes the eigenvalues of a general matrix.
static IComplexNDArray[]	Eigen.eigenvectors(INDArray A) Computes the eigenvalues and eigenvectors of a general matrix.
static INDArray	Eigen.symmetricGeneralizedEigenvalues(INDArray A) Compute generalized eigenvalues of the problem A x = L B x.
static INDArray	Eigen.symmetricGeneralizedEigenvalues(INDArray A, INDArray B) Compute generalized eigenvalues of the problem A x = L B x.

Uses of INDArray in org.nd4j.linalg.factory

Classes in org.nd4j.linalg.factory with type parameters of type INDArray

Modifier and Type	Interface and Description
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.

Fields in org.nd4j.linalg.factory with type parameters of type INDArray

Modifier and Type	Field and Description
protected static ReferenceQueue<INDArray>	Nd4j.referenceQueue

Methods in org.nd4j.linalg.factory that return INDArray

Modifier and Type	Method and Description
INDArray	BaseNDArrayFactory.appendBias(INDArray... vectors) Merge the vectors and append a bias.
static INDArray	Nd4j.appendBias(INDArray... vectors)
INDArray	NDArrayFactory.appendBias(INDArray... vectors)
INDArray	BaseNDArrayFactory.arange(double begin, double end) Array of evenly spaced values.
static INDArray	Nd4j.arange(double begin, double end) Array of evenly spaced values.
INDArray	NDArrayFactory.arange(double begin, double end) Array of evenly spaced values.
INDArray	BlasWrapper.axpy(double da, INDArray dx, INDArray dy)
INDArray	BaseNDArrayFactory.bilinearProducts(INDArray curr, INDArray in) Returns a column vector where each entry is the nth bilinear product of the nth slices of the two tensors.
static INDArray	Nd4j.bilinearProducts(INDArray curr, INDArray in) Returns a column vector where each entry is the nth bilinear product of the nth slices of the two tensors.
INDArray	NDArrayFactory.bilinearProducts(INDArray curr, INDArray in) Returns a column vector where each entry is the nth bilinear product of the nth slices of the two tensors.
static INDArray	Nd4j.complexZeros(int rows, int columns) Creates a matrix of zeros
INDArray	BaseNDArrayFactory.concat(int dimension, INDArray... toConcat) concatenate ndarrays along a dimension
static INDArray	Nd4j.concat(int dimension, INDArray... toConcat) Concatneate ndarrays along a dimension
INDArray	NDArrayFactory.concat(int dimension, INDArray... toConcat) Concatneate ndarrays along a dimension
static INDArray	Nd4j.create(DataBuffer buffer)
INDArray	NDArrayFactory.create(DataBuffer data) Creates a row vector with the data
static INDArray	Nd4j.create(DataBuffer data, int[] shape)
INDArray	NDArrayFactory.create(DataBuffer data, int[] shape) Create an ndrray with the specified shape
static INDArray	Nd4j.create(DataBuffer data, int[] shape, int offset)
INDArray	NDArrayFactory.create(DataBuffer buffer, int[] shape, int offset)
INDArray	BaseNDArrayFactory.create(DataBuffer buffer, int[] shape, int[] stride, char order, int offset)
INDArray	NDArrayFactory.create(DataBuffer buffer, int[] shape, int[] stride, char order, int offset)
static INDArray	Nd4j.create(DataBuffer data, int[] shape, int[] strides, int offset)
INDArray	NDArrayFactory.create(DataBuffer data, int[] shape, int[] stride, int offset) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(DataBuffer data, int[] newShape, int[] newStride, int offset, char ordering)
INDArray	NDArrayFactory.create(DataBuffer data, int[] newShape, int[] newStride, int offset, char ordering)
INDArray	NDArrayFactory.create(DataBuffer data, int rows, int columns, int[] stride, int offset) Creates an ndarray with the specified shape
INDArray	BaseNDArrayFactory.create(double[] data) Creates a row vector with the data
static INDArray	Nd4j.create(double[] data) Creates a row vector with the data
INDArray	NDArrayFactory.create(double[] data) Creates a row vector with the data
static INDArray	Nd4j.create(double[][] data) Create an ndarray based on the given data layout
INDArray	NDArrayFactory.create(double[][] data) Create an ndarray with the given data layout
INDArray	BaseNDArrayFactory.create(double[] data, char order)
static INDArray	Nd4j.create(double[] data, char order) Creates a row vector with the data
INDArray	NDArrayFactory.create(double[] data, char order)
INDArray	BaseNDArrayFactory.create(double[] data, int[] shape) Create an ndrray with the specified shape
static INDArray	Nd4j.create(double[] data, int[] shape) Create an ndrray with the specified shape
INDArray	NDArrayFactory.create(double[] data, int[] shape) Create an ndrray with the specified shape
static INDArray	Nd4j.create(double[] data, int[] shape, char ordering) Create an ndrray with the specified shape
INDArray	NDArrayFactory.create(double[] data, int[] shape, char ordering)
static INDArray	Nd4j.create(double[] data, int[] shape, int offset)
INDArray	NDArrayFactory.create(double[] data, int[] shape, int offset)
INDArray	BaseNDArrayFactory.create(double[] data, int[] shape, int[] stride, char order, int offset)
INDArray	NDArrayFactory.create(double[] data, int[] ints, int[] ints1, char order, int offset)
abstract INDArray	BaseNDArrayFactory.create(double[] data, int[] shape, int[] stride, int offset) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(double[] data, int[] shape, int[] stride, int offset) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(double[] data, int[] shape, int[] stride, int offset) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(double[] data, int[] shape, int[] stride, int offset, char ordering) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(double[] data, int[] shape, int[] stride, int offset, char ordering)
static INDArray	Nd4j.create(double[] data, int[] shape, int offset, char ordering) Creates an ndarray with the specified shape
INDArray	BaseNDArrayFactory.create(double[] data, int rows, int columns, int[] stride, int offset) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(double[] data, int rows, int columns, int[] stride, int offset) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(double[] data, int rows, int columns, int[] stride, int offset) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(double[] data, int rows, int columns, int[] stride, int offset, char ordering) Creates an ndarray with the specified shape
INDArray	BaseNDArrayFactory.create(float[] data) Creates a row vector with the data
static INDArray	Nd4j.create(float[] data) Creates a row vector with the data
INDArray	NDArrayFactory.create(float[] data) Creates a row vector with the data
static INDArray	Nd4j.create(float[][] doubles)
INDArray	NDArrayFactory.create(float[][] floats)
INDArray	BaseNDArrayFactory.create(float[] data, char order)
static INDArray	Nd4j.create(float[] data, char order) Creates a row vector with the data
INDArray	NDArrayFactory.create(float[] data, char order)
INDArray	BaseNDArrayFactory.create(float[] data, int[] shape) Create an ndrray with the specified shape
static INDArray	Nd4j.create(float[] data, int[] shape) Create an ndrray with the specified shape
INDArray	NDArrayFactory.create(float[] data, int[] shape) Create an ndrray with the specified shape
INDArray	BaseNDArrayFactory.create(float[] data, int[] shape, char ordering)
static INDArray	Nd4j.create(float[] data, int[] shape, char ordering) Create an ndrray with the specified shape
INDArray	NDArrayFactory.create(float[] data, int[] shape, char ordering)
static INDArray	Nd4j.create(float[] data, int[] shape, char ordering, int offset)
INDArray	BaseNDArrayFactory.create(float[] data, int[] shape, int offset)
static INDArray	Nd4j.create(float[] data, int[] shape, int offset) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(float[] data, int[] shape, int offset)
INDArray	BaseNDArrayFactory.create(float[] data, int[] shape, int[] stride, char order, int offset)
static INDArray	Nd4j.create(float[] data, int[] shape, int[] stride, char ordering, int offset)
INDArray	NDArrayFactory.create(float[] data, int[] shape, int[] stride, char order, int offset)
abstract INDArray	BaseNDArrayFactory.create(float[] data, int[] shape, int[] stride, int offset) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(float[] data, int[] shape, int[] stride, int offset) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(float[] data, int[] shape, int[] stride, int offset) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(float[] data, int[] shape, int[] stride, int offset, char ordering) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(float[] data, int[] shape, int[] stride, int offset, char ordering)
INDArray	NDArrayFactory.create(float[] data, int[] shape, int offset, Character order)
INDArray	BaseNDArrayFactory.create(float[] data, int rows, int columns, int[] stride, int offset) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(float[] data, int rows, int columns, int[] stride, int offset) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(float[] data, int rows, int columns, int[] stride, int offset)
static INDArray	Nd4j.create(float[] data, int rows, int columns, int[] stride, int offset, char ordering) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(float[] data, int rows, int columns, int[] stride, int offset, char ordering)
static INDArray	Nd4j.create(int... shape) Creates an ndarray with the specified shape
INDArray	BaseNDArrayFactory.create(int columns) Creates a row vector with the specified number of columns
static INDArray	Nd4j.create(int columns) Creates a row vector with the specified number of columns
INDArray	NDArrayFactory.create(int columns) Creates a row vector with the specified number of columns
INDArray	BaseNDArrayFactory.create(int[] shape) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(int[] shape) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(int[] shape, char ordering) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(int[] shape, char ordering)
INDArray	BaseNDArrayFactory.create(int[] shape, DataBuffer.Type dataType)
static INDArray	Nd4j.create(int[] shape, DataBuffer.Type dataType)
INDArray	NDArrayFactory.create(int[] shape, DataBuffer.Type dataType)
INDArray	NDArrayFactory.create(int[] shape, DataBuffer buffer)
static INDArray	Nd4j.create(int[] sliceShape, double[]... arrays) Create an ndarray based on the given data
static INDArray	Nd4j.create(int[] sliceShape, float[]... arrays) Create an ndarray based on the given data
INDArray	BaseNDArrayFactory.create(int[] shape, int[] stride) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(int[] shape, int[] stride) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(int[] shape, int[] stride) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(int[] shape, int[] stride, char ordering) Creates an ndarray with the specified shape
INDArray	BaseNDArrayFactory.create(int[] shape, int[] stride, int offset) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(int[] shape, int[] stride, int offset) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(int[] shape, int[] stride, int offset) Creates an ndarray with the specified shape
INDArray	BaseNDArrayFactory.create(int[] data, int[] shape, int[] stride, char order, int offset)
INDArray	NDArrayFactory.create(int[] shape, int[] ints1, int[] stride, char order, int offset)
INDArray	BaseNDArrayFactory.create(int[] ints, int[] ints1, int[] stride, int offset)
INDArray	NDArrayFactory.create(int[] ints, int[] ints1, int[] stride, int offset)
INDArray	BaseNDArrayFactory.create(int[] shape, int[] stride, int offset, char ordering)
static INDArray	Nd4j.create(int[] shape, int[] stride, int offset, char ordering) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(int[] shape, int[] stride, int offset, char ordering)
static INDArray	Nd4j.create(int columns, char order) Creates a row vector with the specified number of columns
INDArray	BaseNDArrayFactory.create(int rows, int columns) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(int rows, int columns) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(int rows, int columns) Creates an ndarray with the specified shape
INDArray	BaseNDArrayFactory.create(int rows, int columns, char ordering)
static INDArray	Nd4j.create(int rows, int columns, char ordering) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(int rows, int columns, char ordering)
INDArray	BaseNDArrayFactory.create(int rows, int columns, int[] stride) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(int rows, int columns, int[] stride) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(int rows, int columns, int[] stride) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(int rows, int columns, int[] stride, char ordering) Creates an ndarray with the specified shape
INDArray	BaseNDArrayFactory.create(int rows, int columns, int[] stride, int offset) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(int rows, int columns, int[] stride, int offset) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(int rows, int columns, int[] stride, int offset) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(int rows, int columns, int[] stride, int offset, char ordering) Creates an ndarray with the specified shape
abstract INDArray	BaseNDArrayFactory.create(List<INDArray> list, int[] shape) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(List<INDArray> list, int[] shape) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(List<INDArray> list, int[] shape) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(List<INDArray> list, int[] shape, char ordering) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(List<INDArray> list, int[] shape, char ordering)
static INDArray	Nd4j.cumsum(INDArray compute)
static INDArray	Nd4j.cumsum(INDArray compute, int dimension)
static INDArray	Nd4j.diag(INDArray x) Creates a new matrix where the values of the given vector are the diagonal values of the matrix if a vector is passed in, if a matrix is returns the kth diagonal in the matrix
static INDArray	Nd4j.diag(INDArray x, int k) Creates a new matrix where the values of the given vector are the diagonal values of the matrix if a vector is passed in, if a matrix is returns the kth diagonal in the matrix
static INDArray	Nd4j.emptyLike(INDArray arr) Empty like
INDArray	BaseNDArrayFactory.eye(int n) Create the identity ndarray
static INDArray	Nd4j.eye(int n) Create the identity ndarray
INDArray	NDArrayFactory.eye(int n) Create the identity ndarray
INDArray	BlasWrapper.gemm(double alpha, INDArray a, INDArray b, double beta, INDArray c) ************************************************************************ BLAS Level 3
INDArray	BlasWrapper.gemv(double alpha, INDArray a, INDArray x, double beta, INDArray y) ************************************************************************ BLAS Level 2
INDArray	BlasWrapper.ger(double alpha, INDArray x, INDArray y, INDArray a)
INDArray	BaseNDArrayFactory.hstack(INDArray... arrs) Concatenates two matrices horizontally.
static INDArray	Nd4j.hstack(INDArray... arrs) Concatenates two matrices horizontally.
INDArray	NDArrayFactory.hstack(INDArray... arrs) Concatenates two matrices horizontally.
INDArray	BaseNDArrayFactory.linspace(int lower, int upper, int num) Generate a linearly spaced vector
static INDArray	Nd4j.linspace(int lower, int upper, int num) Generate a linearly spaced vector
INDArray	NDArrayFactory.linspace(int lower, int upper, int num) Generate a linearly spaced vector
static INDArray	Nd4j.max(INDArray compute)
static INDArray	Nd4j.max(INDArray compute, int dimension)
static INDArray	Nd4j.mean(INDArray compute)
static INDArray	Nd4j.mean(INDArray compute, int dimension)
static INDArray	Nd4j.min(INDArray compute)
static INDArray	Nd4j.min(INDArray compute, int dimension)
static INDArray	Nd4j.norm1(INDArray compute)
static INDArray	Nd4j.norm1(INDArray compute, int dimension)
static INDArray	Nd4j.norm2(INDArray compute)
static INDArray	Nd4j.norm2(INDArray compute, int dimension)
static INDArray	Nd4j.normmax(INDArray compute)
static INDArray	Nd4j.normmax(INDArray compute, int dimension)
static INDArray	Nd4j.ones(int... shape) Create an ndarray of ones
INDArray	BaseNDArrayFactory.ones(int columns) Creates a row vector with the specified number of columns
static INDArray	Nd4j.ones(int columns) Creates a row vector with the specified number of columns
INDArray	NDArrayFactory.ones(int columns) Creates a row vector with the specified number of columns
INDArray	BaseNDArrayFactory.ones(int[] shape) Create an ndarray of ones
INDArray	NDArrayFactory.ones(int[] shape) Create an ndarray of ones
INDArray	BaseNDArrayFactory.ones(int rows, int columns) Creates a row vector with the specified number of columns
static INDArray	Nd4j.ones(int rows, int columns) Creates a row vector with the specified number of columns
INDArray	NDArrayFactory.ones(int rows, int columns) Creates a row vector with the specified number of columns
static INDArray	Nd4j.onesLike(INDArray arr) Ones like
static INDArray	Nd4j.prod(INDArray compute)
static INDArray	Nd4j.prod(INDArray compute, int dimension)
INDArray	BaseNDArrayFactory.rand(int[] shape) Create a random ndarray with the given shape using the current time as the seed
static INDArray	Nd4j.rand(int[] shape) Create a random ndarray with the given shape using the current time as the seed
INDArray	NDArrayFactory.rand(int[] shape) Create a random ndarray with the given shape using the current time as the seed
INDArray	BaseNDArrayFactory.rand(int[] shape, Distribution r) Create a random ndarray with the given shape using the given rng
static INDArray	Nd4j.rand(int[] shape, Distribution r) Create a random ndarray with the given shape using the given rng
INDArray	NDArrayFactory.rand(int[] shape, Distribution r) Create a random ndarray with the given shape using the given rng
INDArray	BaseNDArrayFactory.rand(int[] shape, double min, double max, Random rng)
static INDArray	Nd4j.rand(int[] shape, double min, double max, Random rng) Generates a random matrix between min and max
INDArray	NDArrayFactory.rand(int[] shape, double min, double max, Random rng)
INDArray	BaseNDArrayFactory.rand(int[] shape, float min, float max, Random rng) Generates a random matrix between min and max
INDArray	NDArrayFactory.rand(int[] shape, float min, float max, Random rng) Generates a random matrix between min and max
INDArray	BaseNDArrayFactory.rand(int[] shape, long seed) Create a random ndarray with the given shape using the given rng
static INDArray	Nd4j.rand(int[] shape, long seed) Create a random ndarray with the given shape using the given rng
INDArray	NDArrayFactory.rand(int[] shape, long seed) Create a random ndarray with the given shape using the given rng
INDArray	BaseNDArrayFactory.rand(int[] shape, Random r) Create a random ndarray with the given shape using the given rng
static INDArray	Nd4j.rand(int[] shape, Random r) Create a random ndarray with the given shape using the given rng
INDArray	NDArrayFactory.rand(int[] shape, Random r) Create a random ndarray with the given shape using the given rng
INDArray	BaseNDArrayFactory.rand(int rows, int columns) Create a random ndarray with the given shape using the current time as the seed
static INDArray	Nd4j.rand(int rows, int columns) Create a random ndarray with the given shape using the current time as the seed
INDArray	NDArrayFactory.rand(int rows, int columns) Create a random ndarray with the given shape using the current time as the seed
INDArray	BaseNDArrayFactory.rand(int rows, int columns, double min, double max, Random rng)
static INDArray	Nd4j.rand(int rows, int columns, double min, double max, Random rng) Generates a random matrix between min and max
INDArray	NDArrayFactory.rand(int rows, int columns, double min, double max, Random rng)
INDArray	BaseNDArrayFactory.rand(int rows, int columns, float min, float max, Random rng) Generates a random matrix between min and max
INDArray	NDArrayFactory.rand(int rows, int columns, float min, float max, Random rng) Generates a random matrix between min and max
INDArray	BaseNDArrayFactory.rand(int rows, int columns, long seed) Create a random ndarray with the given shape using the given rng
static INDArray	Nd4j.rand(int rows, int columns, long seed) Create a random ndarray with the given shape using the given rng
INDArray	NDArrayFactory.rand(int rows, int columns, long seed) Create a random ndarray with the given shape using the given rng
INDArray	BaseNDArrayFactory.rand(int rows, int columns, Random r) Create a random ndarray with the given shape using the given rng
static INDArray	Nd4j.rand(int rows, int columns, Random r) Deprecated.
INDArray	NDArrayFactory.rand(int rows, int columns, Random r) Create a random ndarray with the given shape using the given rng
static INDArray	Nd4j.rand(long seed, int... shape) Create a random ndarray with the given shape using the given rng
INDArray	BaseNDArrayFactory.randn(int[] shape) Random normal using the current time stamp as the seed
static INDArray	Nd4j.randn(int[] shape) Random normal using the current time stamp as the seed
INDArray	NDArrayFactory.randn(int[] shape) Random normal using the current time stamp as the seed
INDArray	BaseNDArrayFactory.randn(int[] shape, long seed) Random normal using the specified seed
static INDArray	Nd4j.randn(int[] shape, long seed) Random normal using the specified seed
INDArray	NDArrayFactory.randn(int[] shape, long seed) Random normal using the specified seed
INDArray	BaseNDArrayFactory.randn(int[] shape, Random r) Random normal using the given rng
static INDArray	Nd4j.randn(int[] shape, Random r) Random normal using the given rng
INDArray	NDArrayFactory.randn(int[] shape, Random r) Random normal using the given rng
INDArray	BaseNDArrayFactory.randn(int rows, int columns) Random normal using the current time stamp as the seed
static INDArray	Nd4j.randn(int rows, int columns) Random normal using the current time stamp as the seed
INDArray	NDArrayFactory.randn(int rows, int columns) Random normal using the current time stamp as the seed
INDArray	BaseNDArrayFactory.randn(int rows, int columns, long seed) Random normal using the specified seed
static INDArray	Nd4j.randn(int rows, int columns, long seed) Random normal using the specified seed
INDArray	NDArrayFactory.randn(int rows, int columns, long seed) Random normal using the specified seed
INDArray	BaseNDArrayFactory.randn(int rows, int columns, Random r) Random normal using the given rng
static INDArray	Nd4j.randn(int rows, int columns, Random r) Random normal using the given rng
INDArray	NDArrayFactory.randn(int rows, int columns, Random r) Random normal using the given rng
static INDArray	Nd4j.read(DataInputStream dis) Read in an ndarray from a data input stream
static INDArray	Nd4j.readTxt(InputStream filePath, String split) Read line via input streams
static INDArray	Nd4j.readTxt(String filePath) Read line via input streams
static INDArray	Nd4j.readTxt(String filePath, String split) Read line via input streams
static INDArray	Nd4j.repeat(INDArray n, int num) Create an n x (shape) ndarray where the ndarray is repeated num times
INDArray	BaseNDArrayFactory.reverse(INDArray reverse) Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
static INDArray	Nd4j.reverse(INDArray reverse) Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
INDArray	NDArrayFactory.reverse(INDArray reverse) Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
INDArray	BaseNDArrayFactory.rot(INDArray reverse) Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
static INDArray	Nd4j.rot(INDArray reverse) Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
INDArray	NDArrayFactory.rot(INDArray reverse) Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
INDArray	BlasWrapper.scal(double alpha, INDArray x)
INDArray	BaseNDArrayFactory.scalar(double value) Create a scalar nd array with the specified value and offset
static INDArray	Nd4j.scalar(double value) Create a scalar nd array with the specified value and offset
INDArray	NDArrayFactory.scalar(double value) Create a scalar nd array with the specified value and offset
INDArray	BaseNDArrayFactory.scalar(double value, int offset) Create a scalar nd array with the specified value and offset
static INDArray	Nd4j.scalar(double value, int offset) Create a scalar nd array with the specified value and offset
INDArray	NDArrayFactory.scalar(double value, int offset) Create a scalar nd array with the specified value and offset
INDArray	BaseNDArrayFactory.scalar(float value) Create a scalar nd array with the specified value and offset
static INDArray	Nd4j.scalar(float value) Create a scalar nd array with the specified value and offset
INDArray	NDArrayFactory.scalar(float value) Create a scalar nd array with the specified value and offset
INDArray	BaseNDArrayFactory.scalar(float value, int offset) Create a scalar nd array with the specified value and offset
static INDArray	Nd4j.scalar(float value, int offset) Create a scalar nd array with the specified value and offset
INDArray	NDArrayFactory.scalar(float value, int offset) Create a scalar nd array with the specified value and offset
INDArray	BaseNDArrayFactory.scalar(int value, int offset) Create a scalar nd array with the specified value and offset
INDArray	NDArrayFactory.scalar(int value, int offset)
INDArray	BaseNDArrayFactory.scalar(Number value) Create a scalar ndarray with the specified offset
static INDArray	Nd4j.scalar(Number value) Create a scalar ndarray with the specified offset
INDArray	NDArrayFactory.scalar(Number value) Create a scalar ndarray with the specified offset
INDArray	BaseNDArrayFactory.scalar(Number value, int offset) Create a scalar ndarray with the specified offset
static INDArray	Nd4j.scalar(Number value, int offset) Create a scalar ndarray with the specified offset
INDArray	NDArrayFactory.scalar(Number value, int offset) Create a scalar ndarray with the specified offset
static INDArray	Nd4j.sort(INDArray ndarray, int dimension, boolean ascending) Sort an ndarray along a particular dimension
static INDArray[]	Nd4j.sortWithIndices(IComplexNDArray ndarray, int dimension, boolean ascending) Sort an ndarray along a particular dimension
static INDArray[]	Nd4j.sortWithIndices(INDArray ndarray, int dimension, boolean ascending) Sort an ndarray along a particular dimension
static INDArray	Nd4j.std(INDArray compute)
static INDArray	Nd4j.std(INDArray compute, int dimension)
static INDArray	Nd4j.sum(INDArray compute)
static INDArray	Nd4j.sum(INDArray compute, int dimension)
static INDArray	Nd4j.tile(INDArray tile, int... repeat) An alias for repmat
INDArray	BaseNDArrayFactory.toFlattened(Collection<INDArray> matrices) Returns a vector with all of the elements in every nd array equal to the sum of the lengths of the ndarrays
static INDArray	Nd4j.toFlattened(Collection<INDArray> matrices) Create a long row vector of all of the given ndarrays
INDArray	NDArrayFactory.toFlattened(Collection<INDArray> matrices) /** Returns a flattened ndarray with all of the elements in each ndarray regardless of dimension
INDArray	BaseNDArrayFactory.toFlattened(INDArray... matrices)
static INDArray	Nd4j.toFlattened(INDArray... matrices) Create a long row vector of all of the given ndarrays
INDArray	NDArrayFactory.toFlattened(INDArray... matrices) Flatten all of the ndarrays in to one long vector
INDArray	BaseNDArrayFactory.toFlattened(int length, Iterator<? extends INDArray>... matrices)
static INDArray	Nd4j.toFlattened(int length, Iterator<? extends INDArray>... matrices) Create a long row vector of all of the given ndarrays
INDArray	NDArrayFactory.toFlattened(int length, Iterator<? extends INDArray>... matrices) Returns a flattened ndarray with all of the elements in each ndarray regardless of dimension
INDArray	BaseNDArrayFactory.valueArrayOf(int[] shape, double value) Creates an ndarray with the specified value as the only value in the ndarray
static INDArray	Nd4j.valueArrayOf(int[] shape, double value) Creates an ndarray with the specified value as the only value in the ndarray
INDArray	NDArrayFactory.valueArrayOf(int[] shape, double value) Creates an ndarray with the specified value as the only value in the ndarray
static INDArray	Nd4j.valueArrayOf(int num, double value) Creates an ndarray with the specified value as the only value in the ndarray
INDArray	BaseNDArrayFactory.valueArrayOf(int rows, int columns, double value) Creates a row vector with the specified number of columns
static INDArray	Nd4j.valueArrayOf(int rows, int columns, double value) Creates a row vector with the specified number of columns
INDArray	NDArrayFactory.valueArrayOf(int rows, int columns, double value) Creates a row vector with the specified number of columns
static INDArray	Nd4j.var(INDArray compute)
static INDArray	Nd4j.var(INDArray compute, int dimension)
INDArray	BaseNDArrayFactory.vstack(INDArray... arrs) Concatenates two matrices vertically.
static INDArray	Nd4j.vstack(INDArray... arrs) Concatenates two matrices vertically.
INDArray	NDArrayFactory.vstack(INDArray... arrs) Concatenates two matrices vertically.
INDArray	BaseNDArrayFactory.zeros(int columns) Creates a row vector with the specified number of columns
static INDArray	Nd4j.zeros(int columns) Creates a row vector with the specified number of columns
INDArray	NDArrayFactory.zeros(int columns) Creates a row vector with the specified number of columns
INDArray	BaseNDArrayFactory.zeros(int[] shape) Create an ndarray of zeros
static INDArray	Nd4j.zeros(int[] shape) Create an ndarray of zeros
INDArray	NDArrayFactory.zeros(int[] shape) Create an ndarray of zeros
INDArray	BaseNDArrayFactory.zeros(int rows, int columns) Creates a row vector with the specified number of columns
static INDArray	Nd4j.zeros(int rows, int columns) Creates a row vector with the specified number of columns
INDArray	NDArrayFactory.zeros(int rows, int columns) Creates a row vector with the specified number of columns
static INDArray	Nd4j.zerosLike(INDArray arr) Empty like

Methods in org.nd4j.linalg.factory that return types with arguments of type INDArray

Modifier and Type	Method and Description
static ReferenceQueue<INDArray>	Nd4j.refQueue() The reference queue used for cleaning up ndarrays

Methods in org.nd4j.linalg.factory with parameters of type INDArray

Modifier and Type	Method and Description
INDArray	BaseNDArrayFactory.appendBias(INDArray... vectors) Merge the vectors and append a bias.
static INDArray	Nd4j.appendBias(INDArray... vectors)
INDArray	NDArrayFactory.appendBias(INDArray... vectors)
static void	DataTypeValidation.assertDouble(INDArray... d)
static void	DataTypeValidation.assertDouble(INDArray d)
static void	DataTypeValidation.assertFloat(INDArray... d2)
static void	DataTypeValidation.assertFloat(INDArray d2)
static void	DataTypeValidation.assertSameDataType(INDArray... indArrays)
INDArray	BlasWrapper.axpy(double da, INDArray dx, INDArray dy)
INDArray	BaseNDArrayFactory.bilinearProducts(INDArray curr, INDArray in) Returns a column vector where each entry is the nth bilinear product of the nth slices of the two tensors.
static INDArray	Nd4j.bilinearProducts(INDArray curr, INDArray in) Returns a column vector where each entry is the nth bilinear product of the nth slices of the two tensors.
INDArray	NDArrayFactory.bilinearProducts(INDArray curr, INDArray in) Returns a column vector where each entry is the nth bilinear product of the nth slices of the two tensors.
static void	Nd4j.clearNans(INDArray arr) Clear nans from an ndarray
INDArray	BaseNDArrayFactory.concat(int dimension, INDArray... toConcat) concatenate ndarrays along a dimension
static INDArray	Nd4j.concat(int dimension, INDArray... toConcat) Concatneate ndarrays along a dimension
INDArray	NDArrayFactory.concat(int dimension, INDArray... toConcat) Concatneate ndarrays along a dimension
void	BaseNDArrayFactory.copy(INDArray a, INDArray b) Copy a to b
static void	Nd4j.copy(INDArray a, INDArray b) Copy a to b
void	NDArrayFactory.copy(INDArray a, INDArray b) Copy a to b
abstract IComplexNDArray	BaseNDArrayFactory.createComplex(INDArray arr) Create a complex ndarray from the passed in indarray
static IComplexNDArray	Nd4j.createComplex(INDArray arr) Create a complex ndarray from the passed in indarray
IComplexNDArray	NDArrayFactory.createComplex(INDArray arr) Create a complex ndarray from the passed in indarray
static IComplexNDArray	Nd4j.createComplex(INDArray real, INDArray imag) Create a complex ndarray based on the real and imaginary
static INDArray	Nd4j.cumsum(INDArray compute)
static INDArray	Nd4j.cumsum(INDArray compute, int dimension)
static INDArray	Nd4j.diag(INDArray x) Creates a new matrix where the values of the given vector are the diagonal values of the matrix if a vector is passed in, if a matrix is returns the kth diagonal in the matrix
static INDArray	Nd4j.diag(INDArray x, int k) Creates a new matrix where the values of the given vector are the diagonal values of the matrix if a vector is passed in, if a matrix is returns the kth diagonal in the matrix
static void	Nd4j.doAlongDiagonal(INDArray x, com.google.common.base.Function<Number,Number> func) Perform an operation along a diagonal
static INDArray	Nd4j.emptyLike(INDArray arr) Empty like
INDArray	BlasWrapper.gemm(double alpha, INDArray a, INDArray b, double beta, INDArray c) ************************************************************************ BLAS Level 3
INDArray	BlasWrapper.gemv(double alpha, INDArray a, INDArray x, double beta, INDArray y) ************************************************************************ BLAS Level 2
INDArray	BlasWrapper.ger(double alpha, INDArray x, INDArray y, INDArray a)
static boolean	Nd4j.hasInvalidNumber(INDArray num) Returns true if the given ndarray has either an infinite or nan
INDArray	BaseNDArrayFactory.hstack(INDArray... arrs) Concatenates two matrices horizontally.
static INDArray	Nd4j.hstack(INDArray... arrs) Concatenates two matrices horizontally.
INDArray	NDArrayFactory.hstack(INDArray... arrs) Concatenates two matrices horizontally.
static INDArray	Nd4j.max(INDArray compute)
static INDArray	Nd4j.max(INDArray compute, int dimension)
static INDArray	Nd4j.mean(INDArray compute)
static INDArray	Nd4j.mean(INDArray compute, int dimension)
static INDArray	Nd4j.min(INDArray compute)
static INDArray	Nd4j.min(INDArray compute, int dimension)
static INDArray	Nd4j.norm1(INDArray compute)
static INDArray	Nd4j.norm1(INDArray compute, int dimension)
static INDArray	Nd4j.norm2(INDArray compute)
static INDArray	Nd4j.norm2(INDArray compute, int dimension)
static INDArray	Nd4j.normmax(INDArray compute)
static INDArray	Nd4j.normmax(INDArray compute, int dimension)
static INDArray	Nd4j.onesLike(INDArray arr) Ones like
static INDArray	Nd4j.prod(INDArray compute)
static INDArray	Nd4j.prod(INDArray compute, int dimension)
static INDArray	Nd4j.repeat(INDArray n, int num) Create an n x (shape) ndarray where the ndarray is repeated num times
INDArray	BaseNDArrayFactory.reverse(INDArray reverse) Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
static INDArray	Nd4j.reverse(INDArray reverse) Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
INDArray	NDArrayFactory.reverse(INDArray reverse) Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
INDArray	BaseNDArrayFactory.rot(INDArray reverse) Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
static INDArray	Nd4j.rot(INDArray reverse) Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
INDArray	NDArrayFactory.rot(INDArray reverse) Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
void	BaseNDArrayFactory.rot90(INDArray toRotate) Rotate a matrix 90 degrees
static void	Nd4j.rot90(INDArray toRotate) Rotate a matrix 90 degrees
void	NDArrayFactory.rot90(INDArray toRotate) Rotate a matrix 90 degrees
void	BlasWrapper.saxpy(double alpha, INDArray x, INDArray y)
void	BlasWrapper.saxpy(float alpha, INDArray x, INDArray y) Abstraction over saxpy
INDArray	BlasWrapper.scal(double alpha, INDArray x)
static void	Nd4j.setParams(INDArray theta, Collection<INDArray>... matrices) Given a sequence of Iterators over a applyTransformToDestination of matrices, fill in all of the matrices with the entries in the theta vector.
static void	Nd4j.setParams(INDArray theta, Iterator<? extends INDArray>... matrices) Given a sequence of Iterators over a applyTransformToDestination of matrices, fill in all of the matrices with the entries in the theta vector.
static int[]	Nd4j.shape(INDArray arr) Returns the shape of the ndarray
static INDArray	Nd4j.sort(INDArray ndarray, int dimension, boolean ascending) Sort an ndarray along a particular dimension
static INDArray[]	Nd4j.sortWithIndices(INDArray ndarray, int dimension, boolean ascending) Sort an ndarray along a particular dimension
static INDArray	Nd4j.std(INDArray compute)
static INDArray	Nd4j.std(INDArray compute, int dimension)
static INDArray	Nd4j.sum(INDArray compute)
static INDArray	Nd4j.sum(INDArray compute, int dimension)
int	BlasWrapper.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	BlasWrapper.syevx(char jobz, char range, char uplo, INDArray a, double vl, double vu, int il, int iu, double abstol, INDArray w, INDArray z)
static INDArray	Nd4j.tile(INDArray tile, int... repeat) An alias for repmat
INDArray	BaseNDArrayFactory.toFlattened(INDArray... matrices)
static INDArray	Nd4j.toFlattened(INDArray... matrices) Create a long row vector of all of the given ndarrays
INDArray	NDArrayFactory.toFlattened(INDArray... matrices) Flatten all of the ndarrays in to one long vector
protected static void	BaseNDArrayFactory.validateConcat(int dimension, INDArray... arrs)
static INDArray	Nd4j.var(INDArray compute)
static INDArray	Nd4j.var(INDArray compute, int dimension)
INDArray	BaseNDArrayFactory.vstack(INDArray... arrs) Concatenates two matrices vertically.
static INDArray	Nd4j.vstack(INDArray... arrs) Concatenates two matrices vertically.
INDArray	NDArrayFactory.vstack(INDArray... arrs) Concatenates two matrices vertically.
static void	Nd4j.write(INDArray arr, DataOutputStream dataOutputStream) Write an ndarray to the specified outputstream
static void	Nd4j.writeTxt(INDArray write, String filePath, String split) Read line via input streams
static INDArray	Nd4j.zerosLike(INDArray arr) Empty like

Method parameters in org.nd4j.linalg.factory with type arguments of type INDArray

Modifier and Type	Method and Description
abstract INDArray	BaseNDArrayFactory.create(List<INDArray> list, int[] shape) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(List<INDArray> list, int[] shape) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(List<INDArray> list, int[] shape) Creates an ndarray with the specified shape
static INDArray	Nd4j.create(List<INDArray> list, int[] shape, char ordering) Creates an ndarray with the specified shape
INDArray	NDArrayFactory.create(List<INDArray> list, int[] shape, char ordering)
INDArray	BaseNDArrayFactory.toFlattened(Collection<INDArray> matrices) Returns a vector with all of the elements in every nd array equal to the sum of the lengths of the ndarrays
static INDArray	Nd4j.toFlattened(Collection<INDArray> matrices) Create a long row vector of all of the given ndarrays
INDArray	NDArrayFactory.toFlattened(Collection<INDArray> matrices) /** Returns a flattened ndarray with all of the elements in each ndarray regardless of dimension

Uses of INDArray in org.nd4j.linalg.fft

Methods in org.nd4j.linalg.fft with parameters of type INDArray

Modifier and Type	Method and Description
IComplexNDArray	BaseFFTInstance.fft(INDArray input) 1d discrete fourier op, note that this will throw an exception if the passed in input isn't a vector.
IComplexNDArray	FFTInstance.fft(INDArray input) 1d discrete fourier op, note that this will throw an exception if the passed in input isn't a vector.
static IComplexNDArray	FFT.fft(INDArray input) 1d discrete fourier op, note that this will throw an exception if the passed in input isn't a vector.
IComplexNDArray	BaseFFTInstance.fft(INDArray transform, int numElements) FFT along a particular dimension
IComplexNDArray	FFTInstance.fft(INDArray transform, int numElements) FFT along a particular dimension
static IComplexNDArray	FFT.fft(INDArray transform, int numElements) FFT along a particular dimension
IComplexNDArray	FFTInstance.fft(INDArray transform, int numElements, int dimension) FFT along a particular dimension
static IComplexNDArray	FFT.fft(INDArray transform, int numElements, int dimension) FFT along a particular dimension
IComplexNDArray	DefaultFFTInstance.fft(INDArray transform, int numElements, int dimension) FFT along a particular dimension
IComplexNDArray	BaseFFTInstance.fftn(INDArray transform) FFT on the whole array (n is equal the first dimension shape)
IComplexNDArray	FFTInstance.fftn(INDArray transform) FFT on the whole array (n is equal the first dimension shape)
static IComplexNDArray	FFT.fftn(INDArray transform) FFT on the whole array (n is equal the first dimension shape)
IComplexNDArray	BaseFFTInstance.fftn(INDArray transform, int dimension, int numElements) Computes the fft along the first non singleton dimension of op when it is a matrix
IComplexNDArray	FFTInstance.fftn(INDArray transform, int dimension, int numElements) Computes the fft along the first non singleton dimension of op when it is a matrix
static IComplexNDArray	FFT.fftn(INDArray transform, int dimension, int numElements) Computes the fft along the first non singleton dimension of op when it is a matrix
protected Op	DefaultFFTInstance.getFftOp(INDArray arr, int n)
protected Op	DefaultFFTInstance.getIfftOp(INDArray arr, int n)
IComplexNDArray	FFTInstance.ifft(INDArray transform, int numElements) FFT along a particular dimension
static IComplexNDArray	FFT.ifft(INDArray transform, int numElements) FFT along a particular dimension
IComplexNDArray	DefaultFFTInstance.ifft(INDArray transform, int numElements) FFT along a particular dimension
IComplexNDArray	FFTInstance.ifft(INDArray transform, int numElements, int dimension) IFFT along a particular dimension
static IComplexNDArray	FFT.ifft(INDArray transform, int numElements, int dimension) IFFT along a particular dimension
IComplexNDArray	DefaultFFTInstance.ifft(INDArray transform, int numElements, int dimension) IFFT along a particular dimension
IComplexNDArray	BaseFFTInstance.ifftn(INDArray transform)
IComplexNDArray	FFTInstance.ifftn(INDArray transform)
IComplexNDArray	BaseFFTInstance.ifftn(INDArray transform, int dimension, int numElements) ND IFFT, computes along the first on singleton dimension of op
IComplexNDArray	FFTInstance.ifftn(INDArray transform, int dimension, int numElements) ND IFFT, computes along the first on singleton dimension of op
static IComplexNDArray	FFT.ifftn(INDArray transform, int dimension, int numElements) ND IFFT, computes along the first on singleton dimension of op

Uses of INDArray in org.nd4j.linalg.indexing

Methods in org.nd4j.linalg.indexing with parameters of type INDArray

Modifier and Type	Method and Description
static boolean	BooleanIndexing.and(INDArray n, Condition cond) And over the whole ndarray given some condition
static void	BooleanIndexing.applyWhere(INDArray to, Condition condition, com.google.common.base.Function<Number,Number> function) Based on the matching elements op to based on condition to with function function
static NDArrayIndex[]	NDArrayIndex.create(INDArray index) Create from a matrix.
static NDArrayIndex[]	Indices.createFromStartAndEnd(INDArray start, INDArray end) Create an n dimensional index based on the given interval indices.
static NDArrayIndex[]	Indices.createFromStartAndEnd(INDArray start, INDArray end, boolean inclusive) Create indices representing intervals along each dimension
static int[]	Indices.linearIndices(INDArray arr) Calculate the linear indices for an ndarray
static int	Indices.linearOffset(int index, INDArray arr) Compute the linear offset for an index in an ndarray.
static boolean	BooleanIndexing.or(INDArray n, Condition cond) Or over the whole ndarray given some condition
static int	Indices.rowNumber(int index, INDArray arr) Compute the linear offset for an index in an ndarray.

Uses of INDArray in org.nd4j.linalg.learning

Fields in org.nd4j.linalg.learning declared as INDArray

Modifier and Type	Field and Description
INDArray	AdaGrad.historicalGradient

Methods in org.nd4j.linalg.learning that return INDArray

Modifier and Type	Method and Description
INDArray	AdaGrad.getGradient(INDArray gradient) Gets feature specific learning rates Adagrad keeps a history of gradients being passed in.
INDArray	AdaGrad.getGradient(INDArray gradient, int slice, int[] shape) Gets feature specific learning rates Adagrad keeps a history of gradients being passed in.
INDArray	AdaGrad.getHistoricalGradient()

Methods in org.nd4j.linalg.learning with parameters of type INDArray

Modifier and Type	Method and Description
INDArray	AdaGrad.getGradient(INDArray gradient) Gets feature specific learning rates Adagrad keeps a history of gradients being passed in.
INDArray	AdaGrad.getGradient(INDArray gradient, int slice, int[] shape) Gets feature specific learning rates Adagrad keeps a history of gradients being passed in.
void	AdaGrad.setHistoricalGradient(INDArray historicalGradient)

Uses of INDArray in org.nd4j.linalg.lossfunctions

Methods in org.nd4j.linalg.lossfunctions with parameters of type INDArray

Modifier and Type	Method and Description
static double	LossFunctions.score(INDArray labels, LossFunctions.LossFunction lossFunction, INDArray z, double l2, boolean useRegularization) Generic scoring function.

Uses of INDArray in org.nd4j.linalg.ops.transforms

Methods in org.nd4j.linalg.ops.transforms that return INDArray

Modifier and Type	Method and Description
static INDArray	Transforms.abs(INDArray ndArray) Abs funciton
static INDArray	Transforms.abs(INDArray ndArray, boolean dup) Abs function
static INDArray	Transforms.avgPooling(INDArray toPool, int[] stride) Pooled expectations(avg)
static INDArray	Transforms.ceiling(INDArray ndArray) Binary matrix of whether the number at a given index is greater than
static INDArray	Transforms.ceiling(INDArray ndArray, boolean copyOnOps) Ceiling function
static INDArray	Transforms.downSample(INDArray d1, int[] stride) Down sampling a signal for the first stride dimensions
static INDArray	Transforms.eps(INDArray ndArray)
static INDArray	Transforms.eps(INDArray ndArray, boolean dup) Eps function
static INDArray	Transforms.exp(INDArray ndArray)
static INDArray	Transforms.exp(INDArray ndArray, boolean dup) Exp function
static INDArray	Transforms.floor(INDArray ndArray) Binary matrix of whether the number at a given index is greater than
static INDArray	Transforms.floor(INDArray ndArray, boolean dup) Floor function
static INDArray	Transforms.greaterThanOrEqual(INDArray first, INDArray ndArray) 1 if greater than or equal to 0 otherwise (at each element)
static INDArray	Transforms.greaterThanOrEqual(INDArray first, INDArray ndArray, boolean dup) Eps function
static INDArray	Transforms.hardTanh(INDArray ndArray)
static INDArray	Transforms.hardTanh(INDArray ndArray, boolean dup) Hard tanh
static INDArray	Transforms.identity(INDArray ndArray)
static INDArray	Transforms.identity(INDArray ndArray, boolean dup) Identity function
static INDArray	Transforms.lessThanOrEqual(INDArray first, INDArray ndArray) 1 if less than or equal to 0 otherwise (at each element)
static INDArray	Transforms.lessThanOrEqual(INDArray first, INDArray ndArray, boolean dup) Eps function
static INDArray	Transforms.log(INDArray ndArray)
static INDArray	Transforms.log(INDArray ndArray, boolean dup) Log function
static INDArray	Transforms.max(INDArray ndArray, double k) Stabilize to be within a range of k
static INDArray	Transforms.max(INDArray ndArray, double k, boolean dup) Stabilize to be within a range of k
static INDArray	Transforms.maxPool(INDArray input, int[] ds, boolean ignoreBorder) Max poolingi
static INDArray	Transforms.neg(INDArray ndArray) Returns the negative of an ndarray
static INDArray	Transforms.neg(INDArray ndArray, boolean dup) Negative
static INDArray	Transforms.normalizeZeroMeanAndUnitVariance(INDArray toNormalize) Normalize data to zero mean and unit variance substract by the mean and divide by the standard deviation
static INDArray	Transforms.pow(INDArray ndArray, Number power) Pow function
static INDArray	Transforms.pow(INDArray ndArray, Number power, boolean dup) Pow function
static INDArray	Transforms.round(INDArray ndArray) Rounding function
static INDArray	Transforms.round(INDArray ndArray, boolean dup) Rounding function
static INDArray	Transforms.sigmoid(INDArray ndArray) Sigmoid function
static INDArray	Transforms.sigmoid(INDArray ndArray, boolean dup) Sigmoid function
static INDArray	Transforms.sign(INDArray toSign) Signum function of this ndarray
static INDArray	Transforms.sign(INDArray toSign, boolean dup) Signum function of this ndarray
static INDArray	Transforms.sqrt(INDArray ndArray) Sqrt function
static INDArray	Transforms.sqrt(INDArray ndArray, boolean dup) Sqrt function
static INDArray	Transforms.stabilize(INDArray ndArray, double k)
static INDArray	Transforms.stabilize(INDArray ndArray, double k, boolean dup) Stabilize to be within a range of k
static INDArray	Transforms.sumPooling(INDArray toPool, int[] stride) Pooled expectations(sum)
static INDArray	Transforms.tanh(INDArray ndArray) Tanh function
static INDArray	Transforms.tanh(INDArray ndArray, boolean dup) Tanh function
static INDArray	Transforms.unitVec(INDArray toScale) Scale by 1 / norm2 of the matrix
static INDArray	Transforms.upSample(INDArray d, INDArray scale) Upsampling a signal (specifically the first 2 dimensions)

Methods in org.nd4j.linalg.ops.transforms with parameters of type INDArray

Modifier and Type	Method and Description
static INDArray	Transforms.abs(INDArray ndArray) Abs funciton
static INDArray	Transforms.abs(INDArray ndArray, boolean dup) Abs function
static INDArray	Transforms.avgPooling(INDArray toPool, int[] stride) Pooled expectations(avg)
static INDArray	Transforms.ceiling(INDArray ndArray) Binary matrix of whether the number at a given index is greater than
static INDArray	Transforms.ceiling(INDArray ndArray, boolean copyOnOps) Ceiling function
static double	Transforms.cosineSim(INDArray d1, INDArray d2) Cosine similarity
static INDArray	Transforms.downSample(INDArray d1, int[] stride) Down sampling a signal for the first stride dimensions
static INDArray	Transforms.eps(INDArray ndArray)
static INDArray	Transforms.eps(INDArray ndArray, boolean dup) Eps function
static INDArray	Transforms.exp(INDArray ndArray)
static INDArray	Transforms.exp(INDArray ndArray, boolean dup) Exp function
static INDArray	Transforms.floor(INDArray ndArray) Binary matrix of whether the number at a given index is greater than
static INDArray	Transforms.floor(INDArray ndArray, boolean dup) Floor function
static INDArray	Transforms.greaterThanOrEqual(INDArray first, INDArray ndArray) 1 if greater than or equal to 0 otherwise (at each element)
static INDArray	Transforms.greaterThanOrEqual(INDArray first, INDArray ndArray, boolean dup) Eps function
static INDArray	Transforms.hardTanh(INDArray ndArray)
static INDArray	Transforms.hardTanh(INDArray ndArray, boolean dup) Hard tanh
static INDArray	Transforms.identity(INDArray ndArray)
static INDArray	Transforms.identity(INDArray ndArray, boolean dup) Identity function
static INDArray	Transforms.lessThanOrEqual(INDArray first, INDArray ndArray) 1 if less than or equal to 0 otherwise (at each element)
static INDArray	Transforms.lessThanOrEqual(INDArray first, INDArray ndArray, boolean dup) Eps function
static INDArray	Transforms.log(INDArray ndArray)
static INDArray	Transforms.log(INDArray ndArray, boolean dup) Log function
static INDArray	Transforms.max(INDArray ndArray, double k) Stabilize to be within a range of k
static INDArray	Transforms.max(INDArray ndArray, double k, boolean dup) Stabilize to be within a range of k
static INDArray	Transforms.maxPool(INDArray input, int[] ds, boolean ignoreBorder) Max poolingi
static INDArray	Transforms.neg(INDArray ndArray) Returns the negative of an ndarray
static INDArray	Transforms.neg(INDArray ndArray, boolean dup) Negative
static INDArray	Transforms.normalizeZeroMeanAndUnitVariance(INDArray toNormalize) Normalize data to zero mean and unit variance substract by the mean and divide by the standard deviation
static INDArray	Transforms.pow(INDArray ndArray, Number power) Pow function
static INDArray	Transforms.pow(INDArray ndArray, Number power, boolean dup) Pow function
static INDArray	Transforms.round(INDArray ndArray) Rounding function
static INDArray	Transforms.round(INDArray ndArray, boolean dup) Rounding function
static INDArray	Transforms.sigmoid(INDArray ndArray) Sigmoid function
static INDArray	Transforms.sigmoid(INDArray ndArray, boolean dup) Sigmoid function
static INDArray	Transforms.sign(INDArray toSign) Signum function of this ndarray
static INDArray	Transforms.sign(INDArray toSign, boolean dup) Signum function of this ndarray
static INDArray	Transforms.sqrt(INDArray ndArray) Sqrt function
static INDArray	Transforms.sqrt(INDArray ndArray, boolean dup) Sqrt function
static INDArray	Transforms.stabilize(INDArray ndArray, double k)
static INDArray	Transforms.stabilize(INDArray ndArray, double k, boolean dup) Stabilize to be within a range of k
static INDArray	Transforms.sumPooling(INDArray toPool, int[] stride) Pooled expectations(sum)
static INDArray	Transforms.tanh(INDArray ndArray) Tanh function
static INDArray	Transforms.tanh(INDArray ndArray, boolean dup) Tanh function
static INDArray	Transforms.unitVec(INDArray toScale) Scale by 1 / norm2 of the matrix
static INDArray	Transforms.upSample(INDArray d, INDArray scale) Upsampling a signal (specifically the first 2 dimensions)

Uses of INDArray in org.nd4j.linalg.util

Methods in org.nd4j.linalg.util that return INDArray

Modifier and Type	Method and Description
static INDArray	NDArrayUtil.center(INDArray arr, int[] shape) Center an array
static INDArray	NDArrayUtil.exp(INDArray toExp)
static INDArray	NDArrayUtil.expi(INDArray toExp) Returns an exponential version of this ndarray
static INDArray	NDArrayUtil.padWithZeros(INDArray nd, int[] targetShape) Pads an INDArray with zeros
static INDArray	ArrayUtil.toNDArray(int[] nums)
static INDArray	ArrayUtil.toNDArray(int[][] nums)
static INDArray	FeatureUtil.toOutcomeMatrix(int[] index, int numOutcomes) Creates an out come vector from the specified inputs
static INDArray	FeatureUtil.toOutcomeVector(int index, int numOutcomes) Creates an out come vector from the specified inputs
static INDArray	NDArrayUtil.truncate(INDArray nd, int n, int dimension) Truncates an INDArray to the specified shape.

Methods in org.nd4j.linalg.util with parameters of type INDArray

Modifier and Type	Method and Description
static void	LinAlgExceptions.assertColumns(INDArray n, INDArray n2)
static void	LinAlgExceptions.assertMultiplies(INDArray nd1, INDArray nd2) Asserts matrix multiply rules (columns of left == rows of right)
static void	LinAlgExceptions.assertRows(INDArray n, INDArray n2)
static void	LinAlgExceptions.assertSameShape(INDArray n, INDArray n2)
static void	LinAlgExceptions.assertValidNum(INDArray n)
static INDArray	NDArrayUtil.center(INDArray arr, int[] shape) Center an array
static INDArray	NDArrayUtil.exp(INDArray toExp)
static INDArray	NDArrayUtil.expi(INDArray toExp) Returns an exponential version of this ndarray
static int	LinearUtil.linearStride(INDArray arr) When needing to look at an array that's a matrix or some other tensor we typically need to map those arrays element wise (take axpy or uploading data as a linear buffer for example) This handles finding the proper offset for the situations where a >= 2d array needs to be interpreted in a linear form that may not be used outside of those contexts.
static void	FeatureUtil.normalizeMatrix(INDArray toNormalize)
static INDArray	NDArrayUtil.padWithZeros(INDArray nd, int[] targetShape) Pads an INDArray with zeros
static void	FeatureUtil.scaleByMax(INDArray toScale) Divides each row by its max
static void	FeatureUtil.scaleMinMax(double min, double max, INDArray toScale) Scales the ndarray columns to the given min/max values
static int[]	ArrayUtil.toInts(INDArray n)
static INDArray	NDArrayUtil.truncate(INDArray nd, int n, int dimension) Truncates an INDArray to the specified shape.