Nd4j (nd4j-api 0.4-rc3.6 API)

java.lang.Object
- org.nd4j.linalg.factory.Nd4j

```
public class Nd4j
extends Object
```
Creation of ndarrays via classpath discovery.

Author:

Adam Gibson

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Nd4j.PadMode

Nested Classes
Modifier and Type	Class and Description
`static class`	`Nd4j.PadMode`

Field Summary

Fields
Modifier and Type	Field and Description
`static DataBuffer.AllocationMode`	`alloc`
`static String`	`ALLOC`
`static String`	`BLAS_OPS`
`protected static BlasWrapper`	`BLAS_WRAPPER_INSTANCE`
`protected static Class<? extends BlasWrapper>`	`blasWrapperClazz`
`protected static ReferenceQueue<DataBuffer>`	`bufferQueue`
`protected static ConvolutionInstance`	`CONVOLUTION_INSTANCE`
`static String`	`CONVOLUTION_OPS`
`protected static Class<? extends ConvolutionInstance>`	`convolutionInstanceClazz`
`static String`	`COPY_OPS`
`static boolean`	`copyOnOps`
`protected static DataBufferFactory`	`DATA_BUFFER_FACTORY_INSTANCE`
`static String`	`DATA_BUFFER_OPS`
`protected static Class<? extends DataBufferFactory>`	`dataBufferFactoryClazz`
`static String`	`DISTRIBUTION`
`protected static DistributionFactory`	`DISTRIBUTION_FACTORY`
`protected static Class<? extends DistributionFactory>`	`distributionFactoryClazz`
`static DataBuffer.Type`	`dtype`
`static String`	`DTYPE`
`static boolean`	`ENFORCE_NUMERICAL_STABILITY`
`static double`	`EPS_THRESHOLD`
`static String`	`EXECUTION_MODE`
`static OpExecutioner.ExecutionMode`	`executionMode`
`protected static FFTInstance`	`FFT_INSTANCE`
`static String`	`FFT_OPS`
`protected static Class<? extends FFTInstance>`	`fftInstanceClazz`
`protected static NDArrayFactory`	`INSTANCE`
`protected static Instrumentation`	`instrumentation`
`static String`	`INSTRUMENTATION`
`protected static Class<? extends Instrumentation>`	`instrumentationClazz`
`static int`	`MAX_ELEMENTS_PER_SLICE`
`static int`	`MAX_SLICES_TO_PRINT`
`static String`	`NDARRAY_FACTORY_CLASS`
`protected static Class<? extends NDArrayFactory>`	`ndArrayFactoryClazz`
`static IComplexNumber`	`NEG_UNIT`
`static String`	`NUMERICAL_STABILITY`
`static String`	`OP_EXECUTIONER`
`protected static OpExecutioner`	`OP_EXECUTIONER_INSTANCE`
`static String`	`OP_FACTORY`
`protected static OpFactory`	`OP_FACTORY_INSTANCE`
`protected static Class<? extends OpExecutioner>`	`opExecutionerClazz`
`protected static Class<? extends OpFactory>`	`opFactoryClazz`
`static char`	`ORDER`
`static String`	`ORDER_KEY`
`protected static Properties`	`props`
`protected static Random`	`random`
`static String`	`RANDOM`
`protected static Class<? extends Random>`	`randomClazz`
`protected static ReferenceQueue<INDArray>`	`referenceQueue`
`static String`	`RESOURCE_MANAGER`
`static String`	`RESOURCE_MANGER_ON`
`static boolean`	`resourceManagerOn`
`static boolean`	`shouldInstrument`
`static String`	`TASK_FACTORY`
`protected static TaskFactory`	`TASK_FACTORY_INSTANCE`
`protected static Class<? extends TaskFactory>`	`taskFactoryClazz`
`static IComplexNumber`	`UNIT`
`static IComplexNumber`	`ZERO`

Constructor Summary

Constructors
Constructor and Description

Nd4j()

