NDArrayFactory (nd4j-api 0.0.3.1 API)

All Known Implementing Classes:

BaseNDArrayFactory
```
public interface NDArrayFactory
```
Creation of ndarrays via classpath discovery.

Author:

Adam Gibson

Field Summary

Fields
Modifier and Type Field and Description

static char C

static char FORTRAN

Fields
Modifier and Type	Field and Description
`static char`	`C`
`static char`	`FORTRAN`

Method Summary

Methods
Modifier and Type	Method and Description
`INDArray`	`appendBias(INDArray... vectors)`
`INDArray`	`arange(double begin, double end)` Array of evenly spaced values.
`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.
`IComplexNDArray`	`complexFlatten(IComplexNDArray[] flatten)`
`IComplexNDArray`	`complexFlatten(List<IComplexNDArray> flatten)`
`IComplexNDArray`	`complexOnes(int columns)` Creates an ndarray
`IComplexNDArray`	`complexOnes(int[] shape)` Create an ndarray of ones
`INDArray`	`complexOnes(int rows, int columns)` Creates an ndarray
`IComplexNDArray`	`complexScalar(Number value)` Create a scalar ndarray with the specified offset
`IComplexNDArray`	`complexScalar(Number value, int offset)` Create a scalar ndarray with the specified offset
`IComplexNDArray`	`complexValueOf(int[] shape, double value)` Creates an shape ndarray with the specified value
`IComplexNDArray`	`complexValueOf(int[] shape, IComplexNumber value)` Creates an shape ndarray with the specified value
`IComplexNDArray`	`complexValueOf(int num, double value)` Creates an 1 x num ndarray with the specified value
`IComplexNDArray`	`complexValueOf(int num, IComplexNumber value)` Creates an 1 x num ndarray with the specified value
`IComplexNDArray`	`complexZeros(int columns)` Creates an ndarray
`IComplexNDArray`	`complexZeros(int[] shape)` Create an ndarray of ones
`IComplexNDArray`	`complexZeros(int rows, int columns)` Creates a matrix of zeros
`IComplexNDArray`	`concat(int dimension, IComplexNDArray... toConcat)` Concatneate ndarrays along a dimension
`INDArray`	`concat(int dimension, INDArray... toConcat)` Concatneate ndarrays along a dimension
`void`	`copy(INDArray a, INDArray b)` Copy a to b
`INDArray`	`create(double[] data)` Creates a row vector with the data
`INDArray`	`create(double[][] data)` Create an ndarray with the given data layout
`INDArray`	`create(double[] data, int[] shape)` Create an ndrray with the specified shape
`INDArray`	`create(double[] data, int[] shape, int[] stride, int offset)` Creates an ndarray with the specified shape
`INDArray`	`create(double[] data, int rows, int columns, int[] stride, int offset)` Creates an ndarray with the specified shape
`INDArray`	`create(float[] data)` Creates a row vector with the data
`INDArray`	`create(float[][] floats)`
`INDArray`	`create(float[] data, int[] shape)` Create an ndrray with the specified shape
`INDArray`	`create(float[] data, int[] shape, int offset)`
`INDArray`	`create(float[] data, int[] shape, int[] stride, int offset)` Creates an ndarray with the specified shape
`INDArray`	`create(float[] data, int[] shape, int[] stride, int offset, char ordering)`
`INDArray`	`create(float[] data, int rows, int columns, int[] stride, int offset)` Creates an ndarray with the specified shape
`INDArray`	`create(int columns)` Creates a row vector with the specified number of columns
`INDArray`	`create(int[] shape)` Creates an ndarray with the specified shape
`INDArray`	`create(int[] shape, int[] stride)` Creates an ndarray with the specified shape
`INDArray`	`create(int[] shape, int[] stride, int offset)` Creates an ndarray with the specified shape
`INDArray`	`create(int rows, int columns)` Creates an ndarray with the specified shape
`INDArray`	`create(int rows, int columns, int[] stride)` Creates an ndarray with the specified shape
`INDArray`	`create(int rows, int columns, int[] stride, int offset)` Creates an ndarray with the specified shape
`INDArray`	`create(List<INDArray> list, int[] shape)` Creates an ndarray with the specified shape
`IComplexNDArray`	`createComplex(double[] data)` Creates an ndarray with the specified data
`IComplexNDArray`	`createComplex(double[] data, int[] shape)` Create an ndrray with the specified shape
`IComplexNDArray`	`createComplex(double[] data, int[] shape, int offset)`
`IComplexNDArray`	`createComplex(double[] data, int[] shape, int[] stride)` Create an ndrray with the specified shape
`IComplexNDArray`	`createComplex(double[] data, int[] shape, int[] stride, int offset)` Creates a complex ndarray with the specified shape
`IComplexNDArray`	`createComplex(double[] data, int[] shape, int[] stride, int offset, char ordering)` Create a complex ndarray with the given data
`IComplexNDArray`	`createComplex(double[] data, int[] shape, int offset, char ordering)`
`IComplexNDArray`	`createComplex(double[] data, int rows, int columns, int[] stride, int offset)` Creates a complex ndarray with the specified shape
`IComplexNDArray`	`createComplex(float[] dim)`
`IComplexNDArray`	`createComplex(float[] data, int[] shape)` Create an ndrray with the specified shape
`IComplexNDArray`	`createComplex(float[] data, int[] shape, int offset)`
`IComplexNDArray`	`createComplex(float[] data, int[] shape, int[] stride)` Create an ndrray with the specified shape
`IComplexNDArray`	`createComplex(float[] data, int[] shape, int[] stride, int offset)` Creates a complex ndarray with the specified shape
`IComplexNDArray`	`createComplex(float[] data, int[] shape, int[] stride, int offset, char ordering)`
`IComplexNDArray`	`createComplex(float[] data, int[] shape, int offset, char ordering)`
`IComplexNDArray`	`createComplex(float[] data, int rows, int columns, int[] stride, int offset)` Creates a complex ndarray with the specified shape
`IComplexNDArray`	`createComplex(IComplexNumber[] data, int[] shape)` Create a complex ndarray from the passed in indarray
`IComplexNDArray`	`createComplex(IComplexNumber[] data, int[] shape, char ordering)` Creates a complex ndarray with the specified shape
`IComplexNDArray`	`createComplex(IComplexNumber[] data, int[] shape, int[] stride, char ordering)` Creates a complex ndarray with the specified shape
`IComplexNDArray`	`createComplex(IComplexNumber[] data, int[] shape, int[] stride, int offset)` Creates a complex ndarray with the specified shape
`IComplexNDArray`	`createComplex(IComplexNumber[] data, int[] shape, int[] stride, int offset, char ordering)` Creates a complex ndarray with the specified shape
`IComplexNDArray`	`createComplex(IComplexNumber[] data, int[] shape, int offset, char ordering)` Creates a complex ndarray with the specified shape
`IComplexNDArray`	`createComplex(INDArray arr)` Create a complex ndarray from the passed in indarray
`IComplexNDArray`	`createComplex(int columns)` Creates an ndarray
`IComplexNDArray`	`createComplex(int[] shape)` Creates a complex ndarray with the specified shape
`IComplexNDArray`	`createComplex(int[] shape, int[] stride)` Creates a complex ndarray with the specified shape
`IComplexNDArray`	`createComplex(int[] shape, int[] stride, int offset)` Creates a complex ndarray with the specified shape
`IComplexNDArray`	`createComplex(int rows, int columns)` Creates a complex ndarray with the specified shape
`IComplexNDArray`	`createComplex(int rows, int columns, int[] stride)` Creates a complex ndarray with the specified shape
`IComplexNDArray`	`createComplex(int rows, int columns, int[] stride, int offset)` Creates a complex ndarray with the specified shape
`IComplexNDArray`	`createComplex(List<IComplexNDArray> arrs, int[] shape)` Create a complex ndarray from the passed in indarray
`IComplexDouble`	`createDouble(double real, double imag)` Create an instance of a complex double
`IComplexFloat`	`createFloat(float real, float imag)` Create float
`String`	`dtype()` Returns the data type for this ndarray
`INDArray`	`eye(int n)` Create the identity ndarray
`INDArray`	`hstack(INDArray... arrs)` Concatenates two matrices horizontally.
`INDArray`	`linspace(int lower, int upper, int num)` Generate a linearly spaced vector
`INDArray`	`ones(int columns)` Creates a row vector with the specified number of columns
`INDArray`	`ones(int[] shape)` Create an ndarray of ones
`INDArray`	`ones(int rows, int columns)` Creates a row vector with the specified number of columns
`char`	`order()` Returns the order for this ndarray for internal data storage
`INDArray`	`rand(int[] shape)` Create a random ndarray with the given shape using the current time as the seed
`INDArray`	`rand(int[] shape, float min, float max, org.apache.commons.math3.random.RandomGenerator rng)` Generates a random matrix between min and max
`INDArray`	`rand(int[] shape, long seed)` Create a random ndarray with the given shape using the given rng
`INDArray`	`rand(int[] shape, org.apache.commons.math3.random.RandomGenerator r)` Create a random ndarray with the given shape using the given rng
`INDArray`	`rand(int[] shape, org.apache.commons.math3.distribution.RealDistribution r)` Create a random ndarray with the given shape using the given rng
`INDArray`	`rand(int rows, int columns)` Create a random ndarray with the given shape using the current time as the seed
`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
`INDArray`	`rand(int rows, int columns, long seed)` Create a random ndarray with the given shape using the given rng
`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
`INDArray`	`randn(int[] shape)` Random normal using the current time stamp as the seed
`INDArray`	`randn(int[] shape, long seed)` Random normal using the specified seed
`INDArray`	`randn(int[] shape, org.apache.commons.math3.random.RandomGenerator r)` Random normal using the given rng
`INDArray`	`randn(int rows, int columns)` Random normal using the current time stamp as the seed
`INDArray`	`randn(int rows, int columns, long seed)` Random normal using the specified seed
`INDArray`	`randn(int rows, int columns, org.apache.commons.math3.random.RandomGenerator r)` Random normal using the given rng
`INDArray`	`reverse(INDArray reverse)` Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
`INDArray`	`rot(INDArray reverse)` Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
`void`	`rot90(INDArray toRotate)` Rotate a matrix 90 degrees
`INDArray`	`scalar(double value)` Create a scalar nd array with the specified value and offset
`INDArray`	`scalar(double value, int offset)` Create a scalar nd array with the specified value and offset
`INDArray`	`scalar(float value)` Create a scalar nd array with the specified value and offset
`INDArray`	`scalar(float value, int offset)` Create a scalar nd array with the specified value and offset
`IComplexNDArray`	`scalar(IComplexDouble value)` Create a scalar nd array with the specified value and offset
`IComplexNDArray`	`scalar(IComplexDouble value, int offset)` Create a scalar nd array with the specified value and offset
`IComplexNDArray`	`scalar(IComplexFloat value)` Create a scalar nd array with the specified value and offset
`IComplexNDArray`	`scalar(IComplexFloat value, int offset)` Create a scalar nd array with the specified value and offset
`IComplexNDArray`	`scalar(IComplexNumber value)` Create a scalar ndarray with the specified offset
`IComplexNDArray`	`scalar(IComplexNumber value, int offset)` Create a scalar ndarray with the specified offset
`INDArray`	`scalar(Number value)` Create a scalar ndarray with the specified offset
`INDArray`	`scalar(Number value, int offset)` Create a scalar ndarray with the specified offset
`void`	`setDType(String dtype)` Sets the data type
`void`	`setOrder(char order)` Sets the order.
`INDArray`	`toFlattened(Collection<INDArray> matrices)` Returns a flattened ndarray with all of the elements in each ndarray regardless of dimension
`INDArray`	`toFlattened(INDArray... matrices)`
`INDArray`	`toFlattened(int length, Iterator<? extends INDArray>... matrices)` Returns a flattened ndarray with all of the elements in each ndarray regardless of dimension
`INDArray`	`valueArrayOf(int[] shape, double value)` Creates an ndarray with the specified value as the only value in the ndarray
`INDArray`	`valueArrayOf(int rows, int columns, double value)` Creates a row vector with the specified number of columns
`INDArray`	`vstack(INDArray... arrs)` Concatenates two matrices vertically.
`INDArray`	`zeros(int columns)` Creates a row vector with the specified number of columns
`INDArray`	`zeros(int[] shape)` Create an ndarray of zeros
`INDArray`	`zeros(int rows, int columns)` Creates a row vector with the specified number of columns

- Field Detail
  - FORTRAN
```
static final char FORTRAN
```
    See Also:
    Constant Field Values
  - C
```
static final char C
```
    See Also:
    Constant Field Values
- Method Detail
  - complexValueOf
```
IComplexNDArray complexValueOf(int num,
                             IComplexNumber value)
