Nd4j (nd4j-api 0.0.3.1 API)

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

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

Author:

Adam Gibson

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`BLAS_OPS`
`static String`	`COMPLEX_CLASS_PROP`
`static String`	`dtype`
`static String`	`DTYPE`
`static String`	`LINALG_PROPS`
`static String`	`NDARRAY_FACTORY_CLASS`
`static IComplexNumber`	`NEG_UNIT`
`static char`	`ORDER`
`static String`	`ORDER_KEY`
`static String`	`REAL_CLASS_PROP`
`static IComplexNumber`	`UNIT`
`static IComplexNumber`	`ZERO`

Constructor Summary

Constructors
Constructor and Description

Nd4j()

Constructors
Constructor and Description
`Nd4j()`

Method Summary

Methods
Modifier and Type	Method and Description
`static INDArray`	`appendBias(INDArray... vectors)`
`static INDArray`	`arange(double begin, double end)` Array of evenly spaced values.
`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 IComplexNDArray`	`complexFlatten(IComplexNDArray... flatten)`
`static IComplexNDArray`	`complexFlatten(List<IComplexNDArray> flatten)`
`static IComplexNDArray`	`complexLinSpace(int i, int i1, int i2)`
`static IComplexNDArray`	`complexOnes(int columns)` Creates an ndarray
`static IComplexNDArray`	`complexOnes(int[] shape)` Create an ndarray of ones
`static INDArray`	`complexOnes(int rows, int columns)` Creates an ndarray
`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 INDArray`	`complexZeros(int columns)` Creates an ndarray
`static IComplexNDArray`	`complexZeros(int[] shape)` Create an ndarray of ones
`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(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 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)` Creates an ndarray with the specified shape
`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[][] floats)`
`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)`
`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 columns)` Creates a row vector with the specified number of columns
`static INDArray`	`create(int[] shape)` Creates an ndarray with the specified shape
`static INDArray`	`create(int[] shape, char ordering)` Creates an ndarray with the specified shape
`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 IComplexNDArray`	`createComplex(double[] data)` Creates an ndarray with the specified data
`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[] ints, 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[] dim)`
`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[] ints, int offset, char ordering)`
`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[] data, int[] shape)` Create a complex ndarray from the passed in indarray
`static IComplexNDArray`	`createComplex(IComplexNumber[] data, int[] shape, int offset, char ordering)` 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(int columns)` Creates an ndarray
`static IComplexNDArray`	`createComplex(int[] shape)` Creates a complex ndarray with the specified shape
`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 IComplexFloat`	`createComplexNumber(Number real, Number imag)` Create float
`static IComplexDouble`	`createDouble(double real, double imag)` Create an instance of a complex double
`static IComplexFloat`	`createFloat(float real, float imag)` Create float
`static String`	`dataType()` Returns the data type used for the runtime
`static INDArray`	`eye(int n)` Create the identity ndarray
`static NDArrayFactory`	`factory()`
`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 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 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.
`static INDArray`	`linspace(int lower, int upper, int num)` Generate a linearly spaced vector
`static INDArray`	`ones(int columns)` Creates a row vector with the specified number of columns
`static INDArray`	`ones(int[] shape)` Create an ndarray of ones
`static INDArray`	`ones(int rows, int columns)` Creates a row vector with the specified number of columns
`static Character`	`order()` Returns the ordering of the ndarrays
`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, float min, float max, org.apache.commons.math3.random.RandomGenerator 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 the given rng
`static INDArray`	`rand(int[] shape, org.apache.commons.math3.random.RandomGenerator r)` Create a random ndarray with the given shape using the given rng
`static INDArray`	`rand(int[] shape, org.apache.commons.math3.distribution.RealDistribution r)` Create a random ndarray with the given shape using the given rng
`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, float min, float max, org.apache.commons.math3.random.RandomGenerator 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 rng
`static INDArray`	`rand(int rows, int columns, org.apache.commons.math3.random.RandomGenerator r)` Create a random ndarray with the given shape using the given rng
`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, org.apache.commons.math3.random.RandomGenerator 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, org.apache.commons.math3.random.RandomGenerator r)` Random normal using the given rng
`static INDArray`	`read(DataInputStream dis)` Read in an ndarray from a data input stream
`static IComplexNDArray`	`readComplex(DataInputStream dis)` Read in an ndarray from a data input stream
`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`	`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 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)`
`static void`	`setFactory(NDArrayFactory factory)`
`static INDArray`	`toFlattened(Collection<INDArray> matrices)`
`static INDArray`	`toFlattened(INDArray... matrices)`
`static INDArray`	`toFlattened(int length, Iterator<? extends INDArray>... matrices)`
`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 INDArray`	`vstack(INDArray... arrs)` Concatenates two matrices vertically.
`static void`	`write(INDArray arr, DataOutputStream dataOutputStream)` Write an ndarray to the specified outputs tream
`static void`	`writeComplex(IComplexNDArray arr, DataOutputStream dataOutputStream)` Write an ndarray to the specified outputs tream
`static INDArray`	`zeros(int columns)` Creates a row vector with the specified number of columns
`static INDArray`	`zeros(int[] shape)` Create an ndarray of zeros
`static INDArray`	`zeros(int rows, int columns)` Creates a row vector with the specified number of columns

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