Constructors
Constructor and Description
`Nd4j()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static INDArray`	`append(INDArray arr, int padAmount, double val, int axis)` Append the given array with the specified value size along a particular axis
`static INDArray`	`appendBias(INDArray... vectors)`
`static INDArray`	`arange(double end)` Array of evenly spaced values.
`static INDArray`	`arange(double begin, double end)` Array of evenly spaced values.
`static INDArray`	`argMax(INDArray arr, int... dimension)`
`static INDArray`	`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 ReferenceQueue<DataBuffer>`	`bufferRefQueue()` The reference queue used for cleaning up databuffers
`static void`	`clearNans(INDArray arr)` Clear nans from an ndarray
`static IComplexNDArray`	`complexFlatten(IComplexNDArray... flatten)` Create a long row vector of all of the given ndarrays
`static IComplexNDArray`	`complexFlatten(List<IComplexNDArray> flatten)` Create a long row vector of all of the given ndarrays
`static IComplexNDArray`	`complexLinSpace(int i, int i1, int i2)` Linspace with complex numbers
`static IComplexNDArray`	`complexOnes(int... shape)` Create an ndarray of ones
`static IComplexNDArray`	`complexOnes(int columns)` Creates an ndarray
`static IComplexNDArray`	`complexOnes(int rows, int columns)` Creates an ndarray
`static IComplexNDArray`	`complexRand(int... shape)` Create a random ndarray with the given shape using the current time as the seed
`static IComplexNDArray`	`complexScalar(Number value)` Create a scalar ndarray with the specified offset
`static IComplexNDArray`	`complexScalar(Number value, int offset)` Create a scalar ndarray with the specified offset
`static IComplexNDArray`	`complexValueOf(int[] shape, double value)`
`static IComplexNDArray`	`complexValueOf(int[] shape, IComplexNumber value)`
`static IComplexNDArray`	`complexValueOf(int num, double value)`
`static IComplexNDArray`	`complexValueOf(int num, IComplexNumber value)`
`static IComplexNDArray`	`complexZeros(int... shape)` Create an ndarray of ones
`static IComplexNDArray`	`complexZeros(int columns)` Creates an ndarray
`static INDArray`	`complexZeros(int rows, int columns)` Creates a matrix of zeros
`static IComplexNDArray`	`concat(int dimension, IComplexNDArray... toConcat)` Concatneate ndarrays along a dimension
`static INDArray`	`concat(int dimension, INDArray... toConcat)` Concatneate ndarrays along a dimension
`static void`	`copy(INDArray a, INDArray b)` Copy a to b
`static INDArray`	`create(DataBuffer buffer)`
`static INDArray`	`create(DataBuffer data, int[] shape)`
`static INDArray`	`create(DataBuffer data, int[] shape, int offset)`
`static INDArray`	`create(DataBuffer data, int[] shape, int[] strides, int offset)`
`static INDArray`	`create(DataBuffer data, int[] newShape, int[] newStride, int offset, char ordering)`
`static INDArray`	`create(double[] data)` Creates a row vector with the data
`static INDArray`	`create(double[][] data)` Create an ndarray based on the given data layout
`static INDArray`	`create(double[][] data, char ordering)`
`static INDArray`	`create(double[] data, char order)` Creates a row vector with the data
`static INDArray`	`create(double[] data, int[] shape)` Create an ndrray with the specified shape
`static INDArray`	`create(double[] data, int[] shape, char ordering)` Create an ndrray with the specified shape
`static INDArray`	`create(double[] data, int[] shape, int offset)`
`static INDArray`	`create(double[] data, int[] shape, int[] stride, int offset)` Creates an ndarray with the specified shape
`static INDArray`	`create(double[] data, int[] shape, int[] stride, int offset, char ordering)` Creates an ndarray with the specified shape
`static INDArray`	`create(double[] data, int[] shape, int offset, char ordering)` Creates an ndarray with the specified shape
`static INDArray`	`create(double[] data, int rows, int columns, int[] stride, int offset)` Creates an ndarray with the specified shape
`static INDArray`	`create(double[] data, int rows, int columns, int[] stride, int offset, char ordering)` Creates an ndarray with the specified shape
`static INDArray`	`create(float[] data)` Creates a row vector with the data
`static INDArray`	`create(float[][] data)`
`static INDArray`	`create(float[][] data, char ordering)`
`static INDArray`	`create(float[] data, char order)` Creates a row vector with the data
`static INDArray`	`create(float[] data, int[] shape)` Create an ndrray with the specified shape
`static INDArray`	`create(float[] data, int[] shape, char ordering)` Create an ndrray with the specified shape
`static INDArray`	`create(float[] data, int[] shape, char ordering, int offset)`
`static INDArray`	`create(float[] data, int[] shape, int offset)` Creates an ndarray with the specified shape
`static INDArray`	`create(float[] data, int[] shape, int[] stride, char ordering, int offset)`
`static INDArray`	`create(float[] data, int[] shape, int[] stride, int offset)` Creates an ndarray with the specified shape
`static INDArray`	`create(float[] data, int[] shape, int[] stride, int offset, char ordering)` Creates an ndarray with the specified shape
`static INDArray`	`create(float[] data, int rows, int columns, int[] stride, int offset)` Creates an ndarray with the specified shape
`static INDArray`	`create(float[] data, int rows, int columns, int[] stride, int offset, char ordering)` Creates an ndarray with the specified shape
`static INDArray`	`create(int... shape)` Creates an ndarray with the specified shape
`static INDArray`	`create(int columns)` Creates a row vector with the specified number of columns
`static INDArray`	`create(int[] shape, char ordering)` Creates an ndarray with the specified shape
`static INDArray`	`create(int[] shape, DataBuffer.Type dataType)`
`static INDArray`	`create(int[] sliceShape, double[]... arrays)` Create an ndarray based on the given data
`static INDArray`	`create(int[] sliceShape, float[]... arrays)` Create an ndarray based on the given data
`static INDArray`	`create(int[] shape, int[] stride)` Creates an ndarray with the specified shape
`static INDArray`	`create(int[] shape, int[] stride, char ordering)` Creates an ndarray with the specified shape
`static INDArray`	`create(int[] shape, int[] stride, int offset)` Creates an ndarray with the specified shape
`static INDArray`	`create(int[] shape, int[] stride, int offset, char ordering)` Creates an ndarray with the specified shape
`static INDArray`	`create(int columns, char order)` Creates a row vector with the specified number of columns
`static INDArray`	`create(int rows, int columns)` Creates an ndarray with the specified shape
`static INDArray`	`create(int rows, int columns, char ordering)` Creates an ndarray with the specified shape
`static INDArray`	`create(int rows, int columns, int[] stride)` Creates an ndarray with the specified shape
`static INDArray`	`create(int rows, int columns, int[] stride, char ordering)` Creates an ndarray with the specified shape
`static INDArray`	`create(int rows, int columns, int[] stride, int offset)` Creates an ndarray with the specified shape
`static INDArray`	`create(int rows, int columns, int[] stride, int offset, char ordering)` Creates an ndarray with the specified shape
`static INDArray`	`create(List<INDArray> list, int[] shape)` Creates an ndarray with the specified shape
`static INDArray`	`create(List<INDArray> list, int[] shape, char ordering)` Creates an ndarray with the specified shape
`static DataBuffer`	`createBuffer(byte[] data, int length)` Create a buffer based on the data type
`static DataBuffer`	`createBuffer(double[] data)` Create a buffer based on the data type
`static DataBuffer`	`createBuffer(float[] data)` Create a buffer based on the data type
`static DataBuffer`	`createBuffer(int length)` Creates a buffer of the specified length based on the data type
`static DataBuffer`	`createBuffer(int[] shape)` Create a buffer equal of length prod(shape)
`static DataBuffer`	`createBuffer(int[] shape, DataBuffer.Type type)` Create a buffer equal of length prod(shape)
`static IComplexNDArray`	`createComplex(DataBuffer data, int[] shape)`
`static IComplexNDArray`	`createComplex(DataBuffer data, int[] shape, int offset)`
`static IComplexNDArray`	`createComplex(DataBuffer data, int[] shape, int[] newStrides, int offset)`
`static IComplexNDArray`	`createComplex(DataBuffer data, int[] shape, int[] newStrides, int offset, char ordering)`
`static IComplexNDArray`	`createComplex(DataBuffer data, int[] shape, int offset, char ordering)`
`static IComplexNDArray`	`createComplex(double[] dim)`
`static IComplexNDArray`	`createComplex(double[] data, char order)` Creates an ndarray with the specified data
`static IComplexNDArray`	`createComplex(double[] data, int[] shape)` Create an ndrray with the specified shape
`static IComplexNDArray`	`createComplex(double[] data, int[] shape, char ordering)` Create an ndrray with the specified shape
`static IComplexNDArray`	`createComplex(double[] data, int[] shape, int offset)`
`static IComplexNDArray`	`createComplex(double[] data, int[] shape, int[] stride)` Create an ndrray with the specified shape
`static IComplexNDArray`	`createComplex(double[] data, int[] shape, int[] stride, char ordering)` Create an ndrray with the specified shape
`static IComplexNDArray`	`createComplex(double[] data, int[] shape, int[] stride, int offset)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(double[] data, int[] shape, int[] stride, int offset, char ordering)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(double[] data, int[] shape, int offset, char ordering)`
`static IComplexNDArray`	`createComplex(double[] data, int rows, int columns, int[] stride, int offset)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(double[] data, int rows, int columns, int[] stride, int offset, char ordering)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(float[] data)` Creates an ndarray with the specified data
`static IComplexNDArray`	`createComplex(float[] data, int[] shape)` Create an ndrray with the specified shape
`static IComplexNDArray`	`createComplex(float[] data, int[] shape, char ordering)` Create an ndrray with the specified shape
`static IComplexNDArray`	`createComplex(float[] data, int[] shape, int offset)`
`static IComplexNDArray`	`createComplex(float[] data, int[] shape, int[] stride)` Create an ndrray with the specified shape
`static IComplexNDArray`	`createComplex(float[] data, int[] shape, int[] stride, char ordering)` Create an ndrray with the specified shape
`static IComplexNDArray`	`createComplex(float[] data, int[] shape, int[] stride, int offset)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(float[] data, int[] shape, int[] stride, int offset, char ordering)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(float[] data, int[] shape, int offset, char ordering)` Create complex ndarray
`static IComplexNDArray`	`createComplex(float[] data, int rows, int columns, int[] stride, int offset)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(float[] data, int rows, int columns, int[] stride, int offset, char ordering)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(IComplexNumber[] iComplexNumbers)` Create a complex array from the given numbers
`static IComplexNDArray`	`createComplex(IComplexNumber[][] iComplexNumbers)` Create a complex ndarray based on the specified matrices
`static IComplexNDArray`	`createComplex(IComplexNumber[] data, int[] shape)` Create a complex ndarray from the passed in indarray
`static IComplexNDArray`	`createComplex(IComplexNumber[] data, int[] shape, int offset, char order)` Create a complex ndarray from the passed in indarray
`static IComplexNDArray`	`createComplex(INDArray arr)` Create a complex ndarray from the passed in indarray
`static IComplexNDArray`	`createComplex(INDArray real, INDArray imag)` Create a complex ndarray based on the real and imaginary
`static IComplexNDArray`	`createComplex(int... shape)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(int columns)` Creates an ndarray
`static IComplexNDArray`	`createComplex(int[] shape, char ordering)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(int[] shape, int[] stride)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(int[] shape, int[] stride, char ordering)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(int[] shape, int[] stride, int offset)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(int[] shape, int[] stride, int offset, char ordering)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(int columns, char order)` Creates an ndarray
`static IComplexNDArray`	`createComplex(int rows, int columns)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(int rows, int columns, char ordering)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(int rows, int columns, int[] stride)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(int rows, int columns, int[] stride, char ordering)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(int rows, int columns, int[] stride, int offset)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(int rows, int columns, int[] stride, int offset, char ordering)` Creates a complex ndarray with the specified shape
`static IComplexNDArray`	`createComplex(List<IComplexNDArray> arrs, int[] shape)` Create a complex ndarray from the passed in indarray
`static IComplexNumber`	`createComplexNumber(Number real, Number imag)` Create double based on real and imaginary
`static IComplexDouble`	`createDouble(double real, double imag)` Create an instance of a complex double
`static IComplexFloat`	`createFloat(float real, float imag)` Create double
`static IComplexNDArray`	`cumsum(IComplexNDArray compute)`
`static IComplexNDArray`	`cumsum(IComplexNDArray compute, int dimension)`
`static INDArray`	`cumsum(INDArray compute)`
`static INDArray`	`cumsum(INDArray compute, int dimension)`
`static DataBuffer.Type`	`dataType()` Returns the data type used for the runtime
`static IComplexNDArray`	`diag(IComplexNDArray 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 IComplexNDArray`	`diag(IComplexNDArray 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`	`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`	`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`	`doAlongDiagonal(IComplexNDArray x, com.google.common.base.Function<IComplexNumber,IComplexNumber> func)` Perform an operation along a diagonal
`static void`	`doAlongDiagonal(INDArray x, com.google.common.base.Function<Number,Number> func)` Perform an operation along a diagonal
`static INDArray`	`emptyLike(INDArray arr)` Empty like
`static INDArray`	`eye(int n)` Create the identity ndarray
`static NDArrayFactory`	`factory()` The factory used for creating ndarrays
`static INDArray`	`fromByteArray(byte[] arr)` Read an ndarray from a byte array
`static INDArray`	`gemm(INDArray a, INDArray b, boolean transposeA, boolean transposeB)` Matrix multiply: Implements op(a)*op(b) where op(X) means transpose X (or not) depending on setting of arguments transposeA and transposeB. So gemm(a,b,false,false) == a.mmul(b), gemm(a,b,true,false) == a.transpose().mmul(b) etc.
`static INDArray`	`gemm(INDArray a, INDArray b, INDArray c, boolean transposeA, boolean transposeB, double alpha, double beta)` Matrix multiply: Implements c = alphaop(a)op(b) + beta*c where op(X) means transpose X (or not) depending on setting of arguments transposeA and transposeB. Note that matrix c MUST be fortran order, have zero offset and have c.data().length == c.length().
`static BlasWrapper`	`getBlasWrapper()`
`static int[]`	`getComplexStrides(int[] shape)` Get the strides based on the shape and NDArrays.order()
`static int[]`	`getComplexStrides(int[] shape, char order)` Get the strides for the given order and shape
`static ConvolutionInstance`	`getConvolution()` Get the convolution singleton
`static DistributionFactory`	`getDistributions()` Get the primary distributions factory
`static OpExecutioner`	`getExecutioner()` Get the operation executioner instance
`static FFTInstance`	`getFFt()` Returns the fft instance
`static Instrumentation`	`getInstrumentation()` Gets the instrumentation instance
`static OpFactory`	`getOpFactory()` Get the operation factory
`static Random`	`getRandom()` Get the current random generator
`static int[]`	`getStrides(int[] shape)` Get the strides based on the shape and NDArrays.order()
`static int[]`	`getStrides(int[] shape, char order)` Get the strides for the given order and shape
`static TaskFactory`	`getTaskFactory()` Get the task factory
`static boolean`	`hasInvalidNumber(INDArray num)` Returns true if the given ndarray has either an infinite or nan
`static INDArray`	`hstack(INDArray... arrs)` Concatenates two matrices horizontally.
`void`	`initContext()` Initializes nd4j
`void`	`initWithBackend(Nd4jBackend backend)` Initialize with the specific backend
`static INDArray`	`linspace(int lower, int upper, int num)` Generate a linearly spaced vector
`static IComplexNDArray`	`max(IComplexNDArray compute)`
`static IComplexNDArray`	`max(IComplexNDArray compute, int dimension)`
`static INDArray`	`max(INDArray compute)`
`static INDArray`	`max(INDArray compute, int dimension)`
`static IComplexNDArray`	`mean(IComplexNDArray compute)`
`static IComplexNDArray`	`mean(IComplexNDArray compute, int dimension)`
`static INDArray`	`mean(INDArray compute)`
`static INDArray`	`mean(INDArray compute, int dimension)`
`static IComplexNDArray`	`min(IComplexNDArray compute)`
`static IComplexNDArray`	`min(IComplexNDArray compute, int dimension)`
`static INDArray`	`min(INDArray compute)`
`static INDArray`	`min(INDArray compute, int dimension)`
`static IComplexNDArray`	`norm1(IComplexNDArray compute)`
`static IComplexNDArray`	`norm1(IComplexNDArray compute, int dimension)`
`static INDArray`	`norm1(INDArray compute)`
`static INDArray`	`norm1(INDArray compute, int dimension)`
`static IComplexNDArray`	`norm2(IComplexNDArray compute)`
`static IComplexNDArray`	`norm2(IComplexNDArray compute, int dimension)`
`static INDArray`	`norm2(INDArray compute)`
`static INDArray`	`norm2(INDArray compute, int dimension)`
`static IComplexNDArray`	`normmax(IComplexNDArray compute)`
`static IComplexNDArray`	`normmax(IComplexNDArray compute, int dimension)`
`static INDArray`	`normmax(INDArray compute)`
`static INDArray`	`normmax(INDArray compute, int dimension)`
`static INDArray`	`ones(int... shape)` Create an ndarray of ones
`static INDArray`	`ones(int columns)` Creates a row vector with the specified number of columns
`static INDArray`	`ones(int rows, int columns)` Creates a row vector with the specified number of columns
`static INDArray`	`onesLike(INDArray arr)` Ones like
`static Character`	`order()` Returns the ordering of the ndarrays
`static INDArray`	`pad(INDArray toPad, int[][] padWidth, List<double[]> constantValues, Nd4j.PadMode padMode)` Pad the given ndarray to the size along each dimension
`static INDArray`	`pad(INDArray toPad, int[][] padWidth, Nd4j.PadMode padMode)` Pad the given ndarray to the size along each dimension
`static INDArray`	`pad(INDArray toPad, int[] padWidth, List<double[]> constantValues, Nd4j.PadMode padMode)` Pad the given ndarray to the size along each dimension
`static INDArray`	`pad(INDArray toPad, int[] padWidth, Nd4j.PadMode padMode)` Pad the given ndarray to the size along each dimension
`static IComplexNumber`	`parseComplexNumber(String val)` Parse a complex number
`static INDArray`	`prepend(INDArray arr, int padAmount, double val, int axis)` Append the given array with the specified value size along a particular axis
`static IComplexNDArray`	`prod(IComplexNDArray compute)`
`static IComplexNDArray`	`prod(IComplexNDArray compute, int dimension)`
`static INDArray`	`prod(INDArray compute)`
`static INDArray`	`prod(INDArray compute, int dimension)`
`static INDArray`	`rand(int[] shape)` Create a random ndarray with the given shape using the current time as the seed
`static INDArray`	`rand(int[] shape, Distribution dist)` Create a random ndarray with the given shape using the given rng
`static INDArray`	`rand(int[] shape, double min, double max, Random rng)` Generates a random matrix between min and max
`static INDArray`	`rand(int[] shape, long seed)` Create a random ndarray with the given shape using given seed
`static INDArray`	`rand(int[] shape, Random rng)` Create a random ndarray with the given shape using the given RandomGenerator
`static INDArray`	`rand(int rows, int columns)` Create a random ndarray with the given shape using the current time as the seed
`static INDArray`	`rand(int rows, int columns, double min, double max, Random rng)` Generates a random matrix between min and max
`static INDArray`	`rand(int rows, int columns, long seed)` Create a random ndarray with the given shape using the given seed
`static INDArray`	`rand(int rows, int columns, Random rng)` Deprecated.
`static INDArray`	`rand(long seed, int... shape)` Create a random ndarray with the given shape using the given seed
`static INDArray`	`randn(int[] shape)` Random normal using the current time stamp as the seed
`static INDArray`	`randn(int[] shape, long seed)` Random normal using the specified seed
`static INDArray`	`randn(int[] shape, Random r)` Random normal using the given rng
`static INDArray`	`randn(int rows, int columns)` Random normal using the current time stamp as the seed
`static INDArray`	`randn(int rows, int columns, long seed)` Random normal using the specified seed
`static INDArray`	`randn(int rows, int columns, Random r)` Random normal using the given rng
`static INDArray`	`read(DataInputStream dis)` Read in an ndarray from a data input stream
`static INDArray`	`read(InputStream reader)` Raad an ndarray from an input stream
`static INDArray`	`readBinary(File read)` Read a binary ndarray from the given file
`static IComplexNDArray`	`readComplex(DataInputStream dis)` Read in an ndarray from a data input stream
`static INDArray`	`readNumpy(InputStream filePath, String split)` Read line via input streams
`static INDArray`	`readNumpy(String filePath)` Read line via input streams
`static INDArray`	`readNumpy(String filePath, String split)` Read line via input streams
`static INDArray`	`readTxt(String filePath)` Read line via input streams
`static ReferenceQueue<INDArray>`	`refQueue()` The reference queue used for cleaning up ndarrays
`static IComplexNDArray`	`repeat(IComplexNDArray n, int num)` Create an n x (shape) ndarray where the ndarray is repeated num times
`static INDArray`	`repeat(INDArray n, int num)` Create an n x (shape) ndarray where the ndarray is repeated num times
`static INDArray`	`reverse(INDArray reverse)` Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
`static INDArray`	`rollAxis(INDArray a, int axis)` Roll the specified axis backwards, until it lies in a given position.
`static INDArray`	`rollAxis(INDArray a, int axis, int start)` Roll the specified axis backwards, until it lies in a given position.
`static INDArray`	`rot(INDArray reverse)` Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
`static void`	`rot90(INDArray toRotate)` Rotate a matrix 90 degrees
`static void`	`saveBinary(INDArray arr, File saveTo)` Save an ndarray to the given file
`static INDArray`	`scalar(double value)` Create a scalar nd array with the specified value and offset
`static INDArray`	`scalar(double value, int offset)` Create a scalar nd array with the specified value and offset
`static INDArray`	`scalar(float value)` Create a scalar nd array with the specified value and offset
`static INDArray`	`scalar(float value, int offset)` Create a scalar nd array with the specified value and offset
`static IComplexNDArray`	`scalar(IComplexDouble value)` Create a scalar nd array with the specified value and offset
`static IComplexNDArray`	`scalar(IComplexDouble value, int offset)` Create a scalar nd array with the specified value and offset
`static IComplexNDArray`	`scalar(IComplexFloat value)` Create a scalar nd array with the specified value and offset
`static IComplexNDArray`	`scalar(IComplexFloat value, int offset)` Create a scalar nd array with the specified value and offset
`static IComplexNDArray`	`scalar(IComplexNumber value)` Create a scalar ndarray with the specified offset
`static IComplexNDArray`	`scalar(IComplexNumber value, int offset)` Create a scalar ndarray with the specified offset
`static INDArray`	`scalar(Number value)` Create a scalar ndarray with the specified offset
`static INDArray`	`scalar(Number value, int offset)` Create a scalar ndarray with the specified offset
`static void`	`setBlasWrapper(BlasWrapper factory)` Sets the global blas wrapper
`static void`	`setConvolution(ConvolutionInstance convolutionInstance)` Set a convolution instance
`static void`	`setFactory(NDArrayFactory factory)`
`static void`	`setFft(FFTInstance fftInstance)`
`static void`	`setNdArrayFactoryClazz(Class<? extends NDArrayFactory> clazz)`
`static void`	`setParams(INDArray theta, Collection<INDArray>... matrices)` Given a sequence of Iterators over a transform of matrices, fill in all of the matrices with the entries in the theta vector.
`static void`	`setParams(INDArray theta, Iterator<? extends INDArray>... matrices)` Given a sequence of Iterators over a transform of matrices, fill in all of the matrices with the entries in the theta vector.
`static int[]`	`shape(INDArray arr)` Returns the shape of the ndarray
`static void`	`shuffle(INDArray toShuffle, int... dimension)` In place shuffle of an ndarray along a specified set of dimensions
`static void`	`shuffle(INDArray toShuffle, Random random, int... dimension)` In place shuffle of an ndarray along a specified set of dimensions
`static IComplexNDArray`	`sort(IComplexNDArray ndarray, int dimension, boolean ascending)` Sort an ndarray along a particular dimension
`static INDArray`	`sort(INDArray ndarray, int dimension, boolean ascending)` Sort an ndarray along a particular dimension
`static INDArray`	`sortColumns(INDArray in, int rowIdx, boolean ascending)` Sort (shuffle) the columns of a 2d array according to the value at a specified row.
`static INDArray`	`sortRows(INDArray in, int colIdx, boolean ascending)` Sort (shuffle) the rows of a 2d array according to the value at a specified column.
`static INDArray[]`	`sortWithIndices(IComplexNDArray ndarray, int dimension, boolean ascending)` Sort an ndarray along a particular dimension
`static INDArray[]`	`sortWithIndices(INDArray ndarray, int dimension, boolean ascending)` Sort an ndarray along a particular dimension
`static IComplexNDArray`	`std(IComplexNDArray compute)`
`static IComplexNDArray`	`std(IComplexNDArray compute, int dimension)`
`static INDArray`	`std(INDArray compute)`
`static INDArray`	`std(INDArray compute, int dimension)`
`static INDArray`	`stripOnes(INDArray toStrip)` Reshapes an ndarray to remove leading 1s
`static IComplexNDArray`	`sum(IComplexNDArray compute)`
`static IComplexNDArray`	`sum(IComplexNDArray compute, int dimension)`
`static INDArray`	`sum(INDArray compute)`
`static INDArray`	`sum(INDArray compute, int dimension)`
`static INDArray`	`tensorMmul(INDArray a, INDArray b, int[][] axes)` Tensor matrix multiplication.
`static INDArray`	`tile(INDArray tile, int... repeat)` An alias for repmat
`static byte[]`	`toByteArray(INDArray arr)` Convert an ndarray to a byte array
`static INDArray`	`toFlattened(char order, Collection<INDArray> matrices)` Create a long row vector of all of the given ndarrays
`static INDArray`	`toFlattened(char order, INDArray... matrices)` Create a long row vector of all of the given ndarrays
`static INDArray`	`toFlattened(Collection<INDArray> matrices)` Create a long row vector of all of the given ndarrays
`static INDArray`	`toFlattened(INDArray... matrices)` Create a long row vector of all of the given ndarrays
`static INDArray`	`toFlattened(int length, Iterator<? extends INDArray>... matrices)` Create a long row vector of all of the given ndarrays
`static INDArray`	`valueArrayOf(int[] shape, double value)` Creates an ndarray with the specified value as the only value in the ndarray
`static INDArray`	`valueArrayOf(int num, double value)` Creates an ndarray with the specified value as the only value in the ndarray
`static INDArray`	`valueArrayOf(int rows, int columns, double value)` Creates a row vector with the specified number of columns
`static IComplexNDArray`	`var(IComplexNDArray compute)`
`static IComplexNDArray`	`var(IComplexNDArray compute, int dimension)`
`static INDArray`	`var(INDArray compute)`
`static INDArray`	`var(INDArray compute, int dimension)`
`static INDArray`	`vstack(INDArray... arrs)` Concatenates two matrices vertically.
`static void`	`write(INDArray arr, DataOutputStream dataOutputStream)` Write an ndarray to the specified outputstream
`static void`	`write(OutputStream writer, INDArray write)` Write an ndarray to a writer
`static void`	`writeComplex(IComplexNDArray arr, DataOutputStream dataOutputStream)` Write an ndarray to the specified outputs tream
`static void`	`writeNumpy(INDArray write, String filePath, String split)` Read line via input streams
`static void`	`writeTxt(INDArray write, String filePath, String split)` Read line via input streams
`static INDArray`	`zeros(int... shape)` Create an ndarray of zeros
`static INDArray`	`zeros(int columns)` Creates a row vector with the specified number of columns
`static INDArray`	`zeros(int rows, int columns)` Creates a row vector with the specified number of columns
`static INDArray`	`zerosLike(INDArray arr)` Empty like

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - NUMERICAL_STABILITY
```
public static final String NUMERICAL_STABILITY
```
    See Also:
    
    Constant Field Values
  - FFT_OPS