```
    Creates an 1 x num ndarray with the specified value
    
    Parameters:
    num - the number of columns
    value - the value to assign
    
    Returns:
    a complex ndarray of the specified size and value
  - complexValueOf
```
IComplexNDArray complexValueOf(int[] shape,
                             IComplexNumber value)
```
    Creates an shape ndarray with the specified value
    
    Parameters:
    shape - the shape of the ndarray
    value - the value to assign
    
    Returns:
    a complex ndarray of the specified size and value
  - complexValueOf
```
IComplexNDArray complexValueOf(int num,
                             double value)
```
    Creates an 1 x num ndarray with the specified value
    
    Parameters:
    num - the number of columns
    value - the value to assign
    
    Returns:
    a complex ndarray of the specified size and value
  - complexValueOf
```
IComplexNDArray complexValueOf(int[] shape,
                             double value)
```
    Creates an shape ndarray with the specified value
    
    Parameters:
    shape - the shape of the ndarray
    value - the value to assign
    
    Returns:
    a complex ndarray of the specified size and value
  - setOrder
```
void setOrder(char order)
```
    Sets the order. Primarily for testing purposes
    
    Parameters:
    order -
  - setDType
```
void setDType(String dtype)
```
    Sets the data type
    
    Parameters:
    dtype -
  - order
```
char order()
```
    Returns the order for this ndarray for internal data storage
    
    Returns:
    the order (c or f)
  - dtype
```
String dtype()
```
    Returns the data type for this ndarray
    
    Returns:
    the data type for this ndarray
  - createComplex
```
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
  - linspace
