NDArrayFactory (nd4j-api 0.4-rc3.10 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

All Methods Instance Methods Abstract 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
`IComplexNDArray`	`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(DataBuffer data)` Creates a row vector with the data
`INDArray`	`create(DataBuffer data, int[] shape)` Create an ndrray with the specified shape
`INDArray`	`create(DataBuffer buffer, int[] shape, int offset)`
`INDArray`	`create(DataBuffer buffer, int[] shape, int[] stride, char order, int offset)`
`INDArray`	`create(DataBuffer data, int[] shape, int[] stride, int offset)` Creates an ndarray with the specified shape
`INDArray`	`create(DataBuffer data, int[] newShape, int[] newStride, int offset, char ordering)`
`INDArray`	`create(DataBuffer data, int rows, int columns, int[] stride, int offset)` Creates an ndarray with the specified shape
`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, char ordering)`
`INDArray`	`create(double[] data, char order)`
`INDArray`	`create(double[] data, int[] shape)` Create an ndrray with the specified shape
`INDArray`	`create(double[] data, int[] shape, char ordering)`
`INDArray`	`create(double[] data, int[] shape, int offset)`
`INDArray`	`create(double[] data, int[] shape, int[] stride, char order, int offset)`
`INDArray`	`create(double[] data, int[] shape, int[] stride, int offset)` Creates an ndarray with the specified shape
`INDArray`	`create(double[] data, int[] shape, int[] stride, int offset, char ordering)`
`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, char ordering)`
`INDArray`	`create(float[] data, char order)`
`INDArray`	`create(float[] data, int[] shape)` Create an ndrray with the specified shape
`INDArray`	`create(float[] data, int[] shape, char ordering)`
`INDArray`	`create(float[] data, int[] shape, int offset)`
`INDArray`	`create(float[] data, int[] shape, int[] stride, char order, 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[] shape, int offset, Character order)`
`INDArray`	`create(float[] data, int rows, int columns, int[] stride, int offset)`
`INDArray`	`create(float[] data, int rows, int columns, int[] stride, int offset, char ordering)`
`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, char ordering)`
`INDArray`	`create(int[] shape, DataBuffer.Type dataType)`
`INDArray`	`create(int[] shape, DataBuffer buffer)` Create an ndarray with the given shape and data
`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[] shape, int[] ints1, int[] stride, char order, int offset)`
`INDArray`	`create(int[] ints, int[] ints1, int[] stride, int offset)`
`INDArray`	`create(int[] shape, int[] stride, int offset, char ordering)`
`INDArray`	`create(int rows, int columns)` Creates an ndarray with the specified shape
`INDArray`	`create(int rows, int columns, char ordering)`
`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
`INDArray`	`create(List<INDArray> list, int[] shape, char ordering)`
`IComplexNDArray`	`createComplex(DataBuffer data)` Creates an ndarray with the specified data
`IComplexNDArray`	`createComplex(DataBuffer data, int[] shape)` Create an ndrray with the specified shape
`IComplexNDArray`	`createComplex(DataBuffer buffer, int[] shape, int offset)`
`IComplexNDArray`	`createComplex(DataBuffer data, int[] shape, int[] stride)` Create an ndrray with the specified shape
`IComplexNDArray`	`createComplex(DataBuffer data, int[] shape, int[] stride, int offset)` Creates a complex ndarray with the specified shape
`IComplexNDArray`	`createComplex(DataBuffer data, int[] newDims, int[] newStrides, int offset, char ordering)`
`IComplexNDArray`	`createComplex(DataBuffer buffer, int[] shape, int offset, char ordering)`
`IComplexNDArray`	`createComplex(DataBuffer data, int rows, int columns, int[] stride, int offset)` Creates a complex 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, Character order)`
`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)`
`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[] ints, int[] ints1, int[] stride, int offset)`
`IComplexNDArray`	`createComplex(int[] shape, int[] complexStrides, int offset, char ordering)`
`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
`void`	`createLapack()` Create lapack
`void`	`createLevel1()` Create level 1
`void`	`createLevel2()` Create level 2
`void`	`createLevel3()` Create level 3
`INDArray`	`createUninitialized(int[] shape, char ordering)`
`DataBuffer.Type`	`dtype()` Returns the data type for this ndarray
`INDArray`	`eye(int n)` Create the identity ndarray
`INDArray`	`hstack(INDArray... arrs)` Concatenates two matrices horizontally.
`Lapack`	`lapack()`
`Level1`	`level1()` Return the level 1 blas operations
`Level2`	`level2()` Return the level 2 blas operations
`Level3`	`level3()` Return the level 3 blas operations
`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(char order, int[] shape)` Create a random ndarray with the given shape, and specified output order
`INDArray`	`rand(char order, int rows, int columns)` Create a random (uniform 0-1) NDArray with the specified shape and order
`INDArray`	`rand(int[] shape)` Create a random ndarray with the given shape using the current time as the seed
`INDArray`	`rand(int[] shape, Distribution r)` Create a random ndarray with the given shape using the given rng
`INDArray`	`rand(int[] shape, double min, double max, Random rng)`
`INDArray`	`rand(int[] shape, float min, float max, Random 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, Random 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, double min, double max, Random rng)`
`INDArray`	`rand(int rows, int columns, float min, float max, Random 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, Random r)` Create a random ndarray with the given shape using the given rng
`INDArray`	`randn(char order, int[] shape)` Random normal N(0,1) with the specified shape and order
`INDArray`	`randn(char order, int rows, int columns)` Random normal N(0,1), with specified output order
`INDArray`	`randn(int[] shape)` Random normal N(0,1) using the current time stamp as the seed
`INDArray`	`randn(int[] shape, long seed)` Random normal using the specified seed
`INDArray`	`randn(int[] shape, Random r)` Random normal using the given rng
`INDArray`	`randn(int rows, int columns)` Random normal (N(0,1)) 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, Random 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(int value, int 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(DataBuffer.Type dtype)` Sets the data type
`void`	`setOrder(char order)` Sets the order.
`INDArray`	`toFlattened(char order, Collection<INDArray> matrices)` Returns a flattened ndarray with all elements in each ndarray regardless of dimension.
`INDArray`	`toFlattened(char order, INDArray... matrices)` Flatten all of the ndarrays in to one long vector
`INDArray`	`toFlattened(Collection<INDArray> matrices)` /** Returns a flattened ndarray with all of the elements in each ndarray regardless of dimension
`INDArray`	`toFlattened(INDArray... matrices)` Flatten all of the ndarrays in to one long vector
`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
  - lapack
```
Lapack lapack()
```
  - level1
```
Level1 level1()
```
    Return the level 1 blas operations
    
    Returns:
  - level2
```
Level2 level2()
```
    Return the level 2 blas operations
    
    Returns:
  - level3
```
Level3 level3()
```
    Return the level 3 blas operations
    
    Returns:
  - createLevel1
```
void createLevel1()
```
    Create level 1
  - createLevel2
```
void createLevel2()
```
    Create level 2
  - createLevel3
```
void createLevel3()
```
    Create level 3
  - createLapack
```
void createLapack()
```
    Create lapack
  - 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(DataBuffer.Type dtype)
```
    Sets the data type
    
    Parameters:
    
    dtype -
  - create
```
INDArray create(int[] shape,
                DataBuffer buffer)
```
    Create an ndarray with the given shape and data
    
    Parameters:
    
    shape - the shape to use
    
    buffer - the buffer to use
    
    Returns:
    
    the ndarray
  - order
```
char order()
```
    Returns the order for this ndarray for internal data storage
    
    Returns:
    
    the order (c or f)
  - dtype
```
DataBuffer.Type 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
  - toFlattened
```
INDArray toFlattened(char order,
                     Collection<INDArray> matrices)
```
    Returns a flattened ndarray with all elements in each ndarray regardless of dimension. Order is specified to ensure flattening order is consistent across
    
    Parameters:
    
    matrices - the ndarrays to flatten
    
    order - the order in which the ndarray values should be flattened
    
    Returns:
  - 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)
```
    Flatten all of the ndarrays in to one long vector
    
    Parameters:
    
    matrices - the matrices to flatten
    
    Returns:
    
    the flattened vector
  - toFlattened
```
INDArray toFlattened(char order,
                     INDArray... matrices)
```
    Flatten all of the ndarrays in to one long vector
    
    Parameters:
    
    matrices - the matrices to flatten
    
    Returns:
    
    the flattened vector
  - 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,
              Random rng)
```
    Generates a random matrix between min and max
    
    Parameters:
    
    shape - the number of rows of the matrix
    
    min - the minimum number
    
    max - the maximum number
    
    rng - the rng to use
    
    Returns:
    
    a drandom matrix of the specified shape and range
  - rand
```
INDArray rand(int rows,
              int columns,
              float min,
              float max,
              Random rng)
```
    Generates a random matrix between min and max
    
    Parameters:
    
    rows - the number of rows of the matrix
    
    columns - the number of columns in the matrix
    
    min - the minimum number
    
    max - the maximum number
    
    rng - the rng to use
    
    Returns:
    
    a drandom matrix of the specified shape and range
  - 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
  - create
```
INDArray create(double[][] data,
                char ordering)
```
  - 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,
              Random 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
  - rand
```
INDArray rand(char order,
              int rows,
              int columns)
```
    Create a random (uniform 0-1) NDArray with the specified shape and order
    
    Parameters:
    
    order - Order ('c' or 'f') of the output array
    
    rows - Number of rows of the output array
    
    columns - Number of columns of the output array
  - randn
```
INDArray randn(int rows,
               int columns,
               Random r)
```
    Random normal using the given rng
    
    Parameters:
    
    rows - the number of rows in the matrix
    
    columns - the number of columns in the matrix
    
    r - the random generator to use
    
    Returns:
  - randn
```
INDArray randn(int rows,
               int columns)
```
    Random normal (N(0,1)) 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(char order,
               int rows,
               int columns)
```
    Random normal N(0,1), with specified output order
    
    Parameters:
    
    rows - the number of rows in the matrix
    
    columns - the number of columns in the matrix
  - 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,
              Distribution 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,
              Random 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
  - rand
```
INDArray rand(char order,
              int[] shape)
```
    Create a random ndarray with the given shape, and specified output order
    
    Parameters:
    
    shape - the shape of the ndarray
    
    Returns:
    
    the random ndarray with the specified shape
  - randn
```
INDArray randn(int[] shape,
               Random r)
```
    Random normal using the given rng
    
    Parameters:
    
    shape - the shape of the ndarray
    
    r - the random generator to use
  - randn
```
INDArray randn(int[] shape)
```
    Random normal N(0,1) using the current time stamp as the seed
    
    Parameters:
    
    shape - the shape of the ndarray
  - randn
```
INDArray randn(char order,
               int[] shape)
```
    Random normal N(0,1) with the specified shape and order
    
    Parameters:
    
    order - the order ('c' or 'f') of the output array
    
    shape - the shape of the ndarray
  - 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(DataBuffer data)
```
    Creates a row vector with the data
    
    Parameters:
    
    data - the columns of the ndarray
    
    Returns:
    
    the created ndarray
  - createComplex
```
IComplexNDArray createComplex(DataBuffer 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
```
IComplexNDArray complexOnes(int rows,
                            int columns)
```
    Creates an ndarray
    
    Parameters:
    
    rows - the number of rows in the matrix
    
    columns - the number of columns in the row vector
    
    Returns:
    
    ndarray
  - ones
```
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
  - createComplex
```
IComplexNDArray createComplex(DataBuffer 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(DataBuffer 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(DataBuffer 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
```
INDArray create(float[] data,
                int rows,
                int columns,
                int[] stride,
                int offset)
```
    Parameters:
    
    data -
    
    rows -
    
    columns -
    
    stride -
    
    offset -
    
    Returns:
  - 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(DataBuffer 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(DataBuffer 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(DataBuffer 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
  - create
```
INDArray create(DataBuffer 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(int value,
                int offset)
```
  - 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(DataBuffer buffer,
                              int[] shape,
                              int offset,
                              char ordering)
```
  - createComplex
```
IComplexNDArray createComplex(double[] data,
                              int[] shape,
                              int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    offset -
    
    Returns:
  - createComplex
```
IComplexNDArray createComplex(DataBuffer buffer,
                              int[] shape,
                              int offset)
```
    Parameters:
    
    buffer -
    
    shape -
    
    offset -
    
    Returns:
  - create
```
INDArray create(float[] data,
                int[] shape,
                int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    offset -
    
    Returns:
  - create
```
INDArray create(float[] data,
                int[] shape,
                char ordering)
```
    Parameters:
    
    data -
    
    shape -
    
    ordering -
    
    Returns:
  - createComplex
```
IComplexNDArray createComplex(float[] data,
                              int[] shape,
                              int offset,
                              char ordering)
```
    Parameters:
    
    data -
    
    shape -
    
    offset -
    
    ordering -
    
    Returns:
  - createComplex
```
IComplexNDArray createComplex(float[] data,
                              int[] shape,
                              int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    offset -
    
    Returns:
  - createComplex
```
IComplexNDArray createComplex(float[] data,
                              int[] shape,
                              int[] stride,
                              int offset,
                              char ordering)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
    
    offset -
    
    ordering -
    
    Returns:
  - create
```
INDArray create(float[][] floats)
```
    Parameters:
    
    floats -
    
    Returns:
  - create
```
INDArray create(float[][] data,
                char ordering)
```
  - createComplex
```
IComplexNDArray createComplex(float[] dim)
```
    Parameters:
    
    dim -
    
    Returns:
  - create
```
INDArray create(float[] data,
                int[] shape,
                int[] stride,
                int offset,
                char ordering)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
    
    offset -
    
    ordering -
    
    Returns:
  - complexFlatten
```
IComplexNDArray complexFlatten(List<IComplexNDArray> flatten)
```
    Parameters:
    
    flatten -
    
    Returns:
  - complexFlatten
```
IComplexNDArray complexFlatten(IComplexNDArray[] flatten)
```
    Parameters:
    
    flatten -
    
    Returns:
  - create
```
INDArray create(DataBuffer buffer,
                int[] shape,
                int offset)
```
    Parameters:
    
    buffer -
    
    shape -
    
    offset -
    
    Returns:
  - createComplex
```
IComplexNDArray createComplex(float[] data,
                              int[] shape,
                              int[] stride,
                              int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
    
    offset -
    
    Returns:
  - create
```
INDArray create(int[] shape,
                char ordering)
```
    Parameters:
    
    shape -
    
    ordering -
    
    Returns:
  - createUninitialized
```
INDArray createUninitialized(int[] shape,
                             char ordering)
```
  - create
```
INDArray create(DataBuffer data,
                int[] newShape,
                int[] newStride,
                int offset,
                char ordering)
```
    Parameters:
    
    data -
    
    newShape -
    
    newStride -
    
    offset -
    
    ordering -
    
    Returns:
  - createComplex
```
IComplexNDArray createComplex(DataBuffer data,
                              int[] newDims,
                              int[] newStrides,
                              int offset,
                              char ordering)
```
    Parameters:
    
    data -
    
    newDims -
    
    newStrides -
    
    offset -
    
    ordering -
    
    Returns:
  - rand
```
INDArray rand(int rows,
              int columns,
              double min,
              double max,
              Random rng)
```
    Parameters:
    
    rows -
    
    columns -
    
    min -
    
    max -
    
    rng -
    
    Returns:
  - createComplex
```
IComplexNDArray createComplex(float[] data,
                              Character order)
```
    Parameters:
    
    data -
    
    order -
    
    Returns:
  - create
```
INDArray create(float[] data,
                int[] shape,
                int offset,
                Character order)
```
    Parameters:
    
    data -
    
    shape -
    
    offset -
    
    order -
    
    Returns:
  - create
```
INDArray create(float[] data,
                int rows,
                int columns,
                int[] stride,
                int offset,
                char ordering)
```
    Parameters:
    
    data -
    
    rows -
    
    columns -
    
    stride -
    
    offset -
    
    ordering -
    
    Returns:
  - create
```
INDArray create(double[] data,
                int[] shape,
                char ordering)
```
    Parameters:
    
    data -
    
    shape -
    
    ordering -
    
    Returns:
  - create
```
INDArray create(List<INDArray> list,
                int[] shape,
                char ordering)
```
    Parameters:
    
    list -
    
    shape -
    
    ordering -
    
    Returns:
  - create
```
INDArray create(double[] data,
                int[] shape,
                int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    offset -
    
    Returns:
  - create
```
INDArray create(double[] data,
                int[] shape,
                int[] stride,
                int offset,
                char ordering)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
    
    offset -
    
    ordering -
    
    Returns:
  - rand
```
INDArray rand(int[] shape,
              double min,
              double max,
              Random rng)
```
    Parameters:
    
    shape -
    
    min -
    
    max -
    
    rng -
    
    Returns:
  - createComplex
```
IComplexNDArray createComplex(int[] ints,
                              int[] ints1,
                              int[] stride,
                              int offset)
```
    Parameters:
    
    ints -
    
    ints1 -
    
    stride -
    
    offset -
    
    Returns:
  - create
```
INDArray create(int[] ints,
                int[] ints1,
                int[] stride,
                int offset)
```
    Parameters:
    
    ints -
    
    ints1 -
    
    stride -
    
    offset -
    
    Returns:
  - create
```
INDArray create(int[] shape,
                int[] ints1,
                int[] stride,
                char order,
                int offset)
```
    Parameters:
    
    shape -
    
    ints1 -
    
    stride -
    
    order -
    
    offset -
    
    Returns:
  - create
```
INDArray create(int rows,
                int columns,
                char ordering)
```
    Parameters:
    
    rows -
    
    columns -
    
    ordering -
    
    Returns:
  - create
```
INDArray create(int[] shape,
                DataBuffer.Type dataType)
```
    Parameters:
    
    shape -
    
    dataType -
    
    Returns:
  - create
```
INDArray create(float[] data,
                char order)
```
    Parameters:
    
    data -
    
    order -
    
    Returns:
  - create
```
INDArray create(float[] data,
                int[] shape,
                int[] stride,
                char order,
                int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
    
    order -
    
    offset -
    
    Returns:
  - create
```
INDArray create(DataBuffer buffer,
                int[] shape,
                int[] stride,
                char order,
                int offset)
```
    Parameters:
    
    buffer -
    
    shape -
    
    stride -
    
    order -
    
    offset -
    
    Returns:
  - create
```
INDArray create(double[] data,
                char order)
```
    Parameters:
    
    data -
    
    order -
    
    Returns:
  - create
```
INDArray create(double[] data,
                int[] shape,
                int[] stride,
                char order,
                int offset)
```
    Parameters:
    
    data -
    
    shape -
    
    stride -
    
    order -
    
    offset -
    
    Returns:
  - create
```
INDArray create(int[] shape,
                int[] stride,
                int offset,
                char ordering)
```
    Parameters:
    
    shape -
    
    stride -
    
    offset -
    
    ordering -
    
    Returns:
  - createComplex
```
IComplexNDArray createComplex(int[] shape,
                              int[] complexStrides,
                              int offset,
                              char ordering)
```
    Parameters:
    
    shape -
    
    complexStrides -
    
    offset -
    
    ordering -
    
    Returns:

Interface NDArrayFactory

Field Summary

Method Summary

Field Detail

FORTRAN

C

Method Detail

lapack

level1

level2

level3

createLevel1

createLevel2

createLevel3

createLapack

complexValueOf

complexValueOf

complexValueOf

complexValueOf

setOrder

setDType

create

order

dtype

createComplex

linspace

toFlattened

toFlattened

toFlattened

bilinearProducts

toFlattened

toFlattened

eye

rot90

rot

reverse

arange

createFloat

createDouble

copy

rand

rand

appendBias

create

create

createComplex

createComplex

createComplex

concat

concat

rand

rand

rand

rand

randn

randn

randn

randn

rand

rand

rand

rand

rand

randn

randn

randn

randn

create

create

createComplex

create

createComplex

create

createComplex

zeros

complexZeros

zeros

complexZeros

valueArrayOf

valueArrayOf