```
public static final String FFT_OPS
```
    See Also:
    
    Constant Field Values
  - DATA_BUFFER_OPS
```
public static final String DATA_BUFFER_OPS
```
    See Also:
    
    Constant Field Values
  - CONVOLUTION_OPS
```
public static final String CONVOLUTION_OPS
```
    See Also:
    
    Constant Field Values
  - DTYPE
```
public static final String DTYPE
```
    See Also:
    
    Constant Field Values
  - BLAS_OPS
```
public static final String BLAS_OPS
```
    See Also:
    
    Constant Field Values
  - ORDER_KEY
```
public static final String ORDER_KEY
```
    See Also:
    
    Constant Field Values
  - NDARRAY_FACTORY_CLASS
```
public static final String NDARRAY_FACTORY_CLASS
```
    See Also:
    
    Constant Field Values
  - COPY_OPS
```
public static final String COPY_OPS
```
    See Also:
    
    Constant Field Values
  - OP_EXECUTIONER
```
public static final String OP_EXECUTIONER
```
    See Also:
    
    Constant Field Values
  - OP_FACTORY
```
public static final String OP_FACTORY
```
    See Also:
    
    Constant Field Values
  - TASK_FACTORY
```
public static final String TASK_FACTORY
```
    See Also:
    
    Constant Field Values
  - RANDOM
```
public static final String RANDOM
```
    See Also:
    
    Constant Field Values
  - DISTRIBUTION
```
public static final String DISTRIBUTION
```
    See Also:
    
    Constant Field Values
  - INSTRUMENTATION
```
public static final String INSTRUMENTATION
```
    See Also:
    
    Constant Field Values
  - RESOURCE_MANAGER
```
public static final String RESOURCE_MANAGER
```
    See Also:
    
    Constant Field Values
  - RESOURCE_MANGER_ON
```
public static final String RESOURCE_MANGER_ON
```
    See Also:
    
    Constant Field Values
  - ALLOC
```
public static final String ALLOC
```
    See Also:
    
    Constant Field Values
  - EXECUTION_MODE
```
public static final String EXECUTION_MODE
```
    See Also:
    
    Constant Field Values
  - executionMode
```
public static OpExecutioner.ExecutionMode executionMode
```
  - dtype
```
public static DataBuffer.Type dtype
```
  - alloc
```
public static DataBuffer.AllocationMode alloc
```
  - ORDER
```
public static char ORDER
```
  - UNIT
```
public static IComplexNumber UNIT
```
  - ZERO
```
public static IComplexNumber ZERO
```
  - NEG_UNIT
```
public static IComplexNumber NEG_UNIT
```
  - EPS_THRESHOLD
```
public static double EPS_THRESHOLD
```
  - MAX_ELEMENTS_PER_SLICE
```
public static int MAX_ELEMENTS_PER_SLICE
```
  - MAX_SLICES_TO_PRINT
```
public static int MAX_SLICES_TO_PRINT
```
  - ENFORCE_NUMERICAL_STABILITY
```
public static boolean ENFORCE_NUMERICAL_STABILITY
```
  - copyOnOps
```
public static boolean copyOnOps
```
  - shouldInstrument
```
public static boolean shouldInstrument
```
  - resourceManagerOn
```
public static boolean resourceManagerOn
```
  - blasWrapperClazz
```
protected static Class<? extends BlasWrapper> blasWrapperClazz
```
  - ndArrayFactoryClazz
```
protected static Class<? extends NDArrayFactory> ndArrayFactoryClazz
```
  - fftInstanceClazz
```
protected static Class<? extends FFTInstance> fftInstanceClazz
```
  - convolutionInstanceClazz
```
protected static Class<? extends ConvolutionInstance> convolutionInstanceClazz
```
  - dataBufferFactoryClazz
```
protected static Class<? extends DataBufferFactory> dataBufferFactoryClazz
```
  - opExecutionerClazz
```
protected static Class<? extends OpExecutioner> opExecutionerClazz
```
  - opFactoryClazz
```
protected static Class<? extends OpFactory> opFactoryClazz
```
  - taskFactoryClazz
```
protected static Class<? extends TaskFactory> taskFactoryClazz
```
  - randomClazz
```
protected static Class<? extends Random> randomClazz
```
  - distributionFactoryClazz
```
protected static Class<? extends DistributionFactory> distributionFactoryClazz
```
  - instrumentationClazz
```
protected static Class<? extends Instrumentation> instrumentationClazz
```
  - DATA_BUFFER_FACTORY_INSTANCE
```
protected static DataBufferFactory DATA_BUFFER_FACTORY_INSTANCE
```
  - BLAS_WRAPPER_INSTANCE
```
protected static BlasWrapper BLAS_WRAPPER_INSTANCE
```
  - INSTANCE
```
protected static NDArrayFactory INSTANCE
```
  - FFT_INSTANCE
```
protected static FFTInstance FFT_INSTANCE
```
  - CONVOLUTION_INSTANCE
```
protected static ConvolutionInstance CONVOLUTION_INSTANCE
```
  - OP_EXECUTIONER_INSTANCE
```
protected static OpExecutioner OP_EXECUTIONER_INSTANCE
```
  - DISTRIBUTION_FACTORY