```
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
```
INDArray toFlattened(Collection<INDArray> matrices)
```
    Returns a flattened ndarray with all of the elements in each ndarray regardless of dimension
    
    Parameters:
    matrices - the ndarrays to use
    
    Returns:
    a flattened ndarray of the elements in the order of titerating over the ndarray and the linear view of each
  - toFlattened
```
INDArray toFlattened(int length,
                   Iterator<? extends INDArray>... matrices)
```
    Returns a flattened ndarray with all of the elements in each ndarray regardless of dimension
    
    Parameters:
    matrices - the ndarrays to use
    
    Returns:
    a flattened ndarray of the elements in the order of titerating over the ndarray and the linear view of each
  - bilinearProducts
```
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
```
INDArray toFlattened(INDArray... matrices)
```
  - eye
```
INDArray eye(int n)
```
    Create the identity ndarray
    
    Parameters:
    n - the number for the identity
    
    Returns:
  - rot90
```
void rot90(INDArray toRotate)
```
    Rotate a matrix 90 degrees
    
    Parameters:
    toRotate - the matrix to rotate
  - rot
```
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
```
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
```
INDArray arange(double begin,
              double end)
```
    Array of evenly spaced values. Returns a row vector
    
    Parameters:
    begin - the begin of the range
    end - the end of the range
    
    Returns:
    the range vector
  - createFloat