- Field Detail
  - LINALG_PROPS
```
public static final String LINALG_PROPS
```
    See Also:
    Constant Field Values
  - REAL_CLASS_PROP
```
public static final String REAL_CLASS_PROP
```
    See Also:
    Constant Field Values
  - COMPLEX_CLASS_PROP
```
public static final String COMPLEX_CLASS_PROP
```
    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
  - dtype
```
public static String dtype
```
  - ORDER
```
public static char ORDER
```
  - 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
  - UNIT
```
public static final IComplexNumber UNIT
```
  - ZERO
```
public static final IComplexNumber ZERO
```
  - NEG_UNIT
```
public static final IComplexNumber NEG_UNIT
```
- Constructor Detail
  - Nd4j
```
public Nd4j()
```
- Method Detail
  - factory
```
public static NDArrayFactory factory()
```
  - setFactory
```
public static void setFactory(NDArrayFactory factory)
```
  - setBlasWrapper
```
public static void setBlasWrapper(BlasWrapper factory)
```
  - order
```
public static Character order()
```
    Returns the ordering of the ndarrays
    
    Returns:
    the ordering of the ndarrays
  - dataType
```
public static String dataType()
```
    Returns the data type used for the runtime
    
    Returns:
    the datatype used for the runtime
  - getBlasWrapper
```
public static BlasWrapper getBlasWrapper()
```
  - 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
  - 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)
```
  - complexFlatten
```
public static IComplexNDArray complexFlatten(List<IComplexNDArray> flatten)
```
  - complexFlatten
```
public static IComplexNDArray complexFlatten(IComplexNDArray... flatten)
```
  - toFlattened
```
public static INDArray toFlattened(int length,
                   Iterator<? extends INDArray>... matrices)
```
  - 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)
```
  - 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
  - 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 outputs tream
    
    Parameters:
    arr - the array to write
    dataOutputStream - the data output stream to write to
    
    Throws:
    
    IOException
  - 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
  - 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
  - createComplexNumber
```
public static IComplexFloat createComplexNumber(Number real,
                                Number imag)
```
    Create float
    
    Parameters:
    real - real component
    imag - imag component
    
    Returns:
  - createFloat
```
public static IComplexFloat createFloat(float real,
                        float imag)
```
    Create float
    
    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
  - rand