```
protected static DistributionFactory DISTRIBUTION_FACTORY
```
  - OP_FACTORY_INSTANCE
```
protected static OpFactory OP_FACTORY_INSTANCE
```
  - TASK_FACTORY_INSTANCE
```
protected static TaskFactory TASK_FACTORY_INSTANCE
```
  - random
```
protected static Random random
```
  - instrumentation
```
protected static Instrumentation instrumentation
```
  - props
```
protected static Properties props
```
  - referenceQueue
```
protected static ReferenceQueue<INDArray> referenceQueue
```
  - bufferQueue
```
protected static ReferenceQueue<DataBuffer> bufferQueue
```
- Constructor Detail
  - Nd4j
```
public Nd4j()
```
- Method Detail
  - pad
```
public static INDArray pad(INDArray toPad,
                           int[][] padWidth,
                           Nd4j.PadMode padMode)
```
    Pad the given ndarray to the size along each dimension
    
    Parameters:
    
    toPad - the ndarray to pad
    
    padWidth - the width to pad along each dimension
    
    padMode - the mode to pad in
    
    Returns:
    
    the padded ndarray based on the specified mode
  - pad
```
public static INDArray pad(INDArray toPad,
                           int[][] padWidth,
                           List<double[]> constantValues,
                           Nd4j.PadMode padMode)
```
    Pad the given ndarray to the size along each dimension
    
    Parameters:
    
    toPad - the ndarray to pad
    
    padWidth - the width to pad along each dimension
    
    constantValues - the values to append for each dimension
    
    padMode - the mode to pad in
    
    Returns:
    
    the padded ndarray based on the specified mode
  - pad
```
public static INDArray pad(INDArray toPad,
                           int[] padWidth,
                           List<double[]> constantValues,
                           Nd4j.PadMode padMode)
```
    Pad the given ndarray to the size along each dimension
    
    Parameters:
    
    toPad - the ndarray to pad
    
    padWidth - the width to pad along each dimension
    
    constantValues - the values to append for each dimension
    
    padMode - the mode to pad in
    
    Returns:
    
    the padded ndarray based on the specified mode
  - pad
```
public static INDArray pad(INDArray toPad,
                           int[] padWidth,
                           Nd4j.PadMode padMode)
```
    Pad the given ndarray to the size along each dimension
    
    Parameters:
    
    toPad - the ndarray to pad
    
    padWidth - the width to pad along each dimension
    
    padMode - the mode to pad in
    
    Returns:
    
    the padded ndarray based on the specified mode
  - append
```
public static INDArray append(INDArray arr,
                              int padAmount,
                              double val,
                              int axis)
```
    Append the given array with the specified value size along a particular axis
    
    Parameters:
    
    arr - the array to append to
    
    padAmount - the pad amount of the array to be returned
    
    val - the value to append
    
    axis - the axis to append to
    
    Returns:
    
    the newly created array
  - prepend
```
public static INDArray prepend(INDArray arr,
                               int padAmount,
                               double val,
                               int axis)
```
    Append the given array with the specified value size along a particular axis
    
    Parameters:
    
    arr - the array to append to
    
    padAmount - the pad amount of the array to be returned
    
    val - the value to append
    
    axis - the axis to append to
    
    Returns:
    
    the newly created array
  - shuffle
```
public static void shuffle(INDArray toShuffle,
                           Random random,
                           int... dimension)
```
    In place shuffle of an ndarray along a specified set of dimensions
    
    Parameters:
    
    toShuffle - the ndarray to shuffle
    
    random - the random to use
    
    dimension - the dimension to do the shuffle
  - shuffle
```
public static void shuffle(INDArray toShuffle,
                           int... dimension)
```
    In place shuffle of an ndarray along a specified set of dimensions
    
    Parameters:
    
    toShuffle - the ndarray to shuffle
    
    dimension - the dimension to do the shuffle
  - refQueue
```
public static ReferenceQueue<INDArray> refQueue()
```
    The reference queue used for cleaning up ndarrays
    
    Returns:
    
    the reference queue for cleaning up ndarrays
  - bufferRefQueue
```
public static ReferenceQueue<DataBuffer> bufferRefQueue()
```
    The reference queue used for cleaning up databuffers
    
    Returns:
    
    the reference queue for cleaning up databuffers
  - getInstrumentation
```
public static Instrumentation getInstrumentation()
```
    Gets the instrumentation instance
    
    Returns:
    
    the instrumentation instance
  - getDistributions
```
public static DistributionFactory getDistributions()
```
    Get the primary distributions factory
    
    Returns:
    
    the primary distributions
  - setNdArrayFactoryClazz
```
public static void setNdArrayFactoryClazz(Class<? extends NDArrayFactory> clazz)
```
  - getRandom
```
public static Random getRandom()
```
    Get the current random generator
    
    Returns:
    
    the current random generator
  - getConvolution
```
public static ConvolutionInstance getConvolution()
```
    Get the convolution singleton
    
    Returns:
    
    the convolution singleton
  - setConvolution
```
public static void setConvolution(ConvolutionInstance convolutionInstance)
```
    Set a convolution instance
    
    Parameters:
    
    convolutionInstance -
  - shape
```
public static int[] shape(INDArray arr)
```
    Returns the shape of the ndarray
    
    Parameters:
    
    arr - the array to get the shape of
    
    Returns:
    
    the shape of tihs ndarray
  - create
```
public static INDArray create(int[] sliceShape,
                              float[]... arrays)
```
    Create an ndarray based on the given data
    
    Parameters:
    
    sliceShape - the shape of each slice
    
    arrays - the arrays of data to create
    
    Returns:
    
    the ndarray of the specified shape where number of slices is equal to array length and each slice is the specified shape
  - create
```
public static INDArray create(int[] sliceShape,
                              double[]... arrays)
```
    Create an ndarray based on the given data
    
    Parameters:
    
    sliceShape - the shape of each slice
    
    arrays - the arrays of data to create
    
    Returns:
    
    the ndarray of the specified shape where number of slices is equal to array length and each slice is the specified shape
  - getExecutioner
```
public static OpExecutioner getExecutioner()
```
    Get the operation executioner instance
    
    Returns:
    
    the operation executioner instance
  - getOpFactory
```
public static OpFactory getOpFactory()
```
    Get the operation factory
    
    Returns:
    
    the operation factory
  - getTaskFactory
```
public static TaskFactory getTaskFactory()
```
    Get the task factory
  - getFFt
```
public static FFTInstance getFFt()
```
    Returns the fft instance
    
    Returns:
    
    the fft instance
  - setFft
```
public static void setFft(FFTInstance fftInstance)
```
    Parameters:
    
    fftInstance -
  - setParams
```
public static void setParams(INDArray theta,
                             Collection<INDArray>... matrices)
```
    Given a sequence of Iterators over a transform of matrices, fill in all of the matrices with the entries in the theta vector. Errors are thrown if the theta vector does not exactly fill the matrices.
  - rollAxis
```
public static INDArray rollAxis(INDArray a,
                                int axis)
```
    Roll the specified axis backwards, until it lies in a given position. Starting ends up being zero. See numpy's rollaxis
    
    Parameters:
    
    a - the array to roll
    
    axis - the axis to roll backwards
    
    Returns:
    
    the rolled ndarray
  - argMax
```
public static INDArray argMax(INDArray arr,
                              int... dimension)
```
    Parameters:
    
    arr -
    
    dimension -
    
    Returns:
  - rollAxis
```
public static INDArray rollAxis(INDArray a,
                                int axis,
                                int start)
```
    Roll the specified axis backwards, until it lies in a given position. See numpy's rollaxis
    
    Parameters:
    
    a - the array to roll
    
    axis - the axis to roll backwards
    
    start - the starting point
    
    Returns:
    
    the rolled ndarray
  - tensorMmul
```
public static INDArray tensorMmul(INDArray a,
                                  INDArray b,
                                  int[][] axes)
```
    Tensor matrix multiplication. Both tensors must be the same rank
    
    Parameters:
    
    a - the left tensor
    
    b - the right tensor
    
    axes - the axes for each array to do matrix multiply along
    
    Returns:
  - gemm
```
public static INDArray gemm(INDArray a,
                            INDArray b,
                            boolean transposeA,
                            boolean transposeB)
```
    Matrix multiply: Implements op(a)*op(b) where op(X) means transpose X (or not) depending on setting of arguments transposeA and transposeB.
    So gemm(a,b,false,false) == a.mmul(b), gemm(a,b,true,false) == a.transpose().mmul(b) etc.
    
    Parameters:
    
    a - First matrix
    
    b - Second matrix
    
    transposeA - if true: transpose matrix a before mmul
    
    transposeB - if true: transpose matrix b before mmul
    
    Returns:
    
    result
  - gemm
```
public static INDArray gemm(INDArray a,
                            INDArray b,
                            INDArray c,
                            boolean transposeA,
                            boolean transposeB,
                            double alpha,
                            double beta)
```
    Matrix multiply: Implements c = alpha*op(a)*op(b) + beta*c where op(X) means transpose X (or not) depending on setting of arguments transposeA and transposeB.
    Note that matrix c MUST be fortran order, have zero offset and have c.data().length == c.length(). An exception will be thrown otherwise.
    Don't use this unless you know about level 3 blas and NDArray storage orders.
    
    Parameters:
    
    a - First matrix
    
    b - Second matrix
    
    c - result matrix. Used in calculation (assuming beta != 0) and result is stored in this. f order, zero offset and length == data.length only
    
    transposeA - if true: transpose matrix a before mmul
    
    transposeB - if true: transpose matrix b before mmul
    
    Returns:
    
    result, i.e., matrix c is returned for convenience
  - setParams
```
public static void setParams(INDArray theta,
                             Iterator<? extends INDArray>... matrices)
```
    Given a sequence of Iterators over a transform of matrices, fill in all of the matrices with the entries in the theta vector. Errors are thrown if the theta vector does not exactly fill the matrices.
  - factory
```
public static NDArrayFactory factory()
```
    The factory used for creating ndarrays
    
    Returns:
    
    the factory instance used for creating ndarrays
  - cumsum
```
public static INDArray cumsum(INDArray compute)
```
  - max
```
public static INDArray max(INDArray compute)
```
  - min
```
public static INDArray min(INDArray compute)
```
  - prod
```
public static INDArray prod(INDArray compute)
```
  - normmax
```
public static INDArray normmax(INDArray compute)
```
  - norm2
```
public static INDArray norm2(INDArray compute)
```
  - norm1
```
public static INDArray norm1(INDArray compute)
```
  - std
```
public static INDArray std(INDArray compute)
```
  - var
```
public static INDArray var(INDArray compute)
```
  - sum
```
public static INDArray sum(INDArray compute)
```
  - mean
```
public static INDArray mean(INDArray compute)
```
  - cumsum
```
public static IComplexNDArray cumsum(IComplexNDArray compute)
```
  - max
```
public static IComplexNDArray max(IComplexNDArray compute)
```
  - min
```
public static IComplexNDArray min(IComplexNDArray compute)
```
  - prod
```
public static IComplexNDArray prod(IComplexNDArray compute)
```
  - normmax
```
public static IComplexNDArray normmax(IComplexNDArray compute)
```
  - norm2
```
public static IComplexNDArray norm2(IComplexNDArray compute)
```
  - norm1
```
public static IComplexNDArray norm1(IComplexNDArray compute)
```
  - std
```
public static IComplexNDArray std(IComplexNDArray compute)
```
  - var
```
public static IComplexNDArray var(IComplexNDArray compute)
```
  - sum
```
public static IComplexNDArray sum(IComplexNDArray compute)
```
  - mean
```
public static IComplexNDArray mean(IComplexNDArray compute)
```
  - cumsum
```
public static INDArray cumsum(INDArray compute,
                              int dimension)
```
  - max
```
public static INDArray max(INDArray compute,
                           int dimension)
```
  - min
```
public static INDArray min(INDArray compute,
                           int dimension)
```
  - prod
```
public static INDArray prod(INDArray compute,
                            int dimension)
```
  - normmax
```
public static INDArray normmax(INDArray compute,
                               int dimension)
```
  - norm2
```
public static INDArray norm2(INDArray compute,
                             int dimension)
```
  - norm1
```
public static INDArray norm1(INDArray compute,
                             int dimension)
```
  - std
```
public static INDArray std(INDArray compute,
                           int dimension)
```
  - var
```
public static INDArray var(INDArray compute,
                           int dimension)
```
  - sum
```
public static INDArray sum(INDArray compute,
                           int dimension)
```
  - mean