```
IComplexFloat createFloat(float real,
                        float imag)
```
    Create float
    
    Parameters:
    real - real component
    imag - imag component
    
    Returns:
  - createDouble
```
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
```
void copy(INDArray a,
        INDArray b)
```
    Copy a to b
    
    Parameters:
    a - the origin matrix
    b - the destination matrix
  - rand
```
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
```
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
```
INDArray appendBias(INDArray... vectors)
```
  - create
```
INDArray create(double[][] data)
```
    Create an ndarray with the given data layout
    
    Parameters:
    data - the data to create the ndarray with
    
    Returns:
    the ndarray with the given data layout
  - createComplex
```
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
```
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
```
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
  - concat
```
INDArray concat(int dimension,
              INDArray... toConcat)
```
    Concatneate ndarrays along a dimension
    
    Parameters:
    dimension - the dimension to concatneate along
    toConcat - the ndarrays to concateneate
    
    Returns:
    the concatneated ndarrays
  - concat
```
IComplexNDArray concat(int dimension,
                     IComplexNDArray... toConcat)
```
    Concatneate ndarrays along a dimension
    
    Parameters:
    dimension - the dimension to concatneate along
    toConcat - the ndarrays to concateneate
    
    Returns:
    the concatneated ndarrays
  - rand
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
INDArray randn(int[] shape)
```
    Random normal using the current time stamp as the seed
    
    Parameters:
    shape - the shape of the ndarray
    
    Returns:
  - randn
```
INDArray randn(int[] shape,
             long seed)