```
public static INDArray rand(int[] shape,
            float min,
            float max,
            org.apache.commons.math3.random.RandomGenerator 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 drandom matrix of the specified shape and range
  - rand
```
public static INDArray rand(int rows,
            int columns,
            float min,
            float max,
            org.apache.commons.math3.random.RandomGenerator 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
  - appendBias
```
public static INDArray appendBias(INDArray... vectors)
```
  - 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
  - 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(IComplexNumber[] data,
                            int[] shape,
                            int offset,
                            char ordering)
```
    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
  - rand
```
public static INDArray rand(int rows,
            int columns,
            org.apache.commons.math3.random.RandomGenerator r)
```
    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
    r - the random generator to use
    
    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 rng
    
    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 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
  - randn
```
public static INDArray randn(int rows,
             int columns,
             org.apache.commons.math3.random.RandomGenerator 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 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:
  - rand
```
public static INDArray rand(int[] shape,
            org.apache.commons.math3.distribution.RealDistribution r)
```
    Create a random ndarray with the given shape using the given rng
    
    Parameters:
    shape - the shape of the ndarray
    r - the random generator to use
    
    Returns:
    the random ndarray with the specified shape
  - rand
```
public static INDArray rand(int[] shape,
            org.apache.commons.math3.random.RandomGenerator r)
```
    Create a random ndarray with the given shape using the given rng
    
    Parameters:
    shape - the shape of the ndarray
    r - the random generator to use
    
    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 the given rng
    
    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(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
  - randn
```
public static INDArray randn(int[] shape,
             org.apache.commons.math3.random.RandomGenerator r)
```
    Random normal using the given rng
    
    Parameters:
    shape - the shape of the ndarray
    r - the random generator to use
    
    Returns:
  - 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:
  - 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
  - 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
  - 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
  - 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)
```
    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)
```
    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)
```
    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
  - 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 INDArray 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
  - complexOnes
```
public static INDArray 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 -
  - concat
```
public static INDArray concat(int dimension,
              INDArray... 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
  - 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
  - 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(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[] 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[] 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(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
  - 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(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)
```
    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,
                            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)
```
    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)
```
    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)
```
    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)
```
    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 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(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
  - 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
  - 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(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(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(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(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 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 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()
  - 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()
  - 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
  - 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(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(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(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,
                            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,
                            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(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 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(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(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(double[] data,
                            int[] ints,
                            int offset,
                            char ordering)
```
  - createComplex
```
public static IComplexNDArray createComplex(double[] data,
                            int[] shape,
                            int offset)
```
  - create
```
public static INDArray create(float[] data,
              int[] shape,
              int offset)
```
  - createComplex
```
public static IComplexNDArray createComplex(float[] data,
                            int[] ints,
                            int offset,
                            char ordering)
```
  - createComplex
```
public static IComplexNDArray createComplex(float[] dim)
```
  - createComplex
```
public static IComplexNDArray createComplex(float[] data,
                            int[] shape,
                            int offset)
```
  - create
```
public static INDArray create(float[][] floats)
```
  - complexLinSpace
```
public static IComplexNDArray complexLinSpace(int i,
                              int i1,
                              int i2)
```
  - create
```
public static INDArray create(float[] data,
              int[] shape,
              int[] stride,
              char ordering,
              int offset)
```
  - create
```
public static INDArray create(float[] data,
              int[] shape,
              char ordering,
              int offset)
```

Class Nd4j

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LINALG_PROPS

REAL_CLASS_PROP

COMPLEX_CLASS_PROP

DTYPE

BLAS_OPS

dtype

ORDER

ORDER_KEY

NDARRAY_FACTORY_CLASS

UNIT

ZERO

NEG_UNIT

Constructor Detail

Nd4j

Method Detail

factory

setFactory

setBlasWrapper

order

dataType

getBlasWrapper

repeat

repeat

linspace

toFlattened

complexFlatten

complexFlatten

toFlattened

bilinearProducts

toFlattened

eye

rot90

read

write

create

readComplex

writeComplex

rot

reverse

arange

createComplexNumber

createFloat

createDouble

copy

rand

rand

appendBias

createComplex

createComplex

createComplex

createComplex

rand

rand

rand

randn

randn

randn

rand

rand

rand

rand

randn

randn

randn

create

create

createComplex

create

createComplex

create

create

createComplex

create

createComplex