public abstract class BaseNDArray extends Object implements INDArray, Iterable
Modifier and Type | Field and Description |
---|---|
protected boolean |
attemptedToFindElementWiseStride |
protected boolean |
cleanedUp |
protected int |
columns |
protected boolean |
compressed |
protected DataBuffer |
data |
protected Boolean |
isMatrix |
protected Boolean |
isScalar |
protected Boolean |
isVector |
protected boolean |
isWrapAround |
protected long |
length |
protected int |
linearStride |
protected static org.slf4j.Logger |
log |
protected int |
numLeadingOnes |
protected int |
numTrailingOnes |
protected int |
rank |
protected int |
rows |
protected DataBuffer |
shape |
protected DataBuffer |
shapeInformation |
protected DataBuffer |
stride |
Constructor and Description |
---|
BaseNDArray() |
BaseNDArray(DataBuffer buffer) |
BaseNDArray(DataBuffer floatBuffer,
char order) |
BaseNDArray(DataBuffer data,
int[] shape) |
BaseNDArray(DataBuffer buffer,
int[] shape,
char ordering) |
BaseNDArray(DataBuffer buffer,
int[] shape,
int offset) |
BaseNDArray(DataBuffer buffer,
int[] shape,
int[] strides) |
BaseNDArray(DataBuffer data,
int[] shape,
int[] stride,
int offset) |
BaseNDArray(DataBuffer buffer,
int[] shape,
int[] stride,
int offset,
char ordering) |
BaseNDArray(DataBuffer buffer,
int[] shape,
int offset,
char ordering)
Constructor for stride and offset
|
BaseNDArray(double[][] data)
Initialize the ndarray as a matrix
with the given data (indices preserved)
|
BaseNDArray(double[][] data,
char ordering) |
BaseNDArray(double[] data,
int[] shape,
char ordering) |
BaseNDArray(double[] data,
int[] shape,
int[] stride,
int offset) |
BaseNDArray(double[] data,
int[] shape,
int[] stride,
int offset,
char ordering) |
BaseNDArray(float[] data) |
BaseNDArray(float[][] data)
Initialize the ndarray
with the given data
|
BaseNDArray(float[][] data,
char ordering) |
BaseNDArray(float[] data,
char order) |
BaseNDArray(float[] data,
int[] shape)
Create this ndarray with the given data and shape and 0 offset
|
BaseNDArray(float[] data,
int[] shape,
char ordering)
Create this ndarray with the given data and shape and 0 offset
|
BaseNDArray(float[] data,
int[] shape,
int offset) |
BaseNDArray(float[] data,
int[] shape,
int[] stride) |
BaseNDArray(float[] data,
int[] shape,
int[] stride,
char ordering) |
BaseNDArray(float[] data,
int[] shape,
int[] stride,
int offset) |
BaseNDArray(float[] data,
int[] shape,
int[] stride,
int offset,
char ordering) |
BaseNDArray(float[] data,
int[] shape,
int offset,
char ordering) |
BaseNDArray(int[] shape)
Create an ndarray
with the given shape
|
BaseNDArray(int[] shape,
char ordering) |
BaseNDArray(int[] shape,
DataBuffer buffer)
Create with the specified shape and buffer
|
BaseNDArray(int[] shape,
int offset) |
BaseNDArray(int[] shape,
int[] stride)
Create the ndarray with
the specified shape and stride and an offset of 0
|
BaseNDArray(int[] shape,
int[] stride,
char ordering)
Create the ndarray with
the specified shape and stride and an offset of 0
|
BaseNDArray(int[] shape,
int[] stride,
int offset)
Construct an ndarray of the specified shape
with an empty data array
|
BaseNDArray(int[] data,
int[] shape,
int[] strides) |
BaseNDArray(int[] shape,
int[] stride,
int offset,
char ordering)
Construct an ndarray of the specified shape
with an empty data array
|
BaseNDArray(int[] shape,
int[] stride,
int offset,
char ordering,
boolean initialize)
Construct an ndarray of the specified shape.
|
BaseNDArray(int[] shape,
int offset,
char ordering) |
BaseNDArray(int newRows,
int newColumns)
Creates a new n times m DoubleMatrix.
|
BaseNDArray(int newRows,
int newColumns,
char ordering)
Creates a new n times m DoubleMatrix.
|
BaseNDArray(List<INDArray> slices,
int[] shape)
Create an ndarray from the specified slices.
|
BaseNDArray(List<INDArray> slices,
int[] shape,
char ordering)
Create an ndarray from the specified slices.
|
BaseNDArray(List<INDArray> slices,
int[] shape,
int[] stride)
Create an ndarray from the specified slices.
|
BaseNDArray(List<INDArray> slices,
int[] shape,
int[] stride,
char ordering)
Create an ndarray from the specified slices.
|
Modifier and Type | Method and Description |
---|---|
IComplexNDArray |
add(IComplexNumber n) |
IComplexNDArray |
add(IComplexNumber n,
IComplexNDArray result) |
INDArray |
add(INDArray other)
copy addition of two matrices
|
INDArray |
add(INDArray other,
INDArray result)
copy addition of two matrices
|
INDArray |
add(Number n)
Scalar addition (cloning)
|
INDArray |
add(Number n,
INDArray result) |
INDArray |
addColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
addi(IComplexNumber n) |
IComplexNDArray |
addi(IComplexNumber n,
IComplexNDArray result) |
INDArray |
addi(INDArray other)
in place addition of two matrices
|
INDArray |
addi(INDArray other,
INDArray result)
in place addition of two matrices
|
INDArray |
addi(Number n)
In place scalar addition
|
INDArray |
addi(Number n,
INDArray result)
In place addition
|
INDArray |
addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
addiRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
addRowVector(INDArray rowVector)
In place addition of a column vector
|
protected void |
assertSlice(INDArray put,
int slice) |
INDArray |
assign(INDArray arr)
Assign all of the elements in the given
ndarray to this ndarray
|
INDArray |
assign(Number value)
Set the value of the ndarray to the specified value
|
INDArray |
assignIf(INDArray arr,
Condition condition)
Assign all elements from given ndarray that are matching given condition,
ndarray to this ndarray
|
INDArray |
broadcast(int... shape)
Broadcasts this ndarray to be the specified shape
|
protected void |
checkArrangeArray(int[] arr) |
void |
checkDimensions(INDArray other)
Validate dimensions are equal
|
void |
cleanup()
Cleanup resources
|
int |
columns()
Number of columns (shape[1]), throws an exception when
called when not 2d
|
INDArray |
cond(Condition condition)
1 in the ndarray if the element matches
the condition 0 otherwise
|
INDArray |
condi(Condition condition)
1 in the ndarray if the element matches
the condition 0 otherwise
|
protected void |
copyRealTo(INDArray arr) |
protected INDArray |
create(BaseNDArray baseNDArray) |
protected INDArray |
create(DataBuffer buffer) |
protected INDArray |
create(DataBuffer data,
int[] shape,
int offset) |
protected INDArray |
create(DataBuffer data,
int[] shape,
int[] strides) |
protected INDArray |
create(DataBuffer data,
int[] newShape,
int[] newStrides,
int offset) |
protected INDArray |
create(DataBuffer data,
int[] newShape,
int[] newStrides,
int offset,
char ordering) |
protected INDArray |
create(int[] shape) |
protected INDArray |
create(int[] shape,
char ordering) |
protected INDArray |
create(int[] shape,
int[] strides,
int offset) |
protected INDArray |
create(int rows,
int length) |
protected INDArray |
createScalar(double d) |
protected INDArray |
createScalarForIndex(int i,
boolean applyOffset) |
INDArray |
cumsum(int dimension)
Cumulative sum along a dimension (in place)
|
INDArray |
cumsumi(int dimension)
Cumulative sum along a dimension
|
DataBuffer |
data()
Returns a linear double array representation of this ndarray
|
INDArray |
dimShuffle(Object[] rearrange,
int[] newOrder,
boolean[] broadCastable)
Dimshuffle: an extension of permute that adds the ability
to broadcast various dimensions.
|
double |
distance1(INDArray other)
Returns the (1-norm) distance.
|
double |
distance2(INDArray other)
Returns the (euclidean) distance.
|
IComplexNDArray |
div(IComplexNumber n) |
IComplexNDArray |
div(IComplexNumber n,
IComplexNDArray result) |
INDArray |
div(INDArray other)
in place (element wise) division of two matrices
|
INDArray |
div(INDArray other,
INDArray result)
copy (element wise) division of two matrices
|
INDArray |
div(Number n)
Division by a number
|
INDArray |
div(Number n,
INDArray result) |
INDArray |
divColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
divi(IComplexNumber n) |
IComplexNDArray |
divi(IComplexNumber n,
IComplexNDArray result) |
INDArray |
divi(INDArray other)
in place (element wise) division of two matrices
|
INDArray |
divi(INDArray other,
INDArray result)
in place (element wise) division of two matrices
|
INDArray |
divi(Number n)
In place scalar division
|
INDArray |
divi(Number n,
INDArray result)
In place division of this ndarray
|
INDArray |
diviColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
diviRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
divRowVector(INDArray rowVector)
In place addition of a column vector
|
protected INDArray |
doColumnWise(INDArray columnVector,
char operation)
Do a row wise op (a,s,m,d)
a : add
s : subtract
m : multiply
d : divide
h : reverse subtraction
t : reverse division
|
protected int[] |
doPermuteSwap(DataBuffer shape,
int[] rearrange) |
protected int[] |
doPermuteSwap(IntBuffer shape,
int[] rearrange) |
protected INDArray |
doRowWise(INDArray rowVector,
char operation)
Do a row wise op (a,s,m,d)
a : add
s : subtract
m : multiply
d : divide
h : reverse subtraction
t : reverse division
|
INDArray |
dup()
Return a copy of this ndarray
|
INDArray |
dup(char order)
Return a copy of this ndarray, where the returned ndarray has the specified order
|
Object |
element()
Returns a scalar (individual element)
of a scalar ndarray
|
int |
elementStride()
Element stride (one element to the next,
also called the defualt stride: 1 for normal
2 for complex)
|
int |
elementWiseStride()
Element wise stride
|
INDArray |
eps(INDArray other)
epsilon equals than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
eps(Number other)
Returns an ndarray with 1 if the element is epsilon equals
|
INDArray |
epsi(INDArray other)
In place epsilon equals than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
epsi(Number other)
Returns an ndarray with 1 if the element is epsilon equals
|
INDArray |
eq(INDArray other)
equal than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
eq(Number other)
Returns an ndarray with 1 if the element is less than
the given element 0 other wise
|
INDArray |
eqi(INDArray other)
In place equal than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
eqi(Number other)
In place less than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
boolean |
equals(Object o)
Compare two matrices.
|
boolean |
equalsWithEps(Object o,
double eps)
This method allows you to compare INDArray against other INDArray, with variable eps
|
INDArray |
get(INDArrayIndex... indexes)
Returns a subset of this array based on the specified
indexes
|
INDArray |
getColumn(int c)
Get the specified column
|
INDArray |
getColumns(int... cindices)
Get whole columns
from the passed indices.
|
double |
getDouble(int... indices)
Returns the elements at the the specified indices
|
double |
getDouble(int i) |
double |
getDouble(int i,
int j) |
double |
getDoubleUnsafe(int offset)
Get a scalar
at the given linear offset
|
float |
getFloat(int... indices)
Returns the elements at the the specified indices
|
float |
getFloat(int i)
Return the item at the linear index i
|
float |
getFloat(int i,
int j)
Return the item at row i column j
Note that this is the same as calling getScalar(new int[]{i,j}
|
int |
getInt(int... indices)
Returns the elements at the the specified indices
|
int |
getLeadingOnes() |
INDArray |
getRow(int r)
Get a copy of a row.
|
INDArray |
getRows(int[] rindices)
Get whole rows from the passed indices.
|
INDArray |
getScalar(int... indexes)
Fetch a particular number on a multi dimensional scale.
|
INDArray |
getScalar(int i)
Returns the element at the specified index
|
INDArray |
getScalar(int row,
int column)
Returns the element at the specified row/column
This will throw an exception if the
|
protected int[] |
getStrides(int[] shape,
char ordering) |
int |
getTrailingOnes() |
INDArray |
gt(INDArray other)
greater than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
gt(Number other)
Greater than boolean (copying)(
|
INDArray |
gti(INDArray other)
In place greater than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
gti(Number other)
In place greater than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
int |
index(int row,
int column)
Return the linear index of the specified row and column
|
protected void |
init(int[] shape,
int[] stride) |
int |
innerMostStride()
Get the inner most stride
wrt the ordering of the array
|
boolean |
isCleanedUp()
Returns true if the ndarray has already been freed
|
boolean |
isColumnVector()
Checks whether the matrix is a column vector.
|
boolean |
isCompressed()
Returns true if this array is compressed, and false otherwise
|
boolean |
isMatrix()
Returns true if this ndarray is 2d
or 3d with a singleton element
|
boolean |
isRowVector()
Checks whether the matrix is a row vector.
|
boolean |
isScalar()
Test whether a matrix is scalar.
|
boolean |
isSquare()
Returns whether the matrix
has the same rows and columns
|
boolean |
isValid()
Returns whether the ndarray is valid or not
|
boolean |
isVector()
Checks whether the matrix is a vector.
|
boolean |
isView()
Returns true if this array is a view or not
|
boolean |
isWrapAround()
Returns true if the ndarray
on linear indexing wraps around
based on the stride(1) of the ndarray
This is a useful optimization in linear view
where strides that might otherwise
go out of bounds but wrap around instead.
|
Iterator<Object> |
iterator() |
int |
length()
Returns the total number of elements in the ndarray
|
long |
lengthLong()
Returns the total number of elements in the ndarray
|
int |
linearIndex(int i)
Get the linear index of the data in to
the array
|
INDArray |
linearView()
Returns a linear view reference of shape
1,length(ndarray)
|
INDArray |
linearViewColumnOrder()
Returns a linear view reference of shape
1,length(ndarray)
|
INDArray |
lt(INDArray other)
less than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
lt(Number other)
Returns an ndarray with 1 if the element is less than
the given element 0 other wise
|
INDArray |
lti(INDArray other)
In place less than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
lti(Number other)
In place less than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
int |
majorStride()
Return the major stride for an ndarray
|
void |
markAsCompressed(boolean reallyCompressed)
This method marks INDArray instance as compressed
PLEASE NOTE: Do not use this method unless you 100% have to
|
INDArray |
max(int... dimension)
Returns the overall max of this ndarray
|
IComplexNumber |
maxComplex() |
Number |
maxNumber() |
INDArray |
mean(int... dimension)
Returns the overall mean of this ndarray
|
IComplexNumber |
meanComplex() |
Number |
meanNumber() |
INDArray |
min(int... dimension)
Returns the overall min of this ndarray
|
IComplexNumber |
minComplex() |
Number |
minNumber() |
INDArray |
mmul(INDArray other)
Perform a copy matrix multiplication
|
INDArray |
mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
mmuli(INDArray other)
Perform an copy matrix multiplication
|
INDArray |
mmuli(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
IComplexNDArray |
mul(IComplexNumber n) |
IComplexNDArray |
mul(IComplexNumber n,
IComplexNDArray result) |
INDArray |
mul(INDArray other)
copy (element wise) multiplication of two matrices
|
INDArray |
mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two matrices
|
INDArray |
mul(Number n)
Scalar multiplication (copy)
|
INDArray |
mul(Number n,
INDArray result) |
INDArray |
mulColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
muli(IComplexNumber n) |
IComplexNDArray |
muli(IComplexNumber n,
IComplexNDArray result) |
INDArray |
muli(INDArray other)
in place (element wise) multiplication of two matrices
|
INDArray |
muli(INDArray other,
INDArray result)
in place (element wise) multiplication of two matrices
|
INDArray |
muli(Number n)
In place scalar multiplication
|
INDArray |
muli(Number n,
INDArray result)
In place multiplication of this ndarray
|
INDArray |
muliColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
muliRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
mulRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
neg()
Negate each element.
|
INDArray |
negi()
Negate each element (in-place).
|
INDArray |
neq(INDArray other) |
INDArray |
neq(Number other)
Not equal
|
INDArray |
neqi(INDArray other) |
INDArray |
neqi(Number other)
In place not equal
|
protected INDArray |
newShape(int[] newShape,
char ordering) |
INDArray |
norm1(int... dimension)
Returns the norm1 along the specified dimension
|
IComplexNumber |
norm1Complex() |
Number |
norm1Number() |
INDArray |
norm2(int... dimension)
Returns the norm2 along the specified dimension
|
IComplexNumber |
norm2Complex() |
Number |
norm2Number() |
INDArray |
normmax(int... dimension)
Returns the normmax along the specified dimension
|
IComplexNumber |
normmaxComplex() |
Number |
normmaxNumber() |
int |
offset()
Returns the start of where the ndarray is
for the underlying data
|
char |
ordering()
Return the ordering (fortran or c)
of this ndarray
|
int |
originalOffset()
Returns the start of where the ndarray is for the original data buffer
|
INDArray |
permute(int... rearrange)
See: http://www.mathworks.com/help/matlab/ref/permute.html
|
INDArray |
permutei(int... rearrange)
An in-place version of permute.
|
INDArray |
prod(int... dimension)
Returns the product along a given dimension
|
IComplexNumber |
prodComplex() |
Number |
prodNumber() |
INDArray |
put(INDArrayIndex[] indices,
INDArray element)
Put the elements of the ndarray
in to the specified indices
|
INDArray |
put(INDArrayIndex[] indices,
Number element)
Put the elements of the ndarray
in to the specified indices
|
INDArray |
put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
INDArray |
put(int i,
INDArray element)
Inserts the element at the specified index
|
INDArray |
put(int i,
int j,
INDArray element)
Inserts the element at the specified index
|
INDArray |
put(int i,
int j,
Number element)
Inserts the element at the specified index
|
INDArray |
putColumn(int column,
INDArray toPut)
Insert a column in to this array
Will throw an exception if this
ndarray is not a matrix
|
INDArray |
putRow(int row,
INDArray toPut)
Insert a row in to this array
Will throw an exception if this
ndarray is not a matrix
|
INDArray |
putScalar(int[] indexes,
double value)
Insert the item at the specified indices
|
INDArray |
putScalar(int[] indexes,
float value) |
INDArray |
putScalar(int[] indexes,
int value) |
INDArray |
putScalar(int i,
double value)
Insert the number linearly in to the ndarray
|
INDArray |
putScalar(int i,
float value)
Insert a scalar float at the specified index
|
INDArray |
putScalar(int i,
int value)
Insert a scalar int at the specified index
|
INDArray |
putScalar(int row,
int col,
double value)
Insert the value at the specified indices, in a 2d (rank 2) NDArray
Equivalent to INDArray.putScalar(int[], double) but avoids int[] creation |
INDArray |
putScalar(int dim0,
int dim1,
int dim2,
double value)
Insert the value at the specified indices, in a 3d (rank 3) NDArray
Equivalent to INDArray.putScalar(int[], double) but avoids int[] creation |
INDArray |
putScalar(int dim0,
int dim1,
int dim2,
int dim3,
double value)
Insert the value at the specified indices, in a 4d (rank 4) NDArray
Equivalent to INDArray.putScalar(int[], double) but avoids int[] creation |
INDArray |
putScalarUnsafe(int offset,
double value)
Insert a scalar
at the given linear offset
|
INDArray |
putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
int |
rank()
The rank of the ndarray (the number of dimensions
|
INDArray |
ravel()
Flattens the array for linear indexing
|
INDArray |
ravel(char ordering)
Flattens the array for linear indexing
|
IComplexNDArray |
rdiv(IComplexNumber n) |
IComplexNDArray |
rdiv(IComplexNumber n,
IComplexNDArray result) |
INDArray |
rdiv(INDArray other)
Reverse division
|
INDArray |
rdiv(INDArray other,
INDArray result)
Reverse division
|
INDArray |
rdiv(Number n)
Reverse division
|
INDArray |
rdiv(Number n,
INDArray result)
Reverse division (number / ndarray)
|
INDArray |
rdivColumnVector(INDArray columnVector)
Reverse division of a column vector (copy)
|
IComplexNDArray |
rdivi(IComplexNumber n) |
IComplexNDArray |
rdivi(IComplexNumber n,
IComplexNDArray result) |
INDArray |
rdivi(INDArray other)
Reverse divsion (in place)
|
INDArray |
rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
INDArray |
rdivi(Number n)
In place reverse division
|
INDArray |
rdivi(Number n,
INDArray result)
Reverse in place division
|
INDArray |
rdiviColumnVector(INDArray columnVector)
In place reverse divison of a column vector
|
INDArray |
rdiviRowVector(INDArray rowVector)
In place reverse division of a column vector
|
INDArray |
rdivRowVector(INDArray rowVector)
Reverse division of a column vector (copy)
|
protected void |
read(ObjectInputStream s) |
INDArray |
repeat(int... repeats)
Returns a flat array
with the elements repeated k times along each given dimension
|
INDArray |
repeat(int dimension,
int... repeats)
Repeat elements along a specified dimension.
|
INDArray |
replaceWhere(INDArray arr,
Condition condition)
Replaces all elements in this ndarray that are matching give condition, with corresponding elements from given array
|
INDArray |
repmat(int[] shape)
Replicate and tile array to fill out to the given shape
|
void |
resetLinearView()
Resets the linear view
|
INDArray |
reshape(char order,
int... newShape)
Reshapes the ndarray (can't change the length of the ndarray)
|
INDArray |
reshape(char order,
int rows,
int columns)
Reshapes the ndarray (can't change the length of the ndarray)
|
INDArray |
reshape(int... shape)
Reshape the ndarray in to the specified dimensions,
possible errors being thrown for invalid shapes
Note here that one dimension can be -1.
|
INDArray |
reshape(int newRows,
int newColumns)
Reshape the matrix.
|
int |
rows()
Returns the number of rows
in the array (only 2d) throws an exception when
called when not 2d
|
IComplexNDArray |
rsub(IComplexNumber n) |
IComplexNDArray |
rsub(IComplexNumber n,
IComplexNDArray result) |
INDArray |
rsub(INDArray other) |
INDArray |
rsub(INDArray other,
INDArray result)
Reverse subtraction
|
INDArray |
rsub(Number n)
Reverse subtraction with duplicates
|
INDArray |
rsub(Number n,
INDArray result)
Reverse subtraction
|
INDArray |
rsubColumnVector(INDArray columnVector)
Reverse subtraction of a column vector (copy)
|
IComplexNDArray |
rsubi(IComplexNumber n) |
IComplexNDArray |
rsubi(IComplexNumber n,
IComplexNDArray result) |
INDArray |
rsubi(INDArray other) |
INDArray |
rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
INDArray |
rsubi(Number n) |
INDArray |
rsubi(Number n,
INDArray result)
Reverse in place subtraction
|
INDArray |
rsubiColumnVector(INDArray columnVector)
In place reverse subtraction of a column vector
|
INDArray |
rsubiRowVector(INDArray rowVector)
In place reverse subtraction of a row vector
|
INDArray |
rsubRowVector(INDArray rowVector)
Reverse subtraction of a row vector (copy)
|
int |
secondaryStride()
Deprecated.
|
void |
setData(DataBuffer data) |
void |
setOrder(char order)
Set the ordering
|
void |
setShape(int... shape)
Shape setter
|
void |
setStride(int[] stride)
stride setter
|
void |
setWrapAround(boolean wrapAround)
Set the ndarray to wrap around
|
int[] |
shape()
Returns the shape(dimensions) of this array
|
IntBuffer |
shapeInfo()
Shape info
|
DataBuffer |
shapeInfoDataBuffer()
Shape info
|
String |
shapeInfoToString()
Returns the shape information debugging
information
|
protected DataBuffer |
shapeOf() |
int |
size(int dimension)
Returns the size of this array
along a particular dimension
|
INDArray |
slice(int slice)
Returns the specified slice of this matrix.
|
INDArray |
slice(int slice,
int dimension)
Returns the slice of this from the specified dimension
|
int |
slices()
Number of slices: aka shape[0]
|
void |
sliceVectors(List<INDArray> list)
Flattens the array for linear indexing
|
double |
squaredDistance(INDArray other)
Returns the square of the Euclidean distance.
|
INDArray |
std(boolean biasCorrected,
int... dimension)
Standard deviation of an ndarray along a dimension
|
INDArray |
std(int... dimension)
Standard deviation of an ndarray along a dimension
|
IComplexNumber |
stdComplex() |
Number |
stdNumber() |
Number |
stdNumber(boolean biasCorrected) |
int[] |
stride()
Returns the stride(indices along the linear index for which each slice is accessed) of this array
|
int |
stride(int dimension)
Calculate the stride along a particular dimension
|
protected DataBuffer |
strideOf() |
IComplexNDArray |
sub(IComplexNumber n) |
IComplexNDArray |
sub(IComplexNumber n,
IComplexNDArray result) |
INDArray |
sub(INDArray other)
copy subtraction of two matrices
|
INDArray |
sub(INDArray other,
INDArray result)
copy subtraction of two matrices
|
INDArray |
sub(Number n)
Scalar subtraction (copied)
|
INDArray |
sub(Number n,
INDArray result) |
INDArray |
subArray(int[] offsets,
int[] shape,
int[] stride) |
INDArray |
subArray(ShapeOffsetResolution resolution)
Sub array based on the
pre calculated shape,strides, offsets
|
INDArray |
subColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
subi(IComplexNumber n) |
IComplexNDArray |
subi(IComplexNumber n,
IComplexNDArray result) |
INDArray |
subi(INDArray other)
in place subtraction of two matrices
|
INDArray |
subi(INDArray other,
INDArray result)
in place subtraction of two matrices
|
INDArray |
subi(Number n)
In place scalar subtraction
|
INDArray |
subi(Number n,
INDArray result)
In place subtraction of this ndarray
|
INDArray |
subiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
subiRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
subRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
sum(int... dimension)
Returns the sum along the last dimension of this ndarray
|
IComplexNumber |
sumComplex()
Sum the entire array
|
Number |
sumNumber()
Sum the entire array
|
INDArray |
swapAxes(int dimension,
int with)
Mainly here for people coming from numpy.
|
INDArray |
tensorAlongDimension(int index,
int... dimension)
Get the vector along a particular dimension
|
int |
tensorssAlongDimension(int... dimension)
Returns the number of possible vectors for a given dimension
|
String |
toString()
Generate string representation of the matrix.
|
INDArray |
transpose()
Return transposed copy of this matrix.
|
INDArray |
transposei()
Return transposed version of this matrix.
|
INDArray |
var(boolean biasCorrected,
int... dimension)
Returns the overall variance of this ndarray
|
INDArray |
var(int... dimension)
Returns the overall variance of this ndarray
|
IComplexNumber |
varComplex() |
Number |
varNumber() |
INDArray |
vectorAlongDimension(int index,
int dimension)
Get the vector along a particular dimension
|
int |
vectorsAlongDimension(int dimension)
Returns the number of possible vectors for a given dimension
|
protected void |
write(ObjectOutputStream out) |
clone, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
unsafeDuplication
forEach, spliterator
protected static final org.slf4j.Logger log
protected transient volatile DataBuffer shapeInformation
protected transient volatile DataBuffer data
protected int rows
protected int columns
protected long length
protected int rank
protected boolean cleanedUp
protected int numLeadingOnes
protected int numTrailingOnes
protected Boolean isVector
protected Boolean isMatrix
protected Boolean isScalar
protected boolean isWrapAround
protected int linearStride
protected boolean attemptedToFindElementWiseStride
protected transient DataBuffer shape
protected transient DataBuffer stride
protected transient boolean compressed
public BaseNDArray()
public BaseNDArray(DataBuffer buffer)
buffer
- public BaseNDArray(DataBuffer buffer, int[] shape, int[] stride, int offset, char ordering)
buffer
- shape
- stride
- offset
- ordering
- public BaseNDArray(double[][] data)
data
- public BaseNDArray(double[][] data, char ordering)
data
- ordering
- public BaseNDArray(int[] shape, DataBuffer buffer)
shape
- the shapebuffer
- the bufferpublic BaseNDArray(float[] data, int[] shape, char ordering)
data
- the data to useshape
- the shape of the ndarraypublic BaseNDArray(float[] data, int[] shape, int offset, char ordering)
data
- the data to useshape
- the shape of the ndarrayoffset
- the desired offsetordering
- the ordering of the ndarraypublic BaseNDArray(int[] shape, int[] stride, int offset, char ordering)
shape
- the shape of the ndarraystride
- the stride of the ndarrayoffset
- the desired offsetordering
- the ordering of the ndarraypublic BaseNDArray(int[] shape, int[] stride, int offset, char ordering, boolean initialize)
shape
- the shape of the ndarraystride
- the stride of the ndarrayoffset
- the desired offsetordering
- the ordering of the ndarrayinitialize
- Whether to initialize the INDArray. If true: initialize. If false: don't.public BaseNDArray(int[] shape, int[] stride, char ordering)
shape
- the shape of the ndarraystride
- the stride of the ndarrayordering
- the ordering of the ndarraypublic BaseNDArray(int[] shape, int offset, char ordering)
shape
- offset
- ordering
- public BaseNDArray(int[] shape)
shape
- public BaseNDArray(int newRows, int newColumns, char ordering)
newRows
- the number of rows (n) of the new matrix.newColumns
- the number of columns (m) of the new matrix.public BaseNDArray(List<INDArray> slices, int[] shape, char ordering)
slices
- the slices to mergeshape
- the shape of the ndarraypublic BaseNDArray(List<INDArray> slices, int[] shape, int[] stride, char ordering)
slices
- the slices to mergeshape
- the shape of the ndarraypublic BaseNDArray(float[] data, int[] shape, int[] stride, char ordering)
data
- shape
- stride
- ordering
- public BaseNDArray(float[] data, int[] shape, int[] stride, int offset, char ordering)
data
- shape
- stride
- offset
- ordering
- public BaseNDArray(DataBuffer data, int[] shape, int[] stride, int offset)
data
- shape
- stride
- offset
- public BaseNDArray(int[] data, int[] shape, int[] strides)
data
- shape
- strides
- public BaseNDArray(DataBuffer data, int[] shape)
data
- shape
- public BaseNDArray(DataBuffer buffer, int[] shape, int offset)
buffer
- shape
- offset
- public BaseNDArray(DataBuffer buffer, int[] shape, char ordering)
buffer
- shape
- ordering
- public BaseNDArray(double[] data, int[] shape, char ordering)
data
- shape
- ordering
- public BaseNDArray(double[] data, int[] shape, int[] stride, int offset, char ordering)
data
- shape
- stride
- offset
- ordering
- public BaseNDArray(float[] data, char order)
data
- order
- public BaseNDArray(DataBuffer floatBuffer, char order)
floatBuffer
- order
- public BaseNDArray(DataBuffer buffer, int[] shape, int[] strides)
buffer
- shape
- strides
- public BaseNDArray(float[] data, int[] shape)
data
- the data to useshape
- the shape of the ndarraypublic BaseNDArray(float[] data, int[] shape, int offset)
data
- shape
- offset
- public BaseNDArray(int[] shape, int[] stride, int offset)
shape
- the shape of the ndarraystride
- the stride of the ndarrayoffset
- the desired offsetpublic BaseNDArray(int[] shape, int[] stride)
shape
- the shape of the ndarraystride
- the stride of the ndarraypublic BaseNDArray(int[] shape, int offset)
shape
- offset
- public BaseNDArray(int[] shape, char ordering)
shape
- ordering
- public BaseNDArray(int newRows, int newColumns)
newRows
- the number of rows (n) of the new matrix.newColumns
- the number of columns (m) of the new matrix.public BaseNDArray(List<INDArray> slices, int[] shape)
slices
- the slices to mergeshape
- the shape of the ndarraypublic BaseNDArray(List<INDArray> slices, int[] shape, int[] stride)
slices
- the slices to mergeshape
- the shape of the ndarraypublic BaseNDArray(float[] data, int[] shape, int[] stride)
data
- shape
- stride
- public BaseNDArray(float[] data, int[] shape, int[] stride, int offset)
data
- shape
- stride
- offset
- public BaseNDArray(float[] data)
data
- public BaseNDArray(float[][] data)
data
- public BaseNDArray(float[][] data, char ordering)
data
- ordering
- public BaseNDArray(DataBuffer buffer, int[] shape, int offset, char ordering)
buffer
- shape
- offset
- ordering
- public BaseNDArray(double[] data, int[] shape, int[] stride, int offset)
public boolean isCompressed()
isCompressed
in interface INDArray
public void markAsCompressed(boolean reallyCompressed)
markAsCompressed
in interface INDArray
reallyCompressed
- public void setWrapAround(boolean wrapAround)
INDArray
setWrapAround
in interface INDArray
wrapAround
- thewrap aroundpublic boolean isWrapAround()
INDArray
isWrapAround
in interface INDArray
public boolean isValid()
public INDArray linearViewColumnOrder()
INDArray
linearViewColumnOrder
in interface INDArray
protected INDArray create(DataBuffer data, int[] shape, int offset)
public INDArray linearView()
linearView
in interface INDArray
public void resetLinearView()
INDArray
resetLinearView
in interface INDArray
public int elementWiseStride()
INDArray
elementWiseStride
in interface INDArray
public int elementStride()
INDArray
elementStride
in interface INDArray
public int majorStride()
INDArray
majorStride
in interface INDArray
@Deprecated public int secondaryStride()
INDArray
secondaryStride
in interface INDArray
public int tensorssAlongDimension(int... dimension)
INDArray
tensorssAlongDimension
in interface INDArray
dimension
- the dimension to calculate the number of vectors forpublic INDArray tensorAlongDimension(int index, int... dimension)
INDArray
tensorAlongDimension
in interface INDArray
index
- the index of the vector to getScalardimension
- the dimension to getScalar the vector frompublic int vectorsAlongDimension(int dimension)
vectorsAlongDimension
in interface INDArray
dimension
- the dimension to calculate the number of vectors forpublic INDArray vectorAlongDimension(int index, int dimension)
vectorAlongDimension
in interface INDArray
index
- the index of the vector to getdimension
- the dimension to get the vector frompublic void setOrder(char order)
INDArray
public void setShape(int... shape)
INDArray
public void setStride(int[] stride)
INDArray
public INDArray cumsumi(int dimension)
public Number normmaxNumber()
normmaxNumber
in interface INDArray
public IComplexNumber normmaxComplex()
normmaxComplex
in interface INDArray
public Number norm2Number()
norm2Number
in interface INDArray
public IComplexNumber norm2Complex()
norm2Complex
in interface INDArray
public Number norm1Number()
norm1Number
in interface INDArray
public IComplexNumber norm1Complex()
norm1Complex
in interface INDArray
public IComplexNumber stdComplex()
stdComplex
in interface INDArray
public Number prodNumber()
prodNumber
in interface INDArray
public IComplexNumber prodComplex()
prodComplex
in interface INDArray
public Number meanNumber()
meanNumber
in interface INDArray
public IComplexNumber meanComplex()
meanComplex
in interface INDArray
public IComplexNumber varComplex()
varComplex
in interface INDArray
public IComplexNumber maxComplex()
maxComplex
in interface INDArray
public IComplexNumber minComplex()
minComplex
in interface INDArray
public Number sumNumber()
INDArray
public IComplexNumber sumComplex()
INDArray
sumComplex
in interface INDArray
public INDArray cumsum(int dimension)
public INDArray assign(INDArray arr)
public INDArray putScalar(int i, double value)
INDArray
public INDArray putScalar(int i, float value)
INDArray
public INDArray putScalar(int i, int value)
INDArray
public INDArray putScalar(int[] indexes, double value)
INDArray
public INDArray putScalar(int row, int col, double value)
INDArray
INDArray.putScalar(int[], double)
but avoids int[] creationpublic INDArray putScalar(int dim0, int dim1, int dim2, double value)
INDArray
INDArray.putScalar(int[], double)
but avoids int[] creationpublic INDArray putScalar(int dim0, int dim1, int dim2, int dim3, double value)
INDArray
INDArray.putScalar(int[], double)
but avoids int[] creationpublic INDArray putScalar(int[] indexes, float value)
public INDArray putScalar(int[] indexes, int value)
public INDArray eps(INDArray other)
public INDArray epsi(INDArray other)
public INDArray lt(Number other)
INDArray
public INDArray lti(Number other)
INDArray
public INDArray eq(Number other)
INDArray
public INDArray eqi(Number other)
INDArray
public INDArray gt(Number other)
INDArray
public INDArray gti(Number other)
INDArray
public INDArray lt(INDArray other)
INDArray
public INDArray lti(INDArray other)
INDArray
public INDArray neqi(Number other)
INDArray
public INDArray eq(INDArray other)
INDArray
public INDArray eqi(INDArray other)
INDArray
public INDArray gt(INDArray other)
INDArray
public INDArray gti(INDArray other)
INDArray
public INDArray negi()
public INDArray rdiv(Number n, INDArray result)
INDArray
public INDArray rdivi(Number n, INDArray result)
INDArray
public INDArray rsub(Number n, INDArray result)
INDArray
public INDArray rsubi(Number n, INDArray result)
INDArray
public INDArray divi(Number n, INDArray result)
INDArray
public INDArray muli(Number n, INDArray result)
INDArray
public INDArray subi(Number n, INDArray result)
INDArray
public INDArray addi(Number n, INDArray result)
INDArray
public INDArray getScalar(int row, int column)
public INDArray dup(char order)
INDArray
public int getInt(int... indices)
public double getDouble(int... indices)
public float getFloat(int... indices)
public boolean isScalar()
public INDArray putSlice(int slice, INDArray put)
protected void assertSlice(INDArray put, int slice)
public boolean isMatrix()
public int index(int row, int column)
INDArray
protected INDArray newShape(int[] newShape, char ordering)
protected INDArray create(DataBuffer data, int[] newShape, int[] newStrides, int offset, char ordering)
protected INDArray create(DataBuffer data, int[] newShape, int[] newStrides, int offset)
protected INDArray create(int[] shape)
protected INDArray create(int[] shape, int[] strides, int offset)
protected int[] getStrides(int[] shape, char ordering)
public double squaredDistance(INDArray other)
squaredDistance
in interface INDArray
public double distance2(INDArray other)
public double distance1(INDArray other)
public INDArray put(INDArrayIndex[] indices, INDArray element)
INDArray
public INDArray put(INDArrayIndex[] indices, Number element)
INDArray
public INDArray swapAxes(int dimension, int with)
public boolean isView()
INDArray
public DataBuffer data()
INDArray
public void setData(DataBuffer data)
public int slices()
public INDArray subArray(ShapeOffsetResolution resolution)
INDArray
public INDArray subArray(int[] offsets, int[] shape, int[] stride)
protected INDArray create(DataBuffer buffer)
public INDArray cond(Condition condition)
INDArray
public INDArray condi(Condition condition)
INDArray
protected void init(int[] shape, int[] stride)
public INDArray getScalar(int i)
INDArray
protected INDArray doColumnWise(INDArray columnVector, char operation)
columnVector
- the column vectoroperation
- the operationpublic boolean isCleanedUp()
INDArray
isCleanedUp
in interface INDArray
public void cleanup()
INDArray
protected INDArray doRowWise(INDArray rowVector, char operation)
rowVector
- the row vectoroperation
- the operationprotected DataBuffer shapeOf()
protected DataBuffer strideOf()
public int stride(int dimension)
INDArray
public INDArray rdiviColumnVector(INDArray columnVector)
INDArray
rdiviColumnVector
in interface INDArray
columnVector
- the column vector used for divisionpublic INDArray rdivColumnVector(INDArray columnVector)
INDArray
rdivColumnVector
in interface INDArray
columnVector
- the column vector used for divisionpublic INDArray rdiviRowVector(INDArray rowVector)
INDArray
rdiviRowVector
in interface INDArray
rowVector
- the row vector used for divisionpublic INDArray rdivRowVector(INDArray rowVector)
INDArray
rdivRowVector
in interface INDArray
rowVector
- the row vector used for divisionpublic INDArray rsubiColumnVector(INDArray columnVector)
INDArray
rsubiColumnVector
in interface INDArray
columnVector
- the column vector to subtractpublic INDArray rsubColumnVector(INDArray columnVector)
INDArray
rsubColumnVector
in interface INDArray
columnVector
- the column vector to subtractpublic INDArray rsubiRowVector(INDArray rowVector)
INDArray
rsubiRowVector
in interface INDArray
rowVector
- the row vector to subtractpublic INDArray rsubRowVector(INDArray rowVector)
INDArray
rsubRowVector
in interface INDArray
rowVector
- the row vector to subtractpublic INDArray diviColumnVector(INDArray columnVector)
diviColumnVector
in interface INDArray
columnVector
- the column vector to addpublic INDArray divColumnVector(INDArray columnVector)
divColumnVector
in interface INDArray
columnVector
- the column vector to addpublic INDArray diviRowVector(INDArray rowVector)
diviRowVector
in interface INDArray
rowVector
- the row vector to addpublic INDArray divRowVector(INDArray rowVector)
divRowVector
in interface INDArray
rowVector
- the row vector to addpublic INDArray muliColumnVector(INDArray columnVector)
muliColumnVector
in interface INDArray
columnVector
- the column vector to addpublic INDArray mulColumnVector(INDArray columnVector)
mulColumnVector
in interface INDArray
columnVector
- the column vector to addpublic INDArray muliRowVector(INDArray rowVector)
muliRowVector
in interface INDArray
rowVector
- the row vector to addpublic INDArray mulRowVector(INDArray rowVector)
mulRowVector
in interface INDArray
rowVector
- the row vector to addpublic INDArray subiColumnVector(INDArray columnVector)
subiColumnVector
in interface INDArray
columnVector
- the column vector to addpublic INDArray subColumnVector(INDArray columnVector)
subColumnVector
in interface INDArray
columnVector
- the column vector to addpublic INDArray subiRowVector(INDArray rowVector)
subiRowVector
in interface INDArray
rowVector
- the row vector to addpublic INDArray subRowVector(INDArray rowVector)
subRowVector
in interface INDArray
rowVector
- the row vector to addpublic INDArray addiColumnVector(INDArray columnVector)
addiColumnVector
in interface INDArray
columnVector
- the column vector to addpublic INDArray addColumnVector(INDArray columnVector)
addColumnVector
in interface INDArray
columnVector
- the column vector to addpublic INDArray addiRowVector(INDArray rowVector)
addiRowVector
in interface INDArray
rowVector
- the row vector to addpublic INDArray addRowVector(INDArray rowVector)
addRowVector
in interface INDArray
rowVector
- the row vector to addprotected INDArray create(int[] shape, char ordering)
public INDArray div(INDArray other, INDArray result)
public INDArray mul(INDArray other, INDArray result)
public INDArray divi(INDArray other, INDArray result)
public INDArray muli(INDArray other, INDArray result)
public INDArray normmax(int... dimension)
public INDArray assignIf(INDArray arr, Condition condition)
public INDArray replaceWhere(INDArray arr, Condition condition)
replaceWhere
in interface INDArray
arr
- condition
- public int linearIndex(int i)
INDArray
linearIndex
in interface INDArray
i
- the index to getScalarpublic INDArray slice(int slice)
protected INDArray createScalarForIndex(int i, boolean applyOffset)
protected INDArray createScalar(double d)
public int getTrailingOnes()
getTrailingOnes
in interface INDArray
public int getLeadingOnes()
getLeadingOnes
in interface INDArray
public INDArray slice(int slice, int dimension)
public INDArray getScalar(int... indexes)
public INDArray rdivi(Number n)
INDArray
public INDArray rsub(Number n)
INDArray
public INDArray divi(Number n)
INDArray
public INDArray mul(Number n)
INDArray
public INDArray muli(Number n)
INDArray
public INDArray sub(Number n)
INDArray
public INDArray subi(Number n)
INDArray
public INDArray add(Number n)
INDArray
public INDArray addi(Number n)
INDArray
public INDArray repmat(int[] shape)
public INDArray repeat(int dimension, int... repeats)
INDArray
public INDArray repeat(int... repeats)
INDArray
public INDArray putRow(int row, INDArray toPut)
public INDArray putColumn(int column, INDArray toPut)
public double getDouble(int i, int j)
public float getFloat(int i)
INDArray
public float getFloat(int i, int j)
INDArray
public INDArray transpose()
public INDArray transposei()
transposei
in interface INDArray
protected INDArray create(DataBuffer data, int[] shape, int[] strides)
public INDArray reshape(char order, int... newShape)
INDArray
public double getDoubleUnsafe(int offset)
INDArray
getDoubleUnsafe
in interface INDArray
offset
- the offset to get atpublic INDArray putScalarUnsafe(int offset, double value)
INDArray
putScalarUnsafe
in interface INDArray
offset
- the offset to insert atvalue
- the value to insertpublic int innerMostStride()
INDArray
innerMostStride
in interface INDArray
public INDArray reshape(char order, int rows, int columns)
INDArray
public INDArray reshape(int... shape)
public void checkDimensions(INDArray other)
INDArray
checkDimensions
in interface INDArray
other
- the other ndarray to comparepublic INDArray prod(int... dimension)
public INDArray mean(int... dimension)
public INDArray var(int... dimension)
public INDArray var(boolean biasCorrected, int... dimension)
public INDArray max(int... dimension)
public INDArray min(int... dimension)
public INDArray sum(int... dimension)
public INDArray norm1(int... dimension)
public INDArray std(int... dimension)
public INDArray std(boolean biasCorrected, int... dimension)
INDArray
public Number stdNumber(boolean biasCorrected)
public INDArray norm2(int... dimension)
public int columns()
public int rows()
public INDArray ravel(char ordering)
public INDArray ravel()
public void sliceVectors(List<INDArray> list)
sliceVectors
in interface INDArray
public INDArray reshape(int newRows, int newColumns)
public INDArray getColumn(int c)
public INDArray getRows(int[] rindices)
public INDArray get(INDArrayIndex... indexes)
public INDArray getColumns(int... cindices)
getColumns
in interface INDArray
cindices
- protected INDArray create(int rows, int length)
public INDArray getRow(int r)
public boolean equalsWithEps(Object o, double eps)
equalsWithEps
in interface INDArray
o
- eps
- public boolean equals(Object o)
public DataBuffer shapeInfoDataBuffer()
INDArray
shapeInfoDataBuffer
in interface INDArray
public int[] shape()
public String shapeInfoToString()
shapeInfoToString
in interface INDArray
public int[] stride()
public int offset()
INDArray
public char ordering()
INDArray
public int size(int dimension)
public int rank()
INDArray
public int length()
public long lengthLong()
lengthLong
in interface INDArray
public INDArray broadcast(int... shape)
public INDArray dimShuffle(Object[] rearrange, int[] newOrder, boolean[] broadCastable)
dimShuffle
in interface INDArray
rearrange
- the dimensions to swap tonewOrder
- the new order (think permute)broadCastable
- (whether the dimension is broadcastable) (must be same length as new order)public INDArray permute(int... rearrange)
public INDArray permutei(int... rearrange)
protected void copyRealTo(INDArray arr)
protected int[] doPermuteSwap(IntBuffer shape, int[] rearrange)
protected int[] doPermuteSwap(DataBuffer shape, int[] rearrange)
protected void checkArrangeArray(int[] arr)
public boolean isVector()
public boolean isSquare()
INDArray
public boolean isRowVector()
isRowVector
in interface INDArray
public boolean isColumnVector()
isColumnVector
in interface INDArray
public String toString()
public Object element()
public IComplexNDArray rdiv(IComplexNumber n)
public IComplexNDArray rdivi(IComplexNumber n)
public IComplexNDArray rsub(IComplexNumber n)
public IComplexNDArray rsubi(IComplexNumber n)
public IComplexNDArray div(IComplexNumber n)
public IComplexNDArray divi(IComplexNumber n)
public IComplexNDArray mul(IComplexNumber n)
public IComplexNDArray muli(IComplexNumber n)
public IComplexNDArray sub(IComplexNumber n)
public IComplexNDArray subi(IComplexNumber n)
public IComplexNDArray add(IComplexNumber n)
public IComplexNDArray addi(IComplexNumber n)
public IComplexNDArray rdiv(IComplexNumber n, IComplexNDArray result)
public IComplexNDArray rdivi(IComplexNumber n, IComplexNDArray result)
public IComplexNDArray rsub(IComplexNumber n, IComplexNDArray result)
public IComplexNDArray rsubi(IComplexNumber n, IComplexNDArray result)
public IComplexNDArray div(IComplexNumber n, IComplexNDArray result)
public IComplexNDArray divi(IComplexNumber n, IComplexNDArray result)
public IComplexNDArray mul(IComplexNumber n, IComplexNDArray result)
public IComplexNDArray muli(IComplexNumber n, IComplexNDArray result)
public IComplexNDArray sub(IComplexNumber n, IComplexNDArray result)
public IComplexNDArray subi(IComplexNumber n, IComplexNDArray result)
public IComplexNDArray add(IComplexNumber n, IComplexNDArray result)
public IComplexNDArray addi(IComplexNumber n, IComplexNDArray result)
protected INDArray create(BaseNDArray baseNDArray)
public int originalOffset()
originalOffset
in interface INDArray
protected void write(ObjectOutputStream out) throws IOException
IOException
protected void read(ObjectInputStream s)
Copyright © 2016. All Rights Reserved.