```
    Random normal using the specified seed
    
    Parameters:
    shape - the shape of the ndarray
    
    Returns:
  - create
```
INDArray create(double[] data)
```
    Creates a row vector with the data
    
    Parameters:
    data - the columns of the ndarray
    
    Returns:
    the created ndarray
  - create
```
INDArray create(float[] data)
```
    Creates a row vector with the data
    
    Parameters:
    data - the columns of the ndarray
    
    Returns:
    the created ndarray
  - createComplex
```
IComplexNDArray createComplex(double[] data)
```
    Creates an ndarray with the specified data
    
    Parameters:
    data - the number of columns in the row vector
    
    Returns:
    ndarray
  - create
```
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
```
IComplexNDArray createComplex(int columns)
```
    Creates an ndarray
    
    Parameters:
    columns - the number of columns in the row vector
    
    Returns:
    ndarray
  - zeros
```
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
```
IComplexNDArray 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
```
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
```
IComplexNDArray complexZeros(int columns)
```
    Creates an ndarray
    
    Parameters:
    columns - the number of columns in the row vector
    
    Returns:
    ndarray
  - valueArrayOf
```
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
```
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
```
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
```
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
```
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
```
IComplexNDArray complexOnes(int columns)
```
    Creates an ndarray
    
    Parameters:
    columns - the number of columns in the row vector
    
    Returns:
    ndarray
  - hstack
```
INDArray hstack(INDArray... arrs)
```
    Concatenates two matrices horizontally. Matrices must have identical numbers of rows.
    
    Parameters:
    arrs -
  - vstack
```
INDArray vstack(INDArray... arrs)
```
    Concatenates two matrices vertically. Matrices must have identical numbers of columns.
    
    Parameters:
    arrs -
  - zeros
```
INDArray zeros(int[] shape)
```
    Create an ndarray of zeros
    
    Parameters:
    shape - the shape of the ndarray
    
    Returns:
    an ndarray with ones filled in
  - complexZeros
```
IComplexNDArray complexZeros(int[] shape)
```
    Create an ndarray of ones
    
    Parameters:
    shape - the shape of the ndarray
    
    Returns:
    an ndarray with ones filled in
  - ones
```
INDArray ones(int[] shape)
```
    Create an ndarray of ones
    
    Parameters:
    shape - the shape of the ndarray
    
    Returns:
    an ndarray with ones filled in
  - complexOnes
```
IComplexNDArray complexOnes(int[] shape)
```
    Create an ndarray of ones
    
    Parameters:
    shape - the shape of the ndarray
    
    Returns:
    an ndarray with ones filled in
  - createComplex