```
public static INDArray mean(INDArray compute,
                            int dimension)
```
  - cumsum
```
public static IComplexNDArray cumsum(IComplexNDArray compute,
                                     int dimension)
```
  - max
```
public static IComplexNDArray max(IComplexNDArray compute,
                                  int dimension)
```
  - min
```
public static IComplexNDArray min(IComplexNDArray compute,
                                  int dimension)
```
  - prod
```
public static IComplexNDArray prod(IComplexNDArray compute,
                                   int dimension)
```
  - normmax
```
public static IComplexNDArray normmax(IComplexNDArray compute,
                                      int dimension)
```
  - norm2
```
public static IComplexNDArray norm2(IComplexNDArray compute,
                                    int dimension)
```
  - norm1
```
public static IComplexNDArray norm1(IComplexNDArray compute,
                                    int dimension)
```
  - std
```
public static IComplexNDArray std(IComplexNDArray compute,
                                  int dimension)
```
  - var
```
public static IComplexNDArray var(IComplexNDArray compute,
                                  int dimension)
```
  - sum
```
public static IComplexNDArray sum(IComplexNDArray compute,
                                  int dimension)
```
  - mean
```
public static IComplexNDArray mean(IComplexNDArray compute,
                                   int dimension)
```
  - createBuffer
```
public static DataBuffer createBuffer(int[] shape,
                                      DataBuffer.Type type)
```
    Create a buffer equal of length prod(shape)
    
    Parameters:
    
    shape - the shape of the buffer to create
    
    type - the type to create
    
    Returns:
    
    the created buffer
  - createBuffer
```
public static DataBuffer createBuffer(byte[] data,
                                      int length)
```
    Create a buffer based on the data type
    
    Parameters:
    
    data - the data to create the buffer with
    
    Returns:
    
    the created buffer
  - createBuffer
```
public static DataBuffer createBuffer(int[] shape)
```
    Create a buffer equal of length prod(shape)
    
    Parameters:
    
    shape - the shape of the buffer to create
    
    Returns:
    
    the created buffer
  - createBuffer
```
public static DataBuffer createBuffer(int length)
```
    Creates a buffer of the specified length based on the data type
    
    Parameters:
    
    length - the length of te buffer
    
    Returns:
    
    the buffer to create
  - createBuffer
```
public static DataBuffer createBuffer(float[] data)
```
    Create a buffer based on the data type
    
    Parameters:
    
    data - the data to create the buffer with
    
    Returns:
    
    the created buffer
  - createBuffer
```
public static DataBuffer createBuffer(double[] data)
```
    Create a buffer based on the data type
    
    Parameters:
    
    data - the data to create the buffer with
    
    Returns:
    
    the created buffer
  - setFactory
```
public static void setFactory(NDArrayFactory factory)
```
  - order
```
public static Character order()
```
    Returns the ordering of the ndarrays
    
    Returns:
    
    the ordering of the ndarrays
  - dataType
```
public static DataBuffer.Type dataType()
```
    Returns the data type used for the runtime
    
    Returns:
    
    the datatype used for the runtime
  - getBlasWrapper
```
public static BlasWrapper getBlasWrapper()
```
  - setBlasWrapper
```
public static void setBlasWrapper(BlasWrapper factory)
```
    Sets the global blas wrapper
    
    Parameters:
    
    factory -
  - repeat
```
public static IComplexNDArray repeat(IComplexNDArray n,
                                     int num)
```
    Create an n x (shape) ndarray where the ndarray is repeated num times
    
    Parameters:
    
    n - the ndarray to replicate
    
    num - the number of copies to repeat
    
    Returns:
    
    the repeated ndarray
  - sortWithIndices
```
public static INDArray[] sortWithIndices(IComplexNDArray ndarray,
                                         int dimension,
                                         boolean ascending)
```
    Sort an ndarray along a particular dimension
    
    Parameters:
    
    ndarray - the ndarray to sort
    
    dimension - the dimension to sort
    
    Returns:
    
    an array with indices and the sorted ndarray
  - sortWithIndices
```
public static INDArray[] sortWithIndices(INDArray ndarray,
                                         int dimension,
                                         boolean ascending)
```
    Sort an ndarray along a particular dimension
    
    Parameters:
    
    ndarray - the ndarray to sort
    
    dimension - the dimension to sort
    
    Returns:
    
    the indices and the sorted ndarray
  - sort
```
public static IComplexNDArray sort(IComplexNDArray ndarray,
                                   int dimension,
                                   boolean ascending)
```
    Sort an ndarray along a particular dimension
    
    Parameters:
    
    ndarray - the ndarray to sort
    
    dimension - the dimension to sort
    
    Returns:
    
    the sorted ndarray
  - sort
```
public static INDArray sort(INDArray ndarray,
                            int dimension,
                            boolean ascending)
```
    Sort an ndarray along a particular dimension
    
    Parameters:
    
    ndarray - the ndarray to sort
    
    dimension - the dimension to sort
    
    Returns:
    
    the sorted ndarray
  - sortRows
```
public static INDArray sortRows(INDArray in,
                                int colIdx,
                                boolean ascending)
```
    Sort (shuffle) the rows of a 2d array according to the value at a specified column. Other than the order of the rows, each row is unmodified. Copy operation: original INDArray is unmodified
    So if sorting the following on values of column 2 (ascending):
    [a b 2]
    [c d 0]
    [e f -3]
    Then output is
    [e f -3]
    [c d 0]
    [a b 2]
    
    Parameters:
    
    in - 2d array to sort
    
    colIdx - The column to sort on
    
    ascending - true if smallest-to-largest; false if largest-to-smallest
    
    Returns:
  - sortColumns
```
public static INDArray sortColumns(INDArray in,
                                   int rowIdx,
                                   boolean ascending)
```
    Sort (shuffle) the columns of a 2d array according to the value at a specified row. Other than the order of the columns, each column is unmodified. Copy operation: original INDArray is unmodified
    So if sorting the following on values of row 1 (ascending):
    [a b c]
    [1 -1 0]
    [d e f]
    Then output is
    [b c a]
    [-1 0 1]
    [e f d]
    
    Parameters:
    
    in - 2d array to sort
    
    rowIdx - The row to sort on
    
    ascending - true if smallest-to-largest; false if largest-to-smallest
    
    Returns:
  - repeat
```
public static INDArray repeat(INDArray n,
                              int num)
```
    Create an n x (shape) ndarray where the ndarray is repeated num times
    
    Parameters:
    
    n - the ndarray to replicate
    
    num - the number of copies to repeat
    
    Returns:
    
    the repeated ndarray
  - linspace
```
public static INDArray linspace(int lower,
                                int upper,
                                int num)
```
    Generate a linearly spaced vector
    
    Parameters:
    
    lower - upper bound
    
    upper - lower bound
    
    num - the step size
    
    Returns:
    
    the linearly spaced vector
  - toFlattened
```
public static INDArray toFlattened(Collection<INDArray> matrices)
```
    Create a long row vector of all of the given ndarrays
    
    Parameters:
    
    matrices - the matrices to create the flattened ndarray for
    
    Returns:
    
    the flattened representation of these ndarrays
  - toFlattened
```
public static INDArray toFlattened(char order,
                                   Collection<INDArray> matrices)
```
    Create a long row vector of all of the given ndarrays
    
    Parameters:
    
    order - the order in which to flatten the matrices
    
    matrices - the matrices to create the flattened ndarray for
    
    Returns:
    
    the flattened representation of these ndarrays
  - complexFlatten
```
public static IComplexNDArray complexFlatten(List<IComplexNDArray> flatten)
```
    Create a long row vector of all of the given ndarrays
    
    Parameters:
    
    flatten - the matrices to create the flattened ndarray for
    
    Returns:
    
    the flattened representation of these ndarrays
  - complexFlatten
```
public static IComplexNDArray complexFlatten(IComplexNDArray... flatten)
```
    Create a long row vector of all of the given ndarrays
    
    Parameters:
    
    flatten - the matrices to create the flattened ndarray for
    
    Returns:
    
    the flattened representation of these ndarrays
  - toFlattened
```
public static INDArray toFlattened(int length,
                                   Iterator<? extends INDArray>... matrices)
```
    Create a long row vector of all of the given ndarrays
    
    Parameters:
    
    matrices - the matrices to create the flattened ndarray for
    
    Returns:
    
    the flattened representation of these ndarrays
  - bilinearProducts
```
public static INDArray 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.
  - toFlattened
```
public static INDArray toFlattened(INDArray... matrices)
```
    Create a long row vector of all of the given ndarrays
    
    Parameters:
    
    matrices - the matrices to create the flattened ndarray for
    
    Returns:
    
    the flattened representation of these ndarrays
  - toFlattened
```
public static INDArray toFlattened(char order,
                                   INDArray... matrices)
```
    Create a long row vector of all of the given ndarrays
    
    Parameters:
    
    order - order in which to flatten ndarrays
    
    matrices - the matrices to create the flattened ndarray for
    
    Returns:
    
    the flattened representation of these ndarrays
  - eye
```
public static INDArray eye(int n)
```
    Create the identity ndarray
    
    Parameters:
    
    n - the number for the identity
    
    Returns:
  - rot90
```
public static void rot90(INDArray toRotate)
```
    Rotate a matrix 90 degrees
    
    Parameters:
    
    toRotate - the matrix to rotate
  - writeTxt
```
public static void writeTxt(INDArray write,
                            String filePath,
                            String split)
                     throws IOException
```
    Read line via input streams
    
    Parameters:
    
    filePath - the input stream ndarray
    
    split - the split separator
    
    Throws:
    
    IOException
  - write
```
public static void write(OutputStream writer,
                         INDArray write)
                  throws IOException
```
    Write an ndarray to a writer
    
    Parameters:
    
    writer - the writer to write to
    
    write - the ndarray to write
    
    Throws:
    
    IOException
  - toByteArray
```
public static byte[] toByteArray(INDArray arr)
                          throws IOException
```
    Convert an ndarray to a byte array
    
    Parameters:
    
    arr - the array to convert
    
    Returns:
    
    the converted byte array
    
    Throws:
    
    IOException
  - fromByteArray
```
public static INDArray fromByteArray(byte[] arr)
                              throws IOException
```
    Read an ndarray from a byte array
    
    Parameters:
    
    arr - the array to read from
    
    Returns:
    
    the deserialized ndarray
    
    Throws:
    
    IOException
  - readNumpy
```
public static INDArray readNumpy(InputStream filePath,
                                 String split)
                          throws IOException
```
    Read line via input streams
    
    Parameters:
    
    filePath - the input stream ndarray
    
    split - the split separator
    
    Returns:
    
    the read txt method
    
    Throws:
    
    IOException
  - writeNumpy
```
public static void writeNumpy(INDArray write,
                              String filePath,
                              String split)
                       throws IOException
```
    Read line via input streams
    
    Parameters:
    
    filePath - the input stream ndarray
    
    split - the split separator
    
    Throws:
    
    IOException
  - readNumpy
```
public static INDArray readNumpy(String filePath,
                                 String split)
                          throws IOException
```
    Read line via input streams
    
    Parameters:
    
    filePath - the input stream ndarray
    
    split - the split separator
    
    Returns:
    
    the read txt method
    
    Throws:
    
    IOException
  - readNumpy
```
public static INDArray readNumpy(String filePath)
                          throws IOException
```
    Read line via input streams
    
    Parameters:
    
    filePath - the input stream ndarray
    
    Returns:
    
    the read txt method
    
    Throws:
    
    IOException
  - read
```
public static INDArray read(InputStream reader)
                     throws IOException
```
    Raad an ndarray from an input stream
    
    Parameters:
    
    reader - the input stream to use
    
    Returns:
    
    the given ndarray
    
    Throws:
    
    IOException
  - parseComplexNumber
```
public static IComplexNumber parseComplexNumber(String val)
```
    Parse a complex number
    
    Parameters:
    
    val - the string to parse
    
    Returns:
    
    the parsed complex number
  - readTxt
```
public static INDArray readTxt(String filePath)
                        throws IOException
```
    Read line via input streams
    
    Parameters:
    
    filePath - the input stream ndarray
    
    Returns:
    
    the read txt method
    
    Throws:
    
    IOException
  - read
```
public static INDArray read(DataInputStream dis)
                     throws IOException
```
    Read in an ndarray from a data input stream
    
    Parameters:
    
    dis - the data input stream to read from
    
    Returns:
    
    the ndarray
    
    Throws:
    
    IOException
  - write
```
public static void write(INDArray arr,
                         DataOutputStream dataOutputStream)
                  throws IOException
```
    Write an ndarray to the specified outputstream
    
    Parameters:
    
    arr - the array to write
    
    dataOutputStream - the data output stream to write to
    
    Throws:
    
    IOException
  - saveBinary
```
public static void saveBinary(INDArray arr,
                              File saveTo)
                       throws IOException
```
    Save an ndarray to the given file
    
    Parameters:
    
    arr - the array to save
    
    saveTo - the file to save to
    
    Throws:
    
    IOException
  - readBinary
```
public static INDArray readBinary(File read)
                           throws IOException
```
    Read a binary ndarray from the given file
    
    Parameters:
    
    read - the nd array to read
    
    Returns:
    
    the loaded ndarray
    
    Throws:
    
    IOException
  - clearNans
```
public static void clearNans(INDArray arr)
```
    Clear nans from an ndarray
    
    Parameters:
    
    arr - the array to clear
  - readComplex
```
public static IComplexNDArray readComplex(DataInputStream dis)
                                   throws IOException
```
    Read in an ndarray from a data input stream
    
    Parameters:
    
    dis - the data input stream to read from
    
    Returns:
    
    the ndarray
    
    Throws:
    
    IOException
  - writeComplex
```
public static void writeComplex(IComplexNDArray arr,
                                DataOutputStream dataOutputStream)
                         throws IOException
```
    Write an ndarray to the specified outputs tream
    
    Parameters:
    
    arr - the array to write
    
    dataOutputStream - the data output stream to write to
    
    Throws:
    
    IOException
  - rot
```
public static INDArray rot(INDArray reverse)
```
    Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
    
    Parameters:
    
    reverse - the matrix to reverse
    
    Returns:
    
    the reversed matrix
  - reverse
```
public static INDArray reverse(INDArray reverse)
```
    Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
    
    Parameters:
    
    reverse - the matrix to reverse
    
    Returns:
    
    the reversed matrix
  - arange
```
public static INDArray arange(double begin,
                              double end)
```
    Array of evenly spaced values.
    
    Parameters:
    
    begin - the begin of the range
    
    end - the end of the range
    
    Returns:
    
    the range vector
  - arange
```
public static INDArray arange(double end)
```
    Array of evenly spaced values.
    
    Parameters:
    
    end - the end of the range
    
    Returns:
    
    the range vector
  - createFloat
```
public static IComplexFloat createFloat(float real,
                                        float imag)
```
    Create double
    
    Parameters:
    
    real - real component
    
    imag - imag component
    
    Returns:
  - createDouble
```
public static IComplexDouble createDouble(double real,
                                          double imag)
```
    Create an instance of a complex double
    
    Parameters:
    
    real - the real component
    
    imag - the imaginary component
    
    Returns:
    
    a new imaginary double with the specified real and imaginary components
  - copy
```
public static void copy(INDArray a,
                        INDArray b)