```
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
```
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
```
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
  - createComplex
```
IComplexNDArray createComplex(IComplexNumber[] 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
  - createComplex
```
IComplexNDArray createComplex(IComplexNumber[] 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
  - createComplex
```
IComplexNDArray createComplex(IComplexNumber[] data,
                            int[] shape,
                            int[] stride,
                            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
    
    Returns:
    the instance
  - createComplex
```
IComplexNDArray createComplex(IComplexNumber[] data,
                            int[] shape,
                            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
    offset - the stride for the ndarray
    
    Returns:
    the instance
  - createComplex
```
IComplexNDArray createComplex(IComplexNumber[] data,
                            int[] shape,
                            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
    
    Returns:
    the instance
  - create
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
INDArray create(List<INDArray> list,
              int[] shape)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    shape - the shape of the ndarray
    
    Returns:
    the instance
  - create
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
IComplexNDArray createComplex(int[] shape)
```
    Creates a complex ndarray with the specified shape
    
    Parameters:
    shape - the shape of the ndarray
    
    Returns:
    the instance
  - create
```
INDArray create(int[] shape)
```
    Creates an ndarray with the specified shape
    
    Parameters:
    shape - the shape of the ndarray
    
    Returns:
    the instance
  - scalar
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
  - createComplex
```
IComplexNDArray createComplex(double[] data,
                            int[] shape,
                            int[] stride,
                            int offset,
                            char ordering)
```
    Create a complex ndarray with the given data
    
    Parameters:
    data - the data to use with tne ndarray
    shape - the shape of the ndarray
    stride - the stride for the ndarray
    offset - the offset of the ndarray
    ordering - the ordering for the ndarray
    
    Returns:
    the created complex ndarray
  - createComplex
```
IComplexNDArray createComplex(double[] data,
                            int[] shape,
                            int offset,
                            char ordering)
```
    Parameters:
    data -
    shape -
    offset -
    ordering -
    
    Returns:
  - createComplex
```
IComplexNDArray createComplex(double[] data,
                            int[] shape,
                            int offset)
```
    Parameters:
    data -
    shape -
    offset -
    
    Returns:
  - create
```
INDArray create(float[] data,
              int[] shape,
              int offset)
```
  - createComplex
```
IComplexNDArray createComplex(float[] data,
                            int[] shape,
                            int offset,
                            char ordering)
```
  - createComplex
```
IComplexNDArray createComplex(float[] data,
                            int[] shape,
                            int offset)
```
  - createComplex
```
IComplexNDArray createComplex(float[] data,
                            int[] shape,
                            int[] stride,
                            int offset,
                            char ordering)
```
  - create
```
INDArray create(float[][] floats)
```
  - createComplex
```
IComplexNDArray createComplex(float[] dim)
```
  - create
```
INDArray create(float[] data,
              int[] shape,
              int[] stride,
              int offset,
              char ordering)
```
  - complexFlatten
```
IComplexNDArray complexFlatten(List<IComplexNDArray> flatten)
```
  - complexFlatten
```
IComplexNDArray complexFlatten(IComplexNDArray[] flatten)
```

Interface NDArrayFactory

Field Summary

Method Summary

Field Detail

FORTRAN

C

Method Detail

complexValueOf

complexValueOf

complexValueOf

complexValueOf

setOrder

setDType

order

dtype

createComplex

linspace

toFlattened

toFlattened

bilinearProducts

toFlattened

eye

rot90

rot

reverse

arange

createFloat

createDouble

copy

rand

rand

appendBias

create

createComplex

createComplex

createComplex

concat

concat

rand

rand

rand

randn

randn

randn

rand

rand

rand

rand

randn

randn

randn

create

create

createComplex

create

createComplex

zeros

complexZeros

zeros

complexZeros

valueArrayOf

valueArrayOf

ones

complexOnes

ones

complexOnes

hstack

vstack

zeros

complexZeros

ones

complexOnes

createComplex

create

createComplex

createComplex

createComplex

createComplex

createComplex

createComplex