```
    Copy a to b
    
    Parameters:
    
    a - the origin matrix
    
    b - the destination matrix
  - diag
```
public static IComplexNDArray diag(IComplexNDArray 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
    
    Parameters:
    
    x - the diagonal values
    
    k - the kth diagonal to getDouble
    
    Returns:
    
    new matrix
  - diag
```
public static INDArray 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
    
    Parameters:
    
    x - the diagonal values
    
    k - the kth diagonal to getDouble
    
    Returns:
    
    new matrix
  - diag
```
public static IComplexNDArray diag(IComplexNDArray 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
    
    Parameters:
    
    x - the diagonal values
    
    Returns:
    
    new matrix
  - diag
```
public static INDArray 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
    
    Parameters:
    
    x - the diagonal values
    
    Returns:
    
    new matrix
  - appendBias
```
public static INDArray appendBias(INDArray... vectors)
```
  - doAlongDiagonal
```
public static void doAlongDiagonal(INDArray x,
                                   com.google.common.base.Function<Number,Number> func)
```
    Perform an operation along a diagonal
    
    Parameters:
    
    x - the ndarray to perform the operation on
    
    func - the operation to perform
  - doAlongDiagonal
```
public static void doAlongDiagonal(IComplexNDArray x,
                                   com.google.common.base.Function<IComplexNumber,IComplexNumber> func)
```
    Perform an operation along a diagonal
    
    Parameters:
    
    x - the ndarray to perform the operation on
    
    func - the operation to perform
  - rand
```
public static INDArray rand(int[] shape)
```
    Create a random ndarray with the given shape using the current time as the seed
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
    
    the random ndarray with the specified shape
  - complexRand
```
public static IComplexNDArray complexRand(int... shape)
```
    Create a random ndarray with the given shape using the current time as the seed
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
    
    the random ndarray with the specified shape
  - rand
```
public static INDArray rand(int rows,
                            int columns)
```
    Create a random ndarray with the given shape using the current time as the seed
    
    Parameters:
    
    rows - the number of rows in the matrix
    
    columns - the number of columns in the matrix
    
    Returns:
    
    the random ndarray with the specified shape
  - rand
```
public static INDArray rand(int[] shape,
                            long seed)
```
    Create a random ndarray with the given shape using given seed
    
    Parameters:
    
    shape - the shape of the ndarray
    
    seed - the seed to use
    
    Returns:
    
    the random ndarray with the specified shape
  - rand
```
public static INDArray rand(long seed,
                            int... shape)
```
    Create a random ndarray with the given shape using the given seed
    
    Parameters:
    
    seed - the seed
    
    shape - the shape
    
    Returns:
    
    the random ndarray with the specified shape
  - rand
```
public static INDArray rand(int rows,
                            int columns,
                            long seed)
```
    Create a random ndarray with the given shape using the given seed
    
    Parameters:
    
    rows - the number of rows in the matrix
    
    columns - the columns of the ndarray
    
    seed - the seed to use
    
    Returns:
    
    the random ndarray with the specified shape
  - rand
```
public static INDArray rand(int[] shape,
                            Random rng)
```
    Create a random ndarray with the given shape using the given RandomGenerator
    
    Parameters:
    
    shape - the shape of the ndarray
    
    rng - the random generator to use
    
    Returns:
    
    the random ndarray with the specified shape
  - rand
```
public static INDArray rand(int[] shape,
                            Distribution dist)
```
    Create a random ndarray with the given shape using the given rng
    
    Parameters:
    
    shape - the shape of the ndarray
    
    dist - distribution to use
    
    Returns:
    
    the random ndarray with the specified shape
  - rand
```
@Deprecated
public static INDArray rand(int rows,
                                        int columns,
                                        Random rng)
```
    Deprecated.
    
    Create a random ndarray with the given shape using the given rng
    
    Parameters:
    
    rows - the number of rows in the matrix
    
    columns - the number of columns in the matrix
    
    rng - the random generator to use
    
    Returns:
    
    the random ndarray with the specified shape
  - rand
```
public static INDArray rand(int[] shape,
                            double min,
                            double max,
                            Random rng)
```
    Generates a random matrix between min and max
    
    Parameters:
    
    shape - the number of rows of the matrix
    
    min - the minimum number
    
    max - the maximum number
    
    rng - the rng to use
    
    Returns:
    
    a random matrix of the specified shape and range
  - rand
```
public static INDArray rand(int rows,
                            int columns,
                            double min,
                            double max,
                            Random rng)
```
    Generates a random matrix between min and max
    
    Parameters:
    
    rows - the number of rows of the matrix
    
    columns - the number of columns in the matrix
    
    min - the minimum number
    
    max - the maximum number
    
    rng - the rng to use
    
    Returns:
    
    a drandom matrix of the specified shape and range
  - randn
```
public static INDArray randn(int[] shape)
```
    Random normal using the current time stamp as the seed
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
  - randn
```
public static INDArray randn(int[] shape,
                             long seed)
```
    Random normal using the specified seed
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
  - randn
```
public static INDArray randn(int rows,
                             int columns)
```
    Random normal using the current time stamp as the seed
    
    Parameters:
    
    rows - the number of rows in the matrix
    
    columns - the number of columns in the matrix
    
    Returns:
  - randn
```
public static INDArray randn(int rows,
                             int columns,
                             long seed)
```
    Random normal using the specified seed
    
    Parameters:
    
    rows - the number of rows in the matrix
    
    columns - the number of columns in the matrix
    
    Returns:
  - randn
```
public static INDArray randn(int rows,
                             int columns,
                             Random r)
```
    Random normal using the given rng
    
    Parameters:
    
    rows - the number of rows in the matrix
    
    columns - the number of columns in the matrix
    
    r - the random generator to use
    
    Returns:
  - randn
```
public static INDArray randn(int[] shape,
                             Random r)
```
    Random normal using the given rng
    
    Parameters:
    
    shape - the shape of the ndarray
    
    r - the random generator to use
    
    Returns:
  - create
```
public static INDArray create(float[] data)
```
    Creates a row vector with the data
    
    Parameters:
    
    data - the columns of the ndarray
    
    Returns:
    
    the created ndarray
  - createComplex
```
public static IComplexNDArray createComplex(float[] data)
```
    Creates an ndarray with the specified data
    
    Parameters:
    
    data - the number of columns in the row vector
    
    Returns:
    
    ndarray
  - create
```
public static INDArray create(double[] data)
```
    Creates a row vector with the data
    
    Parameters:
    
    data - the columns of the ndarray
    
    Returns:
    
    the created ndarray
  - create
```
public static INDArray create(float[][] data)
```
    Parameters:
    
    data -
    
    Returns:
  - create
```
public static INDArray create(float[][] data,
                              char ordering)
```
    Parameters:
    
    data -
    
    ordering -
    
    Returns:
  - create
```
public static INDArray create(double[][] data)
```
    Create an ndarray based on the given data layout
    
    Parameters:
    
    data - the data to use
    
    Returns:
    
    an ndarray with the given data layout
  - create
```
public static INDArray create(double[][] data,
                              char ordering)
```
    Parameters:
    
    data -
    
    ordering -
    
    Returns:
  - createComplex
```
public static IComplexNDArray createComplex(INDArray arr)
```
    Create a complex ndarray from the passed in indarray
    
    Parameters:
    
    arr - the arr to wrap
    
    Returns:
    
    the complex ndarray with the specified ndarray as the real components
  - create
```
public static INDArray create(int columns)
```
    Creates a row vector with the specified number of columns
    
    Parameters:
    
    columns - the columns of the ndarray
    
    Returns:
    
    the created ndarray
  - createComplex
```
public static IComplexNDArray createComplex(int columns)
```
    Creates an ndarray
    
    Parameters:
    
    columns - the number of columns in the row vector
    
    Returns:
    
    ndarray
  - createComplexNumber
```
public static IComplexNumber createComplexNumber(Number real,
                                                 Number imag)
```
    Create double based on real and imaginary
    
    Parameters:
    
    real - real component
    
    imag - imag component
    
    Returns:
  - createComplex
```
public static IComplexNDArray createComplex(INDArray real,
                                            INDArray imag)
```
    Create a complex ndarray based on the real and imaginary
    
    Parameters:
    
    real - the real numbers
    
    imag - the imaginary components
    
    Returns:
    
    the complex
  - createComplex
```
public static IComplexNDArray createComplex(IComplexNumber[] data,
                                            int[] shape)
```
    Create a complex ndarray from the passed in indarray
    
    Parameters:
    
    data - the data to wrap
    
    Returns:
    
    the complex ndarray with the specified ndarray as the real components
  - createComplex
```
public static IComplexNDArray createComplex(List<IComplexNDArray> arrs,
                                            int[] shape)
```
    Create a complex ndarray from the passed in indarray
    
    Parameters:
    
    arrs - the arr to wrap
    
    Returns:
    
    the complex ndarray with the specified ndarray as the real components
  - create
```
public static INDArray create(float[] data,
                              char order)
```
    Creates a row vector with the data
    
    Parameters:
    
    data - the columns of the ndarray
    
    Returns:
    
    the created ndarray
  - create
```
public static INDArray create(double[] data,
                              char order)
```
    Creates a row vector with the data
    
    Parameters:
    
    data - the columns of the ndarray
    
    Returns:
    
    the created ndarray
  - createComplex
```
public static IComplexNDArray createComplex(double[] data,
                                            char order)
```
    Creates an ndarray with the specified data
    
    Parameters:
    
    data - the number of columns in the row vector
    
    Returns:
    
    ndarray
  - create
```
public static INDArray create(int columns,
                              char order)
```
    Creates a row vector with the specified number of columns
    
    Parameters:
    
    columns - the columns of the ndarray
    
    Returns:
    
    the created ndarray
  - createComplex
```
public static IComplexNDArray createComplex(int columns,
                                            char order)
```
    Creates an ndarray
    
    Parameters:
    
    columns - the number of columns in the row vector
    
    Returns:
    
    ndarray
  - createComplex
```
public static IComplexNDArray createComplex(IComplexNumber[] data,
                                            int[] shape,
                                            int offset,
                                            char order)
```
    Create a complex ndarray from the passed in indarray
    
    Parameters:
    
    data - the data to wrap
    
    Returns:
    
    the complex ndarray with the specified ndarray as the real components
  - create
```
public static INDArray create(float[] data,
                              int[] shape)
```
    Create an ndrray with the specified shape
    
    Parameters:
    
    data - the data to use with tne ndarray
    
    shape - the shape of the ndarray
    
    Returns:
    
    the created ndarray
  - createComplex
```
public static IComplexNDArray createComplex(float[] data,
                                            int[] shape)
```
    Create an ndrray with the specified shape
    
    Parameters:
    
    data - the data to use with tne ndarray
    
    shape - the shape of the ndarray
    
    Returns:
    
    the created ndarray
  - create
```
public static INDArray create(double[] data,
                              int[] shape)
```
    Create an ndrray with the specified shape
    
    Parameters:
    
    data - the data to use with tne ndarray
    
    shape - the shape of the ndarray
    
    Returns:
    
    the created ndarray
  - createComplex
```
public static IComplexNDArray createComplex(double[] data,
                                            int[] shape)
```
    Create an ndrray with the specified shape
    
    Parameters:
    
    data - the data to use with tne ndarray
    
    shape - the shape of the ndarray
    
    Returns:
    
    the created ndarray
  - createComplex
```
public static IComplexNDArray createComplex(float[] data,
                                            int[] shape,
                                            int[] stride)
```
    Create an ndrray with the specified shape
    
    Parameters:
    
    data - the data to use with tne ndarray
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    Returns:
    
    the created ndarray
  - createComplex
```
public static IComplexNDArray createComplex(double[] data,
                                            int[] shape,
                                            int[] stride)
```
    Create an ndrray with the specified shape
    
    Parameters:
    
    data - the data to use with tne ndarray
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    Returns:
    
    the created ndarray
  - createComplex
```
public static IComplexNDArray createComplex(float[] data,
                                            int[] shape,
                                            int[] stride,
                                            int offset)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(double[] data,
                              int[] shape,
                              int[] stride,
                              int offset)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(double[] data,
                                            int[] shape,
                                            int[] stride,
                                            int offset)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    data - the data to use with the ndarray
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(float[] data,
                              int rows,
                              int columns,
                              int[] stride,
                              int offset)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    data - the data to use with the ndarray
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(float[] data,
                                            int rows,
                                            int columns,
                                            int[] stride,
                                            int offset)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    data - the data to use with the ndarray
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(double[] data,
                              int rows,
                              int columns,
                              int[] stride,
                              int offset)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    data - the data to use with tne ndarray
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(double[] data,
                                            int rows,
                                            int columns,
                                            int[] stride,
                                            int offset)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(float[] data,
                              int[] shape,
                              int offset)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(double[] data,
                              int[] shape,
                              int offset,
                              char ordering)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(float[] data,
                              int[] shape,
                              int[] stride,
                              int offset)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(List<INDArray> list,
                              int[] shape)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(int rows,
                                            int columns,
                                            int[] stride,
                                            int offset)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(int rows,
                              int columns,
                              int[] stride,
                              int offset)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(int[] shape,
                                            int[] stride,
                                            int offset)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(int[] shape,
                              int[] stride,
                              int offset)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(int rows,
                                            int columns,
                                            int[] stride)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    stride - the stride for the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(int rows,
                              int columns,
                              int[] stride)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    stride - the stride for the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(int[] shape,
                                            int[] stride)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(int[] shape,
                              int[] stride)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(int rows,
                                            int columns)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(int rows,
                              int columns)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(int... shape)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(int... shape)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(float[] data,
                              int[] shape,
                              int[] stride,
                              char ordering,
                              int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
    
    ordering -
    
    offset -
    
    Returns:
  - create
```
public static INDArray create(float[] data,
                              int[] shape,
                              char ordering,
                              int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    ordering -
    
    offset -
    
    Returns:
  - create
```
public static INDArray create(DataBuffer data,
                              int[] shape,
                              int[] strides,
                              int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    strides -
    
    offset -
    
    Returns:
  - create
```
public static INDArray create(DataBuffer data,
                              int[] shape,
                              int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    offset -
    
    Returns:
  - create
```
public static INDArray create(DataBuffer data,
                              int[] newShape,
                              int[] newStride,
                              int offset,
                              char ordering)
```
    Parameters:
    
    data -
    
    newShape -
    
    newStride -
    
    offset -
    
    ordering -
    
    Returns:
  - createComplex
```
public static IComplexNDArray createComplex(DataBuffer data,
                                            int[] shape,
                                            int[] newStrides,
                                            int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    newStrides -
    
    offset -
    
    Returns:
  - createComplex
```
public static IComplexNDArray createComplex(DataBuffer data,
                                            int[] shape,
                                            int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    offset -
    
    Returns:
  - createComplex
```
public static IComplexNDArray createComplex(DataBuffer data,
                                            int[] shape,
                                            int[] newStrides,
                                            int offset,
                                            char ordering)
```
    Parameters:
    
    data -
    
    shape -
    
    newStrides -
    
    offset -
    
    ordering -
    
    Returns:
  - createComplex
```
public static IComplexNDArray createComplex(DataBuffer data,
                                            int[] shape,
                                            int offset,
                                            char ordering)
```
    Parameters:
    
    data -
    
    shape -
    
    offset -
    
    ordering -
    
    Returns:
  - create
```
public static INDArray create(DataBuffer data,
                              int[] shape)
```
    Parameters:
    
    data -
    
    shape -
    
    Returns:
  - createComplex
```
public static IComplexNDArray createComplex(DataBuffer data,
                                            int[] shape)
```
    Parameters:
    
    data -
    
    shape -
    
    Returns:
  - create
```
public static INDArray create(DataBuffer buffer)
```
    Parameters:
    
    buffer -
    
    Returns:
  - createComplex
```
public static IComplexNDArray createComplex(IComplexNumber[] iComplexNumbers)
```
    Create a complex array from the given numbers
    
    Parameters:
    
    iComplexNumbers - the numbers to use
    
    Returns:
    
    the complex numbers
  - createComplex
```
public static IComplexNDArray createComplex(IComplexNumber[][] iComplexNumbers)
```
    Create a complex ndarray based on the specified matrices
    
    Parameters:
    
    iComplexNumbers - the complex numbers
    
    Returns:
    
    the complex numbers
  - createComplex
```
public static IComplexNDArray createComplex(float[] data,
                                            int rows,
                                            int columns,
                                            int[] stride,
                                            int offset,
                                            char ordering)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    data - the data to use with the ndarray
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(float[] data,
                              int rows,
                              int columns,
                              int[] stride,
                              int offset,
                              char ordering)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    data - the data to use with the ndarray
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(int[] shape,
                              DataBuffer.Type dataType)
```
  - createComplex
```
public static IComplexNDArray createComplex(float[] data,
                                            int[] shape,
                                            int[] stride,
                                            int offset,
                                            char ordering)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    data - the data to use with the ndarray
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(double[] data,
                              int[] shape,
                              int[] stride,
                              int offset,
                              char ordering)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(double[] data,
                              int[] shape,
                              char ordering)
```
    Create an ndrray with the specified shape
    
    Parameters:
    
    data - the data to use with tne ndarray
    
    shape - the shape of the ndarray
    
    Returns:
    
    the created ndarray
  - create
```
public static INDArray create(float[] data,
                              int[] shape,
                              char ordering)
```
    Create an ndrray with the specified shape
    
    Parameters:
    
    data - the data to use with tne ndarray
    
    shape - the shape of the ndarray
    
    Returns:
    
    the created ndarray
  - createComplex
```
public static IComplexNDArray createComplex(float[] data,
                                            int[] shape,
                                            char ordering)
```
    Create an ndrray with the specified shape
    
    Parameters:
    
    data - the data to use with tne ndarray
    
    shape - the shape of the ndarray
    
    Returns:
    
    the created ndarray
  - createComplex
```
public static IComplexNDArray createComplex(double[] data,
                                            int[] shape,
                                            char ordering)
```
    Create an ndrray with the specified shape
    
    Parameters:
    
    data - the data to use with tne ndarray
    
    shape - the shape of the ndarray
    
    Returns:
    
    the created ndarray
  - createComplex
```
public static IComplexNDArray createComplex(float[] data,
                                            int[] shape,
                                            int[] stride,
                                            char ordering)
```
    Create an ndrray with the specified shape
    
    Parameters:
    
    data - the data to use with tne ndarray
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    Returns:
    
    the created ndarray
  - createComplex
```
public static IComplexNDArray createComplex(double[] data,
                                            int[] shape,
                                            int[] stride,
                                            char ordering)
```
    Create an ndrray with the specified shape
    
    Parameters:
    
    data - the data to use with tne ndarray
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    Returns:
    
    the created ndarray
  - createComplex
```
public static IComplexNDArray createComplex(double[] data,
                                            int rows,
                                            int columns,
                                            int[] stride,
                                            int offset,
                                            char ordering)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(double[] data,
                              int rows,
                              int columns,
                              int[] stride,
                              int offset,
                              char ordering)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    data - the data to use with tne ndarray
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(double[] data,
                                            int[] shape,
                                            int[] stride,
                                            int offset,
                                            char ordering)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(float[] data,
                              int[] shape,
                              int[] stride,
                              int offset,
                              char ordering)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(List<INDArray> list,
                              int[] shape,
                              char ordering)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(int rows,
                                            int columns,
                                            int[] stride,
                                            int offset,
                                            char ordering)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(int rows,
                              int columns,
                              int[] stride,
                              int offset,
                              char ordering)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(int[] shape,
                                            int[] stride,
                                            int offset,
                                            char ordering)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(int[] shape,
                              int[] stride,
                              int offset,
                              char ordering)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    offset - the offset of the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(int rows,
                                            int columns,
                                            int[] stride,
                                            char ordering)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    stride - the stride for the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(int rows,
                              int columns,
                              int[] stride,
                              char ordering)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    stride - the stride for the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(int[] shape,
                                            int[] stride,
                                            char ordering)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(int[] shape,
                              int[] stride,
                              char ordering)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    stride - the stride for the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(int rows,
                                            int columns,
                                            char ordering)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(int rows,
                              int columns,
                              char ordering)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(int[] shape,
                                            char ordering)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
    
    the instance
  - create
```
public static INDArray create(int[] shape,
                              char ordering)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
    
    the instance
  - createComplex
```
public static IComplexNDArray createComplex(float[] data,
                                            int[] shape,
                                            int offset,
                                            char ordering)
```
    Create complex ndarray
    
    Parameters:
    
    data -
    
    shape -
    
    offset -
    
    ordering -
    
    Returns:
  - createComplex
```
public static IComplexNDArray createComplex(double[] data,
                                            int[] shape,
                                            int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    offset -
    
    Returns:
  - create
```
public static INDArray create(double[] data,
                              int[] shape,
                              int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    offset -
    
    Returns:
  - createComplex
```
public static IComplexNDArray createComplex(double[] data,
                                            int[] shape,
                                            int offset,
                                            char ordering)
```
    Parameters:
    
    data -
    
    shape -
    
    offset -
    
    ordering -
    
    Returns:
  - createComplex
```
public static IComplexNDArray createComplex(double[] dim)
```
    Parameters:
    
    dim -
    
    Returns:
  - createComplex
```
public static IComplexNDArray createComplex(float[] data,
                                            int[] shape,
                                            int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    offset -
    
    Returns:
  - hasInvalidNumber
```
public static boolean hasInvalidNumber(INDArray num)
```
    Returns true if the given ndarray has either an infinite or nan
    
    Parameters:
    
    num - the ndarray to test
    
    Returns:
    
    true if the given ndarray has either infinite or nan false otherwise
  - zeros
```
public static INDArray zeros(int rows,
                             int columns)
```
    Creates a row vector with the specified number of columns
    
    Parameters:
    
    rows - the rows of the ndarray
    
    columns - the columns of the ndarray
    
    Returns:
    
    the created ndarray
  - complexZeros
```
public static INDArray complexZeros(int rows,
                                    int columns)
```
    Creates a matrix of zeros
    
    Parameters:
    
    rows - te number of rows in the matrix
    
    columns - the number of columns in the row vector
    
    Returns:
    
    ndarray
  - zeros
```
public static INDArray zeros(int columns)
```
    Creates a row vector with the specified number of columns
    
    Parameters:
    
    columns - the columns of the ndarray
    
    Returns:
    
    the created ndarray
  - complexZeros
```
public static IComplexNDArray complexZeros(int columns)
```
    Creates an ndarray
    
    Parameters:
    
    columns - the number of columns in the row vector
    
    Returns:
    
    ndarray
  - complexValueOf
```
public static IComplexNDArray complexValueOf(int num,
                                             IComplexNumber value)
```
  - complexValueOf
```
public static IComplexNDArray complexValueOf(int[] shape,
                                             IComplexNumber value)
```
  - complexValueOf
```
public static IComplexNDArray complexValueOf(int num,
                                             double value)
```
  - complexValueOf
```
public static IComplexNDArray complexValueOf(int[] shape,
                                             double value)
```
  - valueArrayOf
```
public static INDArray valueArrayOf(int[] shape,
                                    double value)
```
    Creates an ndarray with the specified value as the only value in the ndarray
    
    Parameters:
    
    shape - the shape of the ndarray
    
    value - the value to assign
    
    Returns:
    
    the created ndarray
  - valueArrayOf
```
public static INDArray valueArrayOf(int num,
                                    double value)
```
    Creates an ndarray with the specified value as the only value in the ndarray
    
    Parameters:
    
    num - number of columns
    
    value - the value to assign
    
    Returns:
    
    the created ndarray
  - valueArrayOf
```
public static INDArray valueArrayOf(int rows,
                                    int columns,
                                    double value)
```
    Creates a row vector with the specified number of columns
    
    Parameters:
    
    rows - the number of rows in the matrix
    
    columns - the columns of the ndarray
    
    value - the value to assign
    
    Returns:
    
    the created ndarray
  - ones
```
public static INDArray ones(int rows,
                            int columns)
```
    Creates a row vector with the specified number of columns
    
    Parameters:
    
    rows - the number of rows in the matrix
    
    columns - the columns of the ndarray
    
    Returns:
    
    the created ndarray
  - zerosLike
```
public static INDArray zerosLike(INDArray arr)
```
    Empty like
    
    Parameters:
    
    arr - the array to create the ones like
    
    Returns:
    
    ones in the shape of the given array
  - emptyLike
```
public static INDArray emptyLike(INDArray arr)
```
    Empty like
    
    Parameters:
    
    arr - the array to create the ones like
    
    Returns:
    
    ones in the shape of the given array
  - onesLike
```
public static INDArray onesLike(INDArray arr)
```
    Ones like
    
    Parameters:
    
    arr - the array to create the ones like
    
    Returns:
    
    ones in the shape of the given array
  - complexOnes
```
public static IComplexNDArray complexOnes(int rows,
                                          int columns)
```
    Creates an ndarray
    
    Parameters:
    
    rows - the number of rows in the matrix
    
    columns - the number of columns in the row vector
    
    Returns:
    
    ndarray
  - ones
```
public static INDArray ones(int columns)
```
    Creates a row vector with the specified number of columns
    
    Parameters:
    
    columns - the columns of the ndarray
    
    Returns:
    
    the created ndarray
  - complexOnes
```
public static IComplexNDArray complexOnes(int columns)
```
    Creates an ndarray
    
    Parameters:
    
    columns - the number of columns in the row vector
    
    Returns:
    
    ndarray
  - hstack
```
public static INDArray hstack(INDArray... arrs)
```
    Concatenates two matrices horizontally. Matrices must have identical numbers of rows.
    
    Parameters:
    
    arrs - the first matrix to concat
  - vstack
```
public static INDArray vstack(INDArray... arrs)
```
    Concatenates two matrices vertically. Matrices must have identical numbers of columns.
    
    Parameters:
    
    arrs -
  - stripOnes
```
public static INDArray stripOnes(INDArray toStrip)
```
    Reshapes an ndarray to remove leading 1s
    
    Parameters:
    
    toStrip - the ndarray to newShapeNoCopy
    
    Returns:
    
    the reshaped ndarray
  - concat
```
public static INDArray concat(int dimension,
                              INDArray... toConcat)
```
    Concatneate ndarrays along a dimension
    
    Parameters:
    
    dimension - the dimension to concatnte along
    
    toConcat - the ndarrays to concat
    
    Returns:
    
    the concatted ndarrays with an output shape of the ndarray shapes save the dimension shape specified which is then the sum of the sizes along that dimension
  - concat
```
public static IComplexNDArray concat(int dimension,
                                     IComplexNDArray... toConcat)
```
    Concatneate ndarrays along a dimension
    
    Parameters:
    
    dimension - the dimension to concatneate along
    
    toConcat - the ndarrays to concat
    
    Returns:
    
    the concatted ndarrays with an output shape of the ndarray shapes save the dimension shape specified which is then the sum of the sizes along that dimension
  - zeros
```
public static INDArray zeros(int... shape)
```
    Create an ndarray of zeros
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
    
    an ndarray with ones filled in
  - complexZeros
```
public static IComplexNDArray complexZeros(int... shape)
```
    Create an ndarray of ones
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
    
    an ndarray with ones filled in
  - ones
```
public static INDArray ones(int... shape)
```
    Create an ndarray of ones
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
    
    an ndarray with ones filled in
  - complexOnes
```
public static IComplexNDArray complexOnes(int... shape)
```
    Create an ndarray of ones
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
    
    an ndarray with ones filled in
  - scalar
```
public static INDArray scalar(Number value,
                              int offset)
```
    Create a scalar ndarray with the specified offset
    
    Parameters:
    
    value - the value to initialize the scalar with
    
    offset - the offset of the ndarray
    
    Returns:
    
    the created ndarray
  - complexScalar
```
public static IComplexNDArray complexScalar(Number value,
                                            int offset)
```
    Create a scalar ndarray with the specified offset
    
    Parameters:
    
    value - the value to initialize the scalar with
    
    offset - the offset of the ndarray
    
    Returns:
    
    the created ndarray
  - complexScalar
```
public static IComplexNDArray complexScalar(Number value)
```
    Create a scalar ndarray with the specified offset
    
    Parameters:
    
    value - the value to initialize the scalar with
    
    Returns:
    
    the created ndarray
  - scalar
```
public static INDArray scalar(double value,
                              int offset)
```
    Create a scalar nd array with the specified value and offset
    
    Parameters:
    
    value - the value of the scalar
    
    offset - the offset of the ndarray
    
    Returns:
    
    the scalar nd array
  - scalar
```
public static INDArray scalar(float value,
                              int offset)
```
    Create a scalar nd array with the specified value and offset
    
    Parameters:
    
    value - the value of the scalar
    
    offset - the offset of the ndarray
    
    Returns:
    
    the scalar nd array
  - scalar
```
public static INDArray scalar(Number value)
```
    Create a scalar ndarray with the specified offset
    
    Parameters:
    
    value - the value to initialize the scalar with
    
    Returns:
    
    the created ndarray
  - scalar
```
public static INDArray scalar(double value)
```
    Create a scalar nd array with the specified value and offset
    
    Parameters:
    
    value - the value of the scalar = * @return the scalar nd array
  - scalar
```
public static INDArray scalar(float value)
```
    Create a scalar nd array with the specified value and offset
    
    Parameters:
    
    value - the value of the scalar = * @return the scalar nd array
  - scalar
```
public static IComplexNDArray scalar(IComplexNumber value,
                                     int offset)
```
    Create a scalar ndarray with the specified offset
    
    Parameters:
    
    value - the value to initialize the scalar with
    
    offset - the offset of the ndarray
    
    Returns:
    
    the created ndarray
  - scalar
```
public static IComplexNDArray scalar(IComplexFloat value)
```
    Create a scalar nd array with the specified value and offset
    
    Parameters:
    
    value - the value of the scalar
    
    Returns:
    
    the scalar nd array
  - scalar
```
public static IComplexNDArray scalar(IComplexDouble value)
```
    Create a scalar nd array with the specified value and offset
    
    Parameters:
    
    value - the value of the scalar = * @return the scalar nd array
  - scalar
```
public static IComplexNDArray scalar(IComplexNumber value)
```
    Create a scalar ndarray with the specified offset
    
    Parameters:
    
    value - the value to initialize the scalar with
    
    Returns:
    
    the created ndarray
  - scalar
```
public static IComplexNDArray scalar(IComplexFloat value,
                                     int offset)
```
    Create a scalar nd array with the specified value and offset
    
    Parameters:
    
    value - the value of the scalar
    
    offset - the offset of the ndarray
    
    Returns:
    
    the scalar nd array
  - scalar
```
public static IComplexNDArray scalar(IComplexDouble value,
                                     int offset)
```
    Create a scalar nd array with the specified value and offset
    
    Parameters:
    
    value - the value of the scalar
    
    offset - the offset of the ndarray
    
    Returns:
    
    the scalar nd array
  - getStrides
```
public static int[] getStrides(int[] shape,
                               char order)
```
    Get the strides for the given order and shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    order - the order to getScalar the strides for
    
    Returns:
    
    the strides for the given shape and order
  - getStrides
```
public static int[] getStrides(int[] shape)
```
    Get the strides based on the shape and NDArrays.order()
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
    
    the strides for the given shape and order specified by NDArrays.order()
  - tile
```
public static INDArray tile(INDArray tile,
                            int... repeat)
```
    An alias for repmat
    
    Parameters:
    
    tile - the ndarray to tile
    
    repeat - the shape to repeat
    
    Returns:
    
    the tiled ndarray
  - getComplexStrides
```
public static int[] getComplexStrides(int[] shape,
                                      char order)
```
    Get the strides for the given order and shape
    
    Parameters:
    
    shape - the shape of the ndarray
    
    order - the order to getScalar the strides for
    
    Returns:
    
    the strides for the given shape and order
  - getComplexStrides
```
public static int[] getComplexStrides(int[] shape)
```
    Get the strides based on the shape and NDArrays.order()
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
    
    the strides for the given shape and order specified by NDArrays.order()
  - complexLinSpace
```
public static IComplexNDArray complexLinSpace(int i,
                                              int i1,
                                              int i2)
```
    Linspace with complex numbers
    
    Parameters:
    
    i -
    
    i1 -
    
    i2 -
    
    Returns:
  - initContext
```
public void initContext()
```
    Initializes nd4j
  - initWithBackend
```
public void initWithBackend(Nd4jBackend backend)
```
    Initialize with the specific backend
    
    Parameters:
    
    backend - the backend to initialize with

Class Nd4j

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NUMERICAL_STABILITY

FFT_OPS

DATA_BUFFER_OPS

CONVOLUTION_OPS

DTYPE

BLAS_OPS

ORDER_KEY

NDARRAY_FACTORY_CLASS

COPY_OPS

OP_EXECUTIONER

OP_FACTORY

TASK_FACTORY

RANDOM

DISTRIBUTION

INSTRUMENTATION

RESOURCE_MANAGER

RESOURCE_MANGER_ON

ALLOC

EXECUTION_MODE

executionMode

dtype

alloc

ORDER

UNIT

ZERO

NEG_UNIT

EPS_THRESHOLD

MAX_ELEMENTS_PER_SLICE

MAX_SLICES_TO_PRINT

ENFORCE_NUMERICAL_STABILITY

copyOnOps

shouldInstrument

resourceManagerOn

blasWrapperClazz

ndArrayFactoryClazz

fftInstanceClazz

convolutionInstanceClazz

dataBufferFactoryClazz

opExecutionerClazz

opFactoryClazz

taskFactoryClazz

randomClazz

distributionFactoryClazz

instrumentationClazz

DATA_BUFFER_FACTORY_INSTANCE

BLAS_WRAPPER_INSTANCE

INSTANCE

FFT_INSTANCE

CONVOLUTION_INSTANCE

OP_EXECUTIONER_INSTANCE

DISTRIBUTION_FACTORY

OP_FACTORY_INSTANCE

TASK_FACTORY_INSTANCE

random

instrumentation

props

referenceQueue

bufferQueue

Constructor Detail

Nd4j

Method Detail

pad

pad

pad

pad

append

prepend

shuffle

shuffle

refQueue

bufferRefQueue

getInstrumentation

getDistributions