| Modifier and Type | Method and Description |
|---|---|
double |
Level1.asum(INDArray arr)
computes the sum of magnitudes of all vector elements or, for a complex vector x, the sum
|
void |
Level1.axpy(int n,
double alpha,
INDArray x,
INDArray y)
computes a vector-scalar product and adds the result to a vector.
|
void |
Level1.copy(INDArray x,
INDArray y)
copy a vector to another vector.
|
double |
Level1.dot(int n,
double alpha,
INDArray X,
INDArray Y)
computes a vector-vector dot product.
|
void |
Level2.gbmv(char order,
char TransA,
int KL,
int KU,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
gbmv computes a matrix-vector product using a general band matrix and performs one of the following matrix-vector operations:
y := alpha*a*x + beta*y for trans = 'N'or'n';
y := alpha*a'*x + beta*y for trans = 'T'or't';
y := alpha*conjg(a')*x + beta*y for trans = 'C'or'c'.
|
void |
Level3.gemm(char Order,
char TransA,
char TransB,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
gemm performs a matrix-matrix operation
c := alpha*op(a)*op(b) + beta*c,
where c is an m-by-n matrix,
op(a) is an m-by-k matrix,
op(b) is a k-by-n matrix.
|
void |
Level3.gemm(INDArray A,
INDArray B,
INDArray C,
boolean transposeA,
boolean transposeB,
double alpha,
double beta)
A convenience method for matrix-matrix operations with transposes.
|
void |
Level2.gemv(char order,
char transA,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
gemv computes a matrix-vector product using a general matrix and performs one of the following matrix-vector operations:
y := alpha*a*x + beta*y for trans = 'N'or'n';
y := alpha*a'*x + beta*y for trans = 'T'or't';
y := alpha*conjg(a')*x + beta*y for trans = 'C'or'c'.
|
void |
Level2.ger(char order,
double alpha,
INDArray X,
INDArray Y,
INDArray A)
performs a rank-1 update of a general m-by-n matrix a:
a := alpha*x*y' + a.
|
static int |
BlasBufferUtil.getBlasOffset(INDArray arr)
Get blas stride for the
given array
|
static int |
BlasBufferUtil.getBlasStride(INDArray arr)
Get blas stride for the
given array
|
static char |
BlasBufferUtil.getCharForTranspose(INDArray arr)
Returns the proper character for
how to interpret a buffer (fortran being N C being T)
|
static int |
BlasBufferUtil.getDimension(INDArray arr,
boolean defaultRows)
Get the dimension associated with
the given ordering.
|
static double[] |
BlasBufferUtil.getDoubleData(INDArray buf)
Returns the double data
for this ndarray.
|
static float[] |
BlasBufferUtil.getFloatData(INDArray buf)
Returns the float data
for this ndarray.
|
static int |
BlasBufferUtil.getLd(INDArray arr)
Get the leading dimension
for a blas invocation.
|
void |
Lapack.getrf(int M,
int N,
INDArray A,
int lda,
int[] IPIV,
int INFO)
LU decomposiiton of a matrix
|
void |
Lapack.getri(int N,
INDArray A,
int lda,
int[] IPIV,
INDArray WORK,
int lwork,
int INFO)
Generate inverse ggiven LU decomp
|
static int |
BlasBufferUtil.getStrideForOrdering(INDArray arr)
Return the proper stride
through a vector
relative to the ordering of the array
This is for incX/incY parameters in BLAS.
|
int |
Level1.iamax(INDArray arr)
finds the element of a
vector that has the largest absolute value.
|
int |
Level1.iamax(int n,
INDArray arr,
int stride)
finds the element of a
vector that has the largest absolute value.
|
int |
Level1.iamin(INDArray arr)
finds the element of a vector that has the minimum absolute value.
|
double |
Level1.nrm2(INDArray arr)
computes the Euclidean norm of a vector.
|
void |
Level1.rot(int N,
INDArray X,
INDArray Y,
double c,
double s)
performs rotation of points in the plane.
|
void |
Level1.rotg(INDArray a,
INDArray b,
INDArray c,
INDArray s)
computes parameters for a Givens rotation.
|
void |
Level1.rotmg(INDArray d1,
INDArray d2,
INDArray b1,
double b2,
INDArray P)
computes the modified parameters for a Givens rotation.
|
void |
Level2.sbmv(char order,
char Uplo,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
sbmv computes a matrix-vector product using a symmetric band matrix:
y := alpha*a*x + beta*y.
|
void |
Level1.scal(int N,
double alpha,
INDArray X)
computes a vector by a scalar product.
|
static void |
BlasBufferUtil.setData(double[] data,
INDArray toSet)
Set the data for the underlying array.
|
static void |
BlasBufferUtil.setData(float[] data,
INDArray toSet)
Set the data for the underlying array.
|
void |
Level2.spmv(char order,
char Uplo,
double alpha,
INDArray Ap,
INDArray X,
double beta,
INDArray Y) |
void |
Level2.spr(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Ap)
spr performs a rank-1 update of an n-by-n packed symmetric matrix a:
a := alpha*x*x' + a.
|
void |
Level2.spr2(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Y,
INDArray A)
?spr2 performs a rank-2 update of an n-by-n packed symmetric matrix a:
a := alpha*x*y' + alpha*y*x' + a.
|
void |
Level1.swap(INDArray x,
INDArray y)
swaps a vector with another vector.
|
void |
Level3.symm(char Order,
char Side,
char Uplo,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
her2k performs a rank-2k update of an n-by-n Hermitian matrix c, that is, one of the following operations:
c := alpha*a*conjg(b') + conjg(alpha)*b*conjg(a') + beta*c, for trans = 'N'or'n'
c := alpha*conjg(b')*a + conjg(alpha)*conjg(a')*b + beta*c, for trans = 'C'or'c'
where c is an n-by-n Hermitian matrix;
a and b are n-by-k matrices if trans = 'N'or'n',
a and b are k-by-n matrices if trans = 'C'or'c'.
|
void |
Level2.symv(char order,
char Uplo,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
symv computes a matrix-vector product for a symmetric matrix:
y := alpha*a*x + beta*y.
|
void |
Level2.syr(char order,
char Uplo,
int N,
double alpha,
INDArray X,
INDArray A)
syr performs a rank-1 update of an n-by-n symmetric matrix a:
a := alpha*x*x' + a.
|
void |
Level2.syr2(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Y,
INDArray A) |
void |
Level3.syr2k(char Order,
char Uplo,
char Trans,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
yr2k performs a rank-2k update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*b' + alpha*b*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*b + alpha*b'*a + beta*c for trans = 'T'or't',
where c is an n-by-n symmetric matrix;
a and b are n-by-k matrices, if trans = 'N'or'n',
a and b are k-by-n matrices, if trans = 'T'or't'.
|
void |
Level3.syrk(char Order,
char Uplo,
char Trans,
double alpha,
INDArray A,
double beta,
INDArray C)
syrk performs a rank-n update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*a + beta*c for trans = 'T'or't','C'or'c',
where c is an n-by-n symmetric matrix;
a is an n-by-k matrix, if trans = 'N'or'n',
a is a k-by-n matrix, if trans = 'T'or't','C'or'c'.
|
void |
Level2.tbmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
syr2 performs a rank-2 update of an n-by-n symmetric matrix a:
a := alpha*x*y' + alpha*y*x' + a.
|
void |
Level2.tbsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
?tbsv solves a system of linear equations whose coefficients are in a triangular band matrix.
|
void |
Level2.tpmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray Ap,
INDArray X)
tpmv computes a matrix-vector product using a triangular packed matrix.
|
void |
Level2.tpsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray Ap,
INDArray X)
tpsv solves a system of linear equations whose coefficients are in a triangular packed matrix.
|
void |
Level3.trmm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
double alpha,
INDArray A,
INDArray B,
INDArray C)
syr2k performs a rank-2k update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*b' + alpha*b*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*b + alpha*b'*a + beta*c for trans = 'T'or't',
where c is an n-by-n symmetric matrix;
a and b are n-by-k matrices, if trans = 'N'or'n',
a and b are k-by-n matrices, if trans = 'T'or't'.
|
void |
Level2.trmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
trmv computes a matrix-vector product using a triangular matrix.
|
void |
Level3.trsm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
double alpha,
INDArray A,
INDArray B)
?trsm solves one of the following matrix equations:
op(a)*x = alpha*b or x*op(a) = alpha*b,
where x and b are m-by-n general matrices, and a is triangular;
op(a) must be an m-by-m matrix, if side = 'L'or'l'
op(a) must be an n-by-n matrix, if side = 'R'or'r'.
|
void |
Level2.trsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
trsv solves a system of linear equations whose coefficients are in a triangular matrix.
|
| Modifier and Type | Method and Description |
|---|---|
double |
BaseLevel1.asum(INDArray arr)
computes the sum of magnitudes of all vector elements or, for a complex vector x, the sum
|
void |
BaseLevel1.axpy(int n,
double alpha,
INDArray x,
INDArray y)
computes a vector-scalar product and adds the result to a vector.
|
protected abstract void |
BaseLevel2.chpr(char order,
char Uplo,
int N,
INDArray alpha,
IComplexNDArray X,
int incX,
IComplexNDArray A) |
void |
BaseLevel1.copy(INDArray x,
INDArray y)
swaps a vector with another vector.
|
protected abstract double |
BaseLevel1.dasum(int N,
INDArray X,
int incX) |
protected abstract void |
BaseLevel1.daxpy(int N,
double alpha,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel1.dcopy(int N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract double |
BaseLevel1.ddot(int N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.dgbmv(char order,
char TransA,
int M,
int N,
int KL,
int KU,
double alpha,
INDArray A,
int lda,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel3.dgemm(char Order,
char TransA,
char TransB,
int M,
int N,
int K,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
double beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.dgemv(char order,
char TransA,
int M,
int N,
double alpha,
INDArray A,
int lda,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.dger(char order,
int M,
int N,
double alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A,
int lda) |
protected abstract double |
BaseLevel1.dnrm2(int N,
INDArray X,
int incX) |
double |
BaseLevel1.dot(int n,
double alpha,
INDArray X,
INDArray Y)
computes a vector-vector dot product.
|
protected abstract void |
BaseLevel1.drot(int N,
INDArray X,
int incX,
INDArray Y,
int incY,
double c,
double s) |
protected abstract void |
BaseLevel1.drotm(int N,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray P) |
protected abstract void |
BaseLevel1.drotmg(double d1,
double d2,
double b1,
double b2,
INDArray P) |
protected abstract void |
BaseLevel2.dsbmv(char order,
char Uplo,
int N,
int K,
double alpha,
INDArray A,
int lda,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel1.dscal(int N,
double alpha,
INDArray X,
int incX) |
protected abstract double |
BaseLevel1.dsdot(int N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.dspmv(char order,
char Uplo,
int N,
double alpha,
INDArray Ap,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.dspr(char order,
char Uplo,
int N,
double alpha,
INDArray X,
int incX,
INDArray Ap) |
protected abstract void |
BaseLevel2.dspr2(char order,
char Uplo,
int N,
double alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A) |
protected abstract void |
BaseLevel1.dswap(int N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel3.dsymm(char Order,
char Side,
char Uplo,
int M,
int N,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
double beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.dsymv(char order,
char Uplo,
int N,
double alpha,
INDArray A,
int lda,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.dsyr(char order,
char Uplo,
int N,
double alpha,
INDArray X,
int incX,
INDArray A,
int lda) |
protected abstract void |
BaseLevel2.dsyr2(char order,
char Uplo,
int N,
double alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A,
int lda) |
protected abstract void |
BaseLevel3.dsyr2k(char Order,
char Uplo,
char Trans,
int N,
int K,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
double beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel3.dsyrk(char Order,
char Uplo,
char Trans,
int N,
int K,
double alpha,
INDArray A,
int lda,
double beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.dtbmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
int K,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.dtbsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
int K,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.dtpmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray Ap,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.dtpsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray Ap,
INDArray X,
int incX) |
protected abstract void |
BaseLevel3.dtrmm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
int M,
int N,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb) |
protected abstract void |
BaseLevel2.dtrmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel3.dtrsm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
int M,
int N,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb) |
protected abstract void |
BaseLevel2.dtrsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray A,
int lda,
INDArray X,
int incX) |
void |
BaseLevel2.gbmv(char order,
char TransA,
int KL,
int KU,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
gbmv computes a matrix-vector product using a general band matrix and performs one of the following matrix-vector operations:
y := alpha*a*x + beta*y for trans = 'N'or'n';
y := alpha*a'*x + beta*y for trans = 'T'or't';
y := alpha*conjg(a')*x + beta*y for trans = 'C'or'c'.
|
void |
BaseLevel3.gemm(char Order,
char TransA,
char TransB,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
gemm performs a matrix-matrix operation
c := alpha*op(a)*op(b) + beta*c,
where c is an m-by-n matrix,
op(a) is an m-by-k matrix,
op(b) is a k-by-n matrix.
|
void |
BaseLevel3.gemm(INDArray A,
INDArray B,
INDArray C,
boolean transposeA,
boolean transposeB,
double alpha,
double beta)
A convenience method for matrix-matrix operations with transposes.
|
void |
BaseLevel2.gemv(char order,
char transA,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
gemv computes a matrix-vector product using a general matrix and performs one of the following matrix-vector operations:
y := alpha*a*x + beta*y for trans = 'N'or'n';
y := alpha*a'*x + beta*y for trans = 'T'or't';
y := alpha*conjg(a')*x + beta*y for trans = 'C'or'c'.
|
void |
BaseLevel2.ger(char order,
double alpha,
INDArray X,
INDArray Y,
INDArray A)
performs a rank-1 update of a general m-by-n matrix a:
a := alpha*x*y' + a.
|
double[] |
BaseLevel.getDoubleData(INDArray buf) |
float[] |
BaseLevel.getFloatData(INDArray buf) |
protected abstract float |
BaseLevel1.hasum(int N,
INDArray X,
int incX) |
protected abstract void |
BaseLevel1.haxpy(int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract float |
BaseLevel1.hdot(int N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel3.hgemm(char Order,
char TransA,
char TransB,
int M,
int N,
int K,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
float beta,
INDArray C,
int ldc) |
int |
BaseLevel1.iamax(INDArray arr)
finds the element of a
vector that has the largest absolute value.
|
int |
BaseLevel1.iamax(int n,
INDArray arr,
int stride) |
int |
BaseLevel1.iamin(INDArray arr)
finds the element of a vector that has the minimum absolute value.
|
protected abstract int |
BaseLevel1.idamax(int N,
INDArray X,
int incX) |
protected abstract int |
BaseLevel1.isamax(int N,
INDArray X,
int incX) |
double |
BaseLevel1.nrm2(INDArray arr)
computes the Euclidean norm of a vector.
|
void |
BaseLevel1.rot(int N,
INDArray X,
INDArray Y,
double c,
double s)
performs rotation of points in the plane.
|
void |
BaseLevel1.rotg(INDArray a,
INDArray b,
INDArray c,
INDArray s)
computes parameters for a Givens rotation.
|
void |
BaseLevel1.rotmg(INDArray d1,
INDArray d2,
INDArray b1,
double b2,
INDArray P)
computes the modified parameters for a Givens rotation.
|
protected abstract float |
BaseLevel1.sasum(int N,
INDArray X,
int incX) |
protected abstract void |
BaseLevel1.saxpy(int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY) |
void |
BaseLevel2.sbmv(char order,
char Uplo,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
sbmv computes a matrix-vector product using a symmetric band matrix:
y := alpha*a*x + beta*y.
|
void |
BaseLevel1.scal(int N,
double alpha,
INDArray X)
computes a vector by a scalar product.
|
protected abstract void |
BaseLevel1.scopy(int N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract float |
BaseLevel1.sdot(int N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract float |
BaseLevel1.sdsdot(int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.sgbmv(char order,
char TransA,
int M,
int N,
int KL,
int KU,
float alpha,
INDArray A,
int lda,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel3.sgemm(char Order,
char TransA,
char TransB,
int M,
int N,
int K,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
float beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.sgemv(char order,
char TransA,
int M,
int N,
float alpha,
INDArray A,
int lda,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.sger(char order,
int M,
int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A,
int lda) |
protected abstract float |
BaseLevel1.snrm2(int N,
INDArray X,
int incX) |
void |
BaseLevel2.spmv(char order,
char Uplo,
double alpha,
INDArray Ap,
INDArray X,
double beta,
INDArray Y) |
void |
BaseLevel2.spr(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Ap)
spr performs a rank-1 update of an n-by-n packed symmetric matrix a:
a := alpha*x*x' + a.
|
void |
BaseLevel2.spr2(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Y,
INDArray A)
?spr2 performs a rank-2 update of an n-by-n packed symmetric matrix a:
a := alpha*x*y' + alpha*y*x' + a.
|
protected abstract void |
BaseLevel1.srot(int N,
INDArray X,
int incX,
INDArray Y,
int incY,
float c,
float s) |
protected abstract void |
BaseLevel1.srotm(int N,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray P) |
protected abstract void |
BaseLevel1.srotmg(float d1,
float d2,
float b1,
float b2,
INDArray P) |
protected abstract void |
BaseLevel2.ssbmv(char order,
char Uplo,
int N,
int K,
float alpha,
INDArray A,
int lda,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel1.sscal(int N,
float alpha,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.sspmv(char order,
char Uplo,
int N,
float alpha,
INDArray Ap,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.sspr(char order,
char Uplo,
int N,
float alpha,
INDArray X,
int incX,
INDArray Ap) |
protected abstract void |
BaseLevel2.sspr2(char order,
char Uplo,
int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A) |
protected abstract void |
BaseLevel1.sswap(int N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel3.ssymm(char Order,
char Side,
char Uplo,
int M,
int N,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
float beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.ssymv(char order,
char Uplo,
int N,
float alpha,
INDArray A,
int lda,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.ssyr(char order,
char Uplo,
int N,
float alpha,
INDArray X,
int incX,
INDArray A,
int lda) |
protected abstract void |
BaseLevel2.ssyr2(char order,
char Uplo,
int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A,
int lda) |
protected abstract void |
BaseLevel3.ssyr2k(char Order,
char Uplo,
char Trans,
int N,
int K,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
float beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel3.ssyrk(char Order,
char Uplo,
char Trans,
int N,
int K,
float alpha,
INDArray A,
int lda,
float beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.stbmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
int K,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.stbsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
int K,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.stpmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray Ap,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.stpsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray Ap,
INDArray X,
int incX) |
protected abstract void |
BaseLevel3.strmm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
int M,
int N,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb) |
protected abstract void |
BaseLevel2.strmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel3.strsm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
int M,
int N,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb) |
protected abstract void |
BaseLevel2.strsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray A,
int lda,
INDArray X,
int incX) |
void |
BaseLevel1.swap(INDArray x,
INDArray y)
swaps a vector with another vector.
|
void |
BaseLevel3.symm(char Order,
char Side,
char Uplo,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
her2k performs a rank-2k update of an n-by-n Hermitian matrix c, that is, one of the following operations:
c := alpha*a*conjg(b') + conjg(alpha)*b*conjg(a') + beta*c, for trans = 'N'or'n'
c := alpha*conjg(b')*a + conjg(alpha)*conjg(a')*b + beta*c, for trans = 'C'or'c'
where c is an n-by-n Hermitian matrix;
a and b are n-by-k matrices if trans = 'N'or'n',
a and b are k-by-n matrices if trans = 'C'or'c'.
|
void |
BaseLevel2.symv(char order,
char Uplo,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
symv computes a matrix-vector product for a symmetric matrix:
y := alpha*a*x + beta*y.
|
void |
BaseLevel2.syr(char order,
char Uplo,
int N,
double alpha,
INDArray X,
INDArray A)
syr performs a rank-1 update of an n-by-n symmetric matrix a:
a := alpha*x*x' + a.
|
void |
BaseLevel2.syr2(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Y,
INDArray A) |
void |
BaseLevel3.syr2k(char Order,
char Uplo,
char Trans,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
yr2k performs a rank-2k update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*b' + alpha*b*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*b + alpha*b'*a + beta*c for trans = 'T'or't',
where c is an n-by-n symmetric matrix;
a and b are n-by-k matrices, if trans = 'N'or'n',
a and b are k-by-n matrices, if trans = 'T'or't'.
|
void |
BaseLevel3.syrk(char Order,
char Uplo,
char Trans,
double alpha,
INDArray A,
double beta,
INDArray C)
syrk performs a rank-n update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*a + beta*c for trans = 'T'or't','C'or'c',
where c is an n-by-n symmetric matrix;
a is an n-by-k matrix, if trans = 'N'or'n',
a is a k-by-n matrix, if trans = 'T'or't','C'or'c'.
|
void |
BaseLevel2.tbmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
syr2 performs a rank-2 update of an n-by-n symmetric matrix a:
a := alpha*x*y' + alpha*y*x' + a.
|
void |
BaseLevel2.tbsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
?tbsv solves a system of linear equations whose coefficients are in a triangular band matrix.
|
void |
BaseLevel2.tpmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray Ap,
INDArray X)
tpmv computes a matrix-vector product using a triangular packed matrix.
|
void |
BaseLevel2.tpsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray Ap,
INDArray X)
tpsv solves a system of linear equations whose coefficients are in a triangular packed matrix.
|
void |
BaseLevel3.trmm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
double alpha,
INDArray A,
INDArray B,
INDArray C)
syr2k performs a rank-2k update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*b' + alpha*b*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*b + alpha*b'*a + beta*c for trans = 'T'or't',
where c is an n-by-n symmetric matrix;
a and b are n-by-k matrices, if trans = 'N'or'n',
a and b are k-by-n matrices, if trans = 'T'or't'.
|
void |
BaseLevel2.trmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
trmv computes a matrix-vector product using a triangular matrix.
|
void |
BaseLevel3.trsm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
double alpha,
INDArray A,
INDArray B)
?trsm solves one of the following matrix equations:
op(a)*x = alpha*b or x*op(a) = alpha*b,
where x and b are m-by-n general matrices, and a is triangular;
op(a) must be an m-by-m matrix, if side = 'L'or'l'
op(a) must be an n-by-n matrix, if side = 'R'or'r'.
|
void |
BaseLevel2.trsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
trsv solves a system of linear equations whose coefficients are in a triangular matrix.
|
protected abstract void |
BaseLevel2.zhpr(char order,
char Uplo,
int N,
INDArray alpha,
IComplexNDArray X,
int incX,
IComplexNDArray A) |
| Constructor and Description |
|---|
GemmParams(INDArray a,
INDArray b,
INDArray c) |
GemmParams(INDArray a,
INDArray b,
INDArray c,
boolean transposeA,
boolean transposeB) |
GemvParameters(INDArray a,
INDArray x,
INDArray y) |
| Modifier and Type | Interface and Description |
|---|---|
interface |
IComplexNDArray
Complex numbers
|
| Modifier and Type | Class and Description |
|---|---|
class |
BaseComplexNDArray
ComplexNDArray for complex numbers.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
BaseComplexNDArray.assign(INDArray arr)
Assign all of the elements in the given
ndarray to this nedarray
|
protected INDArray |
BaseComplexNDArray.create(int[] shape,
char ordering) |
protected INDArray |
BaseComplexNDArray.createScalarForIndex(int i,
boolean applyOffset) |
INDArray |
IComplexNDArray.getReal()
Gets the real portion of this complex ndarray
|
INDArray |
BaseComplexNDArray.getReal() |
INDArray |
IComplexNDArray.imag()
Return all of the imaginary components in this ndarray
|
INDArray |
BaseComplexNDArray.imag()
Get imaginary part of the matrix.
|
INDArray |
BaseComplexNDArray.putScalar(int[] i,
double value) |
INDArray |
IComplexNDArray.putScalar(int[] i,
IComplexNumber complexNumber) |
INDArray |
IComplexNDArray.real()
Return all the real components in this ndarray
|
INDArray |
BaseComplexNDArray.real()
Get realComponent part of the matrix.
|
| Modifier and Type | Method and Description |
|---|---|
IComplexNDArray |
IComplexNDArray.add(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.add(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.add(INDArray other)
copy addition of two matrices
|
IComplexNDArray |
BaseComplexNDArray.add(INDArray other)
copy addition of two matrices
|
IComplexNDArray |
IComplexNDArray.add(INDArray other,
INDArray result)
copy addition of two matrices
|
IComplexNDArray |
BaseComplexNDArray.add(INDArray other,
INDArray result)
copy addition of two matrices
|
IComplexNDArray |
IComplexNDArray.add(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.add(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.addColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.addColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.addi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.addi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.addi(INDArray other)
in place addition of two matrices
|
IComplexNDArray |
BaseComplexNDArray.addi(INDArray other)
in place addition of two matrices
|
IComplexNDArray |
IComplexNDArray.addi(INDArray other,
INDArray result)
in place addition of two matrices
|
IComplexNDArray |
BaseComplexNDArray.addi(INDArray other,
INDArray result)
in place addition of two matrices
|
IComplexNDArray |
IComplexNDArray.addi(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.addi(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.addiRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.addiRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.addRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.addRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
BaseComplexNDArray.assign(INDArray arr)
Assign all of the elements in the given
ndarray to this nedarray
|
void |
IComplexNDArray.checkDimensions(INDArray other)
Validate dimensions are equal
|
void |
BaseComplexNDArray.checkDimensions(INDArray other)
Validate dimensions are equal
|
protected void |
BaseComplexNDArray.copyFromReal(INDArray real) |
protected void |
BaseComplexNDArray.copyImagTo(INDArray arr)
Copy imaginary numbers to the given
ndarray
|
protected void |
BaseComplexNDArray.copyRealTo(INDArray arr)
Copy real numbers to arr
|
protected IComplexNDArray |
BaseComplexNDArray.create(INDArray baseNDArray) |
double |
BaseComplexNDArray.distance1(INDArray other)
Returns the (1-norm) distance.
|
double |
BaseComplexNDArray.distance2(INDArray other)
Returns the (euclidean) distance.
|
IComplexNDArray |
IComplexNDArray.div(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.div(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.div(INDArray other)
in place (element wise) division of two matrices
|
IComplexNDArray |
BaseComplexNDArray.div(INDArray other)
in place (element wise) division of two matrices
|
IComplexNDArray |
IComplexNDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two matrices
|
IComplexNDArray |
BaseComplexNDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two matrices
|
IComplexNDArray |
IComplexNDArray.div(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.div(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.divColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.divColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.divi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.divi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.divi(INDArray other)
in place (element wise) division of two matrices
|
IComplexNDArray |
BaseComplexNDArray.divi(INDArray other)
in place (element wise) division of two matrices
|
IComplexNDArray |
IComplexNDArray.divi(INDArray other,
INDArray result)
in place (element wise) division of two matrices
|
IComplexNDArray |
BaseComplexNDArray.divi(INDArray other,
INDArray result)
in place (element wise) division of two matrices
|
IComplexNDArray |
IComplexNDArray.divi(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.divi(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.diviColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.diviColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.diviRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.diviRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.divRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.divRowVector(INDArray rowVector)
In place addition of a column vector
|
protected IComplexNDArray |
BaseComplexNDArray.doColumnWise(INDArray columnVector,
char operation) |
protected IComplexNDArray |
BaseComplexNDArray.doRowWise(INDArray rowVector,
char operation) |
IComplexNDArray |
IComplexNDArray.eps(INDArray other)
epsilon equals than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
IComplexNDArray |
BaseComplexNDArray.eps(INDArray other)
epsilon equals than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
IComplexNDArray |
IComplexNDArray.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
|
IComplexNDArray |
BaseComplexNDArray.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
|
IComplexNDArray |
IComplexNDArray.eq(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.eq(INDArray other) |
IComplexNDArray |
IComplexNDArray.eqi(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.eqi(INDArray other) |
IComplexNDArray |
IComplexNDArray.gt(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.gt(INDArray other) |
IComplexNDArray |
IComplexNDArray.gti(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.gti(INDArray other) |
IComplexNDArray |
IComplexNDArray.lt(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.lt(INDArray other) |
IComplexNDArray |
IComplexNDArray.lti(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.lti(INDArray other) |
IComplexNDArray |
IComplexNDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
IComplexNDArray |
BaseComplexNDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
IComplexNDArray |
IComplexNDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
IComplexNDArray |
BaseComplexNDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
IComplexNDArray |
IComplexNDArray.mmuli(INDArray other)
Perform an copy matrix multiplication
|
IComplexNDArray |
BaseComplexNDArray.mmuli(INDArray other)
Perform an copy matrix multiplication
|
IComplexNDArray |
IComplexNDArray.mmuli(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
IComplexNDArray |
BaseComplexNDArray.mmuli(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
IComplexNDArray |
IComplexNDArray.mul(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.mul(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.mul(INDArray other)
copy (element wise) multiplication of two matrices
|
IComplexNDArray |
BaseComplexNDArray.mul(INDArray other)
copy (element wise) multiplication of two matrices
|
IComplexNDArray |
IComplexNDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two matrices
|
IComplexNDArray |
BaseComplexNDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two matrices
|
IComplexNDArray |
IComplexNDArray.mul(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.mul(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.mulColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.mulColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.muli(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.muli(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.muli(INDArray other)
in place (element wise) multiplication of two matrices
|
IComplexNDArray |
BaseComplexNDArray.muli(INDArray other)
in place (element wise) multiplication of two matrices
|
IComplexNDArray |
IComplexNDArray.muli(INDArray other,
INDArray result)
in place (element wise) multiplication of two matrices
|
IComplexNDArray |
BaseComplexNDArray.muli(INDArray other,
INDArray result)
in place (element wise) multiplication of two matrices
|
IComplexNDArray |
IComplexNDArray.muli(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.muli(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.muliColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.muliColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.muliRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.muliRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.mulRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.mulRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.neq(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.neq(INDArray other) |
IComplexNDArray |
IComplexNDArray.neqi(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.neqi(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.put(INDArrayIndex[] indices,
INDArray element) |
IComplexNDArray |
IComplexNDArray.put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
IComplexNDArray |
BaseComplexNDArray.put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
IComplexNDArray |
IComplexNDArray.put(int i,
INDArray element)
Inserts the element at the specified index
|
IComplexNDArray |
BaseComplexNDArray.put(int i,
INDArray element)
Inserts the element at the specified index
|
IComplexNDArray |
IComplexNDArray.put(int i,
int j,
INDArray element)
Inserts the element at the specified index
|
IComplexNDArray |
BaseComplexNDArray.put(int i,
int j,
INDArray element)
Inserts the element at the specified index
|
IComplexNDArray |
IComplexNDArray.putColumn(int column,
INDArray toPut)
Insert a column in to this array
Will throw an exception if this
ndarray is not a matrix
|
IComplexNDArray |
BaseComplexNDArray.putColumn(int column,
INDArray toPut)
Insert a column in to this array
Will throw an exception if this
ndarray is not a matrix
|
IComplexNDArray |
IComplexNDArray.putRow(int row,
INDArray toPut)
Insert a row in to this array
Will throw an exception if this
ndarray is not a matrix
|
IComplexNDArray |
BaseComplexNDArray.putRow(int row,
INDArray toPut)
Insert a row in to this array
Will throw an exception if this
ndarray is not a matrix
|
IComplexNDArray |
IComplexNDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
IComplexNDArray |
BaseComplexNDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
IComplexNDArray |
IComplexNDArray.rdiv(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.rdiv(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.rdiv(INDArray other)
Reverse division
|
IComplexNDArray |
BaseComplexNDArray.rdiv(INDArray other)
Reverse division
|
IComplexNDArray |
IComplexNDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
IComplexNDArray |
BaseComplexNDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
IComplexNDArray |
IComplexNDArray.rdiv(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.rdiv(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.rdivColumnVector(INDArray columnVector) |
IComplexNDArray |
BaseComplexNDArray.rdivColumnVector(INDArray columnVector) |
IComplexNDArray |
IComplexNDArray.rdivi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.rdivi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.rdivi(INDArray other)
Reverse divsion (in place)
|
IComplexNDArray |
BaseComplexNDArray.rdivi(INDArray other)
Reverse divsion (in place)
|
IComplexNDArray |
IComplexNDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
IComplexNDArray |
BaseComplexNDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
IComplexNDArray |
IComplexNDArray.rdivi(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.rdivi(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.rdiviColumnVector(INDArray columnVector) |
IComplexNDArray |
BaseComplexNDArray.rdiviColumnVector(INDArray columnVector) |
IComplexNDArray |
IComplexNDArray.rdiviRowVector(INDArray rowVector) |
IComplexNDArray |
BaseComplexNDArray.rdiviRowVector(INDArray rowVector) |
IComplexNDArray |
IComplexNDArray.rdivRowVector(INDArray rowVector) |
IComplexNDArray |
BaseComplexNDArray.rdivRowVector(INDArray rowVector) |
IComplexNDArray |
IComplexNDArray.rsub(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.rsub(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.rsub(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.rsub(INDArray other) |
IComplexNDArray |
IComplexNDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
IComplexNDArray |
BaseComplexNDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
IComplexNDArray |
IComplexNDArray.rsub(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.rsub(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.rsubColumnVector(INDArray columnVector) |
IComplexNDArray |
BaseComplexNDArray.rsubColumnVector(INDArray columnVector) |
IComplexNDArray |
IComplexNDArray.rsubi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.rsubi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.rsubi(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.rsubi(INDArray other) |
IComplexNDArray |
IComplexNDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
IComplexNDArray |
BaseComplexNDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
IComplexNDArray |
IComplexNDArray.rsubi(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.rsubi(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.rsubiColumnVector(INDArray columnVector) |
IComplexNDArray |
BaseComplexNDArray.rsubiColumnVector(INDArray columnVector) |
IComplexNDArray |
IComplexNDArray.rsubiRowVector(INDArray rowVector) |
IComplexNDArray |
BaseComplexNDArray.rsubiRowVector(INDArray rowVector) |
IComplexNDArray |
IComplexNDArray.rsubRowVector(INDArray rowVector) |
IComplexNDArray |
BaseComplexNDArray.rsubRowVector(INDArray rowVector) |
double |
BaseComplexNDArray.squaredDistance(INDArray other)
Returns the squared (Euclidean) distance.
|
IComplexNDArray |
IComplexNDArray.sub(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.sub(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.sub(INDArray other)
copy subtraction of two matrices
|
IComplexNDArray |
BaseComplexNDArray.sub(INDArray other)
copy subtraction of two matrices
|
IComplexNDArray |
IComplexNDArray.sub(INDArray other,
INDArray result)
copy subtraction of two matrices
|
IComplexNDArray |
BaseComplexNDArray.sub(INDArray other,
INDArray result)
copy subtraction of two matrices
|
IComplexNDArray |
IComplexNDArray.sub(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.sub(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.subColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.subColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.subi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.subi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.subi(INDArray other)
in place subtraction of two matrices
|
IComplexNDArray |
BaseComplexNDArray.subi(INDArray other)
in place subtraction of two matrices
|
IComplexNDArray |
IComplexNDArray.subi(INDArray other,
INDArray result)
in place subtraction of two matrices
|
IComplexNDArray |
BaseComplexNDArray.subi(INDArray other,
INDArray result)
in place subtraction of two matrices
|
IComplexNDArray |
IComplexNDArray.subi(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.subi(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.subiColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.subiColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.subiRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.subiRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.subRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.subRowVector(INDArray rowVector)
In place addition of a column vector
|
| Constructor and Description |
|---|
BaseComplexNDArray(INDArray m)
Construct a complex matrix from a realComponent matrix.
|
BaseComplexNDArray(INDArray m,
char ordering)
Construct a complex matrix from a realComponent matrix.
|
BaseComplexNDArray(INDArray m,
int[] stride)
Create with the specified ndarray as the real component
and the given stride
|
BaseComplexNDArray(INDArray m,
int[] stride,
char ordering)
Initialize the given ndarray as the real component
|
| Modifier and Type | Method and Description |
|---|---|
void |
AffinityManager.touch(INDArray array)
Utility method, to associate INDArray with specific device (backend-specific)
|
| Modifier and Type | Method and Description |
|---|---|
void |
Instrumentation.log(INDArray toLog)
Log the given ndarray
|
void |
InMemoryInstrumentation.log(INDArray toLog) |
void |
Instrumentation.log(INDArray toLog,
String status)
Log the given ndarray
|
void |
InMemoryInstrumentation.log(INDArray toLog,
String status) |
| Constructor and Description |
|---|
LogEntry(INDArray toLog) |
LogEntry(INDArray toLog,
StackTraceElement[] stackTraceElements) |
LogEntry(INDArray toLog,
StackTraceElement[] stackTraceElements,
String status) |
LogEntry(INDArray toLog,
String status) |
| Constructor and Description |
|---|
FirstAxisIterator(INDArray iterateOver) |
INDArrayIterator(INDArray iterateOver) |
| Modifier and Type | Class and Description |
|---|---|
class |
BaseNDArray
NDArray: (think numpy)
A few things of note.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
BaseNDArray.add(INDArray other)
copy addition of two matrices
|
INDArray |
INDArray.add(INDArray other)
copy addition of two NDArrays
|
INDArray |
BaseNDArray.add(INDArray other,
INDArray result)
copy addition of two matrices
|
INDArray |
INDArray.add(INDArray other,
INDArray result)
copy addition of two NDArrays
|
INDArray |
BaseNDArray.add(Number n) |
INDArray |
INDArray.add(Number n)
Scalar addition (cloning)
|
INDArray |
BaseNDArray.add(Number n,
INDArray result) |
INDArray |
INDArray.add(Number n,
INDArray result) |
INDArray |
BaseNDArray.addColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.addColumnVector(INDArray columnVector)
Addition of a column vector (copy)
|
INDArray |
BaseNDArray.addi(INDArray other)
in place addition of two matrices
|
INDArray |
INDArray.addi(INDArray other)
in place addition of two NDArrays
|
INDArray |
BaseNDArray.addi(INDArray other,
INDArray result)
in place addition of two matrices
|
INDArray |
INDArray.addi(INDArray other,
INDArray result)
in place addition of two NDArrays
|
INDArray |
BaseNDArray.addi(Number n) |
INDArray |
INDArray.addi(Number n)
In place scalar addition
|
INDArray |
BaseNDArray.addi(Number n,
INDArray result) |
INDArray |
INDArray.addi(Number n,
INDArray result)
In place addition
|
INDArray |
BaseNDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
BaseNDArray.addiRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.addiRowVector(INDArray rowVector)
In place addition of a row vector
|
INDArray |
BaseNDArray.addRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.addRowVector(INDArray rowVector)
Addition of a row vector (copy)
|
INDArray |
BaseNDArray.assign(INDArray arr)
Assign all of the elements in the given
ndarray to this ndarray
|
INDArray |
INDArray.assign(INDArray arr)
Assign all of the elements in the given
ndarray to this ndarray
|
INDArray |
BaseNDArray.assign(Number value)
Set the value of the ndarray to the specified value
|
INDArray |
INDArray.assign(Number value)
Set the value of the ndarray to the specified value
|
INDArray |
BaseNDArray.assignIf(INDArray arr,
Condition condition)
Assign all elements from given ndarray that are matching given condition,
ndarray to this ndarray
|
INDArray |
INDArray.assignIf(INDArray arr,
Condition condition)
Assign all elements from given ndarray that are matching given condition,
ndarray to this ndarray
|
INDArray |
BaseNDArray.broadcast(int... shape)
Broadcasts this ndarray to be the specified shape
|
INDArray |
INDArray.broadcast(int... shape)
Broadcasts this ndarray to be the specified shape
|
INDArray |
BaseNDArray.cond(Condition condition) |
INDArray |
INDArray.cond(Condition condition)
1 in the ndarray if the element matches
the condition 0 otherwise
|
INDArray |
BaseNDArray.condi(Condition condition) |
INDArray |
INDArray.condi(Condition condition)
1 in the ndarray if the element matches
the condition 0 otherwise
|
protected INDArray |
BaseNDArray.create(BaseNDArray baseNDArray) |
protected INDArray |
BaseNDArray.create(DataBuffer buffer) |
protected INDArray |
BaseNDArray.create(DataBuffer data,
int[] shape,
int offset) |
protected INDArray |
BaseNDArray.create(DataBuffer data,
int[] shape,
int[] strides) |
protected INDArray |
BaseNDArray.create(DataBuffer data,
int[] newShape,
int[] newStrides,
int offset) |
protected INDArray |
BaseNDArray.create(DataBuffer data,
int[] newShape,
int[] newStrides,
int offset,
char ordering) |
protected INDArray |
BaseNDArray.create(int[] shape) |
protected INDArray |
BaseNDArray.create(int[] shape,
char ordering) |
protected INDArray |
BaseNDArray.create(int[] shape,
int[] strides,
int offset) |
protected INDArray |
BaseNDArray.create(int rows,
int length) |
protected INDArray |
BaseNDArray.createScalar(double d) |
protected INDArray |
BaseNDArray.createScalarForIndex(int i,
boolean applyOffset) |
INDArray |
BaseNDArray.cumsum(int dimension)
Cumulative sum along a dimension (in place)
|
INDArray |
INDArray.cumsum(int dimension)
Cumulative sum along a dimension (in place)
|
INDArray |
BaseNDArray.cumsumi(int dimension)
Cumulative sum along a dimension
|
INDArray |
INDArray.cumsumi(int dimension)
Cumulative sum along a dimension
|
INDArray |
BaseNDArray.dimShuffle(Object[] rearrange,
int[] newOrder,
boolean[] broadCastable)
Dimshuffle: an extension of permute that adds the ability
to broadcast various dimensions.
|
INDArray |
INDArray.dimShuffle(Object[] rearrange,
int[] newOrder,
boolean[] broadCastable)
Dimshuffle: an extension of permute that adds the ability
to broadcast various dimensions.
|
INDArray |
BaseNDArray.div(INDArray other)
in place (element wise) division of two matrices
|
INDArray |
INDArray.div(INDArray other)
Copy (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two matrices
|
INDArray |
INDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.div(Number n) |
INDArray |
INDArray.div(Number n)
Division by a number
|
INDArray |
BaseNDArray.div(Number n,
INDArray result) |
INDArray |
INDArray.div(Number n,
INDArray result) |
INDArray |
BaseNDArray.divColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.divColumnVector(INDArray columnVector)
Division of a column vector (copy)
|
INDArray |
BaseNDArray.divi(INDArray other)
in place (element wise) division of two matrices
|
INDArray |
INDArray.divi(INDArray other)
in place (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.divi(INDArray other,
INDArray result)
in place (element wise) division of two matrices
|
INDArray |
INDArray.divi(INDArray other,
INDArray result)
in place (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.divi(Number n) |
INDArray |
INDArray.divi(Number n)
In place scalar division
|
INDArray |
BaseNDArray.divi(Number n,
INDArray result) |
INDArray |
INDArray.divi(Number n,
INDArray result)
In place division of this ndarray
|
INDArray |
BaseNDArray.diviColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.diviColumnVector(INDArray columnVector)
In place division of a column vector
|
INDArray |
BaseNDArray.diviRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.diviRowVector(INDArray rowVector)
In place division of a row vector
|
INDArray |
BaseNDArray.divRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.divRowVector(INDArray rowVector)
Division of a row vector (copy)
|
protected INDArray |
BaseNDArray.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 INDArray |
BaseNDArray.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 |
BaseNDArray.dup() |
INDArray |
INDArray.dup()
Return a copy of this ndarray
|
INDArray |
BaseNDArray.dup(char order) |
INDArray |
INDArray.dup(char order)
Return a copy of this ndarray, where the returned ndarray has the specified order
|
INDArray |
BaseNDArray.eps(INDArray other)
epsilon equals than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
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 |
BaseNDArray.eps(Number other)
Returns an ndarray with 1 if the element is epsilon equals
|
INDArray |
INDArray.eps(Number other)
Returns an ndarray with 1 if the element is epsilon equals
|
INDArray |
BaseNDArray.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 |
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 |
BaseNDArray.epsi(Number other)
Returns an ndarray with 1 if the element is epsilon equals
|
INDArray |
INDArray.epsi(Number other)
Returns an ndarray with 1 if the element is epsilon equals
|
INDArray |
BaseNDArray.eq(INDArray other) |
INDArray |
INDArray.eq(INDArray other)
equal than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
BaseNDArray.eq(Number other) |
INDArray |
INDArray.eq(Number other)
Returns an ndarray with 1 if the element is less than
the given element 0 other wise
|
INDArray |
BaseNDArray.eqi(INDArray other) |
INDArray |
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 |
BaseNDArray.eqi(Number other) |
INDArray |
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
|
INDArray |
BaseNDArray.get(INDArrayIndex... indexes)
Returns a subset of this array based on the specified
indexes
|
INDArray |
INDArray.get(INDArrayIndex... indexes)
Returns a subset of this array based on the specified
indexes
|
INDArray |
BaseNDArray.getColumn(int c)
Get the specified column
|
INDArray |
INDArray.getColumn(int i)
Returns the specified column.
|
INDArray |
BaseNDArray.getColumns(int... cindices)
Get whole columns
from the passed indices.
|
INDArray |
INDArray.getColumns(int... columns)
Get a list of specified columns
|
INDArray |
BaseNDArray.getRow(int r)
Get a copy of a row.
|
INDArray |
INDArray.getRow(int i)
Returns the specified row.
|
INDArray |
INDArray.getRows(int... rows)
Get a list of rows
|
INDArray |
BaseNDArray.getRows(int[] rindices)
Get whole rows from the passed indices.
|
INDArray |
BaseNDArray.getScalar(int... indexes)
Fetch a particular number on a multi dimensional scale.
|
INDArray |
INDArray.getScalar(int... indices)
Returns the elements at the the specified indices
|
INDArray |
BaseNDArray.getScalar(int i) |
INDArray |
INDArray.getScalar(int i)
Returns the element at the specified index
|
INDArray |
BaseNDArray.getScalar(int row,
int column)
Returns the element at the specified row/column
This will throw an exception if the
|
INDArray |
INDArray.getScalar(int row,
int column)
Returns the element at the specified row/column
This will throw an exception if the
|
INDArray |
BaseNDArray.gt(INDArray other) |
INDArray |
INDArray.gt(INDArray other)
greater than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
BaseNDArray.gt(Number other) |
INDArray |
INDArray.gt(Number other)
Greater than boolean (copying)(
|
INDArray |
BaseNDArray.gti(INDArray other) |
INDArray |
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 |
BaseNDArray.gti(Number other) |
INDArray |
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
|
INDArray |
BaseNDArray.linearView()
Returns a linear view reference of shape
1,length(ndarray)
|
INDArray |
INDArray.linearView()
Returns a linear view reference of shape
1,length(ndarray)
|
INDArray |
BaseNDArray.linearViewColumnOrder() |
INDArray |
INDArray.linearViewColumnOrder()
Returns a linear view reference of shape
1,length(ndarray)
|
INDArray |
BaseNDArray.lt(INDArray other) |
INDArray |
INDArray.lt(INDArray other)
less than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
BaseNDArray.lt(Number other) |
INDArray |
INDArray.lt(Number other)
Returns an ndarray with 1 if the element is less than
the given element 0 other wise
|
INDArray |
BaseNDArray.lti(INDArray other) |
INDArray |
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 |
BaseNDArray.lti(Number other) |
INDArray |
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
|
INDArray |
BaseNDArray.max(int... dimension)
Returns the overall max of this ndarray
|
INDArray |
INDArray.max(int... dimension)
Returns the overall max of this ndarray
|
INDArray |
BaseNDArray.mean(int... dimension)
Returns the overall mean of this ndarray
|
INDArray |
INDArray.mean(int... dimension)
Returns the overall mean of this ndarray
|
INDArray |
BaseNDArray.min(int... dimension)
Returns the overall min of this ndarray
|
INDArray |
INDArray.min(int... dimension)
Returns the overall min of this ndarray
|
INDArray |
BaseNDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
INDArray |
INDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
INDArray |
BaseNDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
BaseNDArray.mmuli(INDArray other)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmuli(INDArray other)
Perform an inplace matrix multiplication
|
INDArray |
BaseNDArray.mmuli(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmuli(INDArray other,
INDArray result)
Perform an inplace matrix multiplication
|
INDArray |
BaseNDArray.mul(INDArray other)
copy (element wise) multiplication of two matrices
|
INDArray |
INDArray.mul(INDArray other)
copy (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two matrices
|
INDArray |
INDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.mul(Number n) |
INDArray |
INDArray.mul(Number n)
Scalar multiplication (copy)
|
INDArray |
BaseNDArray.mul(Number n,
INDArray result) |
INDArray |
INDArray.mul(Number n,
INDArray result) |
INDArray |
BaseNDArray.mulColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.mulColumnVector(INDArray columnVector)
Multiplication of a column vector (copy)
|
INDArray |
BaseNDArray.muli(INDArray other)
in place (element wise) multiplication of two matrices
|
INDArray |
INDArray.muli(INDArray other)
in place (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.muli(INDArray other,
INDArray result)
in place (element wise) multiplication of two matrices
|
INDArray |
INDArray.muli(INDArray other,
INDArray result)
in place (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.muli(Number n) |
INDArray |
INDArray.muli(Number n)
In place scalar multiplication
|
INDArray |
BaseNDArray.muli(Number n,
INDArray result) |
INDArray |
INDArray.muli(Number n,
INDArray result)
In place multiplication of this ndarray
|
INDArray |
BaseNDArray.muliColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.muliColumnVector(INDArray columnVector)
In place multiplication of a column vector
|
INDArray |
BaseNDArray.muliRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.muliRowVector(INDArray rowVector)
In place multiplication of a row vector
|
INDArray |
BaseNDArray.mulRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.mulRowVector(INDArray rowVector)
Multiplication of a row vector (copy)
|
INDArray |
BaseNDArray.neg()
Negate each element.
|
INDArray |
INDArray.neg()
Returns the ndarray negative (cloned)
|
INDArray |
BaseNDArray.negi()
Negate each element (in-place).
|
INDArray |
INDArray.negi()
In place setting of the negative version of this ndarray
|
INDArray |
BaseNDArray.neq(INDArray other) |
INDArray |
INDArray.neq(INDArray other) |
INDArray |
BaseNDArray.neq(Number other) |
INDArray |
INDArray.neq(Number other)
Not equal
|
INDArray |
BaseNDArray.neqi(INDArray other) |
INDArray |
INDArray.neqi(INDArray other) |
INDArray |
BaseNDArray.neqi(Number other) |
INDArray |
INDArray.neqi(Number other)
In place not equal
|
protected INDArray |
BaseNDArray.newShape(int[] newShape,
char ordering) |
INDArray |
BaseNDArray.norm1(int... dimension)
Returns the norm1 along the specified dimension
|
INDArray |
INDArray.norm1(int... dimension)
Returns the norm1 along the specified dimension
|
INDArray |
BaseNDArray.norm2(int... dimension)
Returns the norm2 along the specified dimension
|
INDArray |
INDArray.norm2(int... dimension)
Returns the norm2 along the specified dimension
|
INDArray |
BaseNDArray.normmax(int... dimension)
Returns the normmax along the specified dimension
|
INDArray |
INDArray.normmax(int... dimension)
Returns the normmax along the specified dimension
|
INDArray |
BaseNDArray.permute(int... rearrange)
See: http://www.mathworks.com/help/matlab/ref/permute.html
|
INDArray |
INDArray.permute(int... rearrange)
See: http://www.mathworks.com/help/matlab/ref/permute.html
|
INDArray |
BaseNDArray.permutei(int... rearrange)
An in-place version of permute.
|
INDArray |
INDArray.permutei(int... rearrange)
An in-place version of permute.
|
INDArray |
BaseNDArray.prod(int... dimension)
Returns the product along a given dimension
|
INDArray |
INDArray.prod(int... dimension)
Returns the product along a given dimension
|
INDArray |
BaseNDArray.put(INDArrayIndex[] indices,
INDArray element) |
INDArray |
INDArray.put(INDArrayIndex[] indices,
INDArray element)
Put the elements of the ndarray
in to the specified indices
|
INDArray |
BaseNDArray.put(INDArrayIndex[] indices,
Number element) |
INDArray |
INDArray.put(INDArrayIndex[] indices,
Number element)
Put the elements of the ndarray
in to the specified indices
|
INDArray |
BaseNDArray.put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
INDArray |
INDArray.put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseNDArray.put(int i,
INDArray element)
Inserts the element at the specified index
|
INDArray |
INDArray.put(int i,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseNDArray.put(int i,
int j,
INDArray element)
Inserts the element at the specified index
|
INDArray |
INDArray.put(int i,
int j,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseNDArray.put(int i,
int j,
Number element)
Inserts the element at the specified index
|
INDArray |
INDArray.put(int i,
int j,
Number element)
Inserts the element at the specified index
|
INDArray |
BaseNDArray.putColumn(int column,
INDArray toPut)
Insert a column in to this array
Will throw an exception if this
ndarray is not a matrix
|
INDArray |
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 |
BaseNDArray.putRow(int row,
INDArray toPut)
Insert a row in to this array
Will throw an exception if this
ndarray is not a matrix
|
INDArray |
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 |
BaseNDArray.putScalar(int[] indexes,
double value) |
INDArray |
INDArray.putScalar(int[] i,
double value)
Insert the item at the specified indices
|
INDArray |
BaseNDArray.putScalar(int[] indexes,
float value) |
INDArray |
INDArray.putScalar(int[] indexes,
float value) |
INDArray |
BaseNDArray.putScalar(int[] indexes,
int value) |
INDArray |
INDArray.putScalar(int[] indexes,
int value) |
INDArray |
BaseNDArray.putScalar(int i,
double value) |
INDArray |
INDArray.putScalar(int i,
double value)
Insert the number linearly in to the ndarray
|
INDArray |
BaseNDArray.putScalar(int i,
float value) |
INDArray |
INDArray.putScalar(int i,
float value)
Insert a scalar float at the specified index
|
INDArray |
BaseNDArray.putScalar(int i,
int value) |
INDArray |
INDArray.putScalar(int i,
int value)
Insert a scalar int at the specified index
|
INDArray |
BaseNDArray.putScalar(int row,
int col,
double value) |
INDArray |
INDArray.putScalar(int row,
int col,
double value)
Insert the value at the specified indices, in a 2d (rank 2) NDArray
Equivalent to putScalar(int[], double) but avoids int[] creation |
INDArray |
BaseNDArray.putScalar(int dim0,
int dim1,
int dim2,
double value) |
INDArray |
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 putScalar(int[], double) but avoids int[] creation |
INDArray |
BaseNDArray.putScalar(int dim0,
int dim1,
int dim2,
int dim3,
double value) |
INDArray |
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 putScalar(int[], double) but avoids int[] creation |
INDArray |
BaseNDArray.putScalarUnsafe(int offset,
double value) |
INDArray |
INDArray.putScalarUnsafe(int offset,
double value)
Insert a scalar
at the given linear offset
|
INDArray |
BaseNDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
INDArray |
INDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
INDArray |
BaseNDArray.ravel()
Flattens the array for linear indexing
|
INDArray |
INDArray.ravel()
Returns a flattened version (row vector) of this ndarray
|
INDArray |
BaseNDArray.ravel(char ordering)
Flattens the array for linear indexing
|
INDArray |
INDArray.ravel(char order)
Returns a flattened version (row vector) of this ndarray
|
INDArray |
BaseNDArray.rdiv(INDArray other)
Reverse division
|
INDArray |
INDArray.rdiv(INDArray other)
Reverse division
|
INDArray |
BaseNDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
INDArray |
INDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
INDArray |
BaseNDArray.rdiv(Number n) |
INDArray |
INDArray.rdiv(Number n)
Reverse division
|
INDArray |
BaseNDArray.rdiv(Number n,
INDArray result) |
INDArray |
INDArray.rdiv(Number n,
INDArray result)
Reverse division (number / ndarray)
|
INDArray |
BaseNDArray.rdivColumnVector(INDArray columnVector) |
INDArray |
INDArray.rdivColumnVector(INDArray columnVector)
Reverse division of a column vector (copy)
|
INDArray |
BaseNDArray.rdivi(INDArray other)
Reverse divsion (in place)
|
INDArray |
INDArray.rdivi(INDArray other)
Reverse divsion (in place)
|
INDArray |
BaseNDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
INDArray |
INDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
INDArray |
BaseNDArray.rdivi(Number n) |
INDArray |
INDArray.rdivi(Number n)
In place reverse division
|
INDArray |
BaseNDArray.rdivi(Number n,
INDArray result) |
INDArray |
INDArray.rdivi(Number n,
INDArray result)
Reverse in place division
|
INDArray |
BaseNDArray.rdiviColumnVector(INDArray columnVector) |
INDArray |
INDArray.rdiviColumnVector(INDArray columnVector)
In place reverse divison of a column vector
|
INDArray |
BaseNDArray.rdiviRowVector(INDArray rowVector) |
INDArray |
INDArray.rdiviRowVector(INDArray rowVector)
In place reverse division of a column vector
|
INDArray |
BaseNDArray.rdivRowVector(INDArray rowVector) |
INDArray |
INDArray.rdivRowVector(INDArray rowVector)
Reverse division of a column vector (copy)
|
INDArray |
NdArrayJSONReader.read(File jsonFile) |
INDArray |
BaseNDArray.repeat(int... repeats) |
INDArray |
INDArray.repeat(int... repeats)
Returns a flat array
with the elements repeated k times along each given dimension
|
INDArray |
BaseNDArray.repeat(int dimension,
int... repeats) |
INDArray |
INDArray.repeat(int dimension,
int... repeats)
Repeat elements along a specified dimension.
|
INDArray |
BaseNDArray.replaceWhere(INDArray arr,
Condition condition)
Replaces all elements in this ndarray that are matching give condition, with corresponding elements from given array
|
INDArray |
INDArray.replaceWhere(INDArray arr,
Condition condition)
Replaces all elements in this ndarray that are matching give condition, with corresponding elements from given array
|
INDArray |
INDArray.repmat(int... shape)
Replicate and tile array to fill out to the given shape
|
INDArray |
BaseNDArray.repmat(int[] shape)
Replicate and tile array to fill out to the given shape
|
INDArray |
BaseNDArray.reshape(char order,
int... newShape) |
INDArray |
INDArray.reshape(char order,
int... newShape)
Reshapes the ndarray (can't change the length of the ndarray)
|
INDArray |
BaseNDArray.reshape(char order,
int rows,
int columns) |
INDArray |
INDArray.reshape(char order,
int rows,
int columns)
Reshapes the ndarray (can't change the length of the ndarray)
|
INDArray |
BaseNDArray.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 |
INDArray.reshape(int... newShape)
Reshapes the ndarray (can't change the length of the ndarray)
|
INDArray |
BaseNDArray.reshape(int newRows,
int newColumns)
Reshape the matrix.
|
INDArray |
INDArray.reshape(int rows,
int columns)
Reshapes the ndarray (can't change the length of the ndarray)
|
INDArray |
BaseNDArray.rsub(INDArray other) |
INDArray |
INDArray.rsub(INDArray other) |
INDArray |
BaseNDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
INDArray |
INDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
INDArray |
BaseNDArray.rsub(Number n) |
INDArray |
INDArray.rsub(Number n)
Reverse subtraction with duplicates
|
INDArray |
BaseNDArray.rsub(Number n,
INDArray result) |
INDArray |
INDArray.rsub(Number n,
INDArray result)
Reverse subtraction
|
INDArray |
BaseNDArray.rsubColumnVector(INDArray columnVector) |
INDArray |
INDArray.rsubColumnVector(INDArray columnVector)
Reverse subtraction of a column vector (copy)
|
INDArray |
BaseNDArray.rsubi(INDArray other) |
INDArray |
INDArray.rsubi(INDArray other) |
INDArray |
BaseNDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
INDArray |
INDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
INDArray |
BaseNDArray.rsubi(Number n) |
INDArray |
INDArray.rsubi(Number n) |
INDArray |
BaseNDArray.rsubi(Number n,
INDArray result) |
INDArray |
INDArray.rsubi(Number n,
INDArray result)
Reverse in place subtraction
|
INDArray |
BaseNDArray.rsubiColumnVector(INDArray columnVector) |
INDArray |
INDArray.rsubiColumnVector(INDArray columnVector)
In place reverse subtraction of a column vector
|
INDArray |
BaseNDArray.rsubiRowVector(INDArray rowVector) |
INDArray |
INDArray.rsubiRowVector(INDArray rowVector)
In place reverse subtraction of a row vector
|
INDArray |
BaseNDArray.rsubRowVector(INDArray rowVector) |
INDArray |
INDArray.rsubRowVector(INDArray rowVector)
Reverse subtraction of a row vector (copy)
|
INDArray |
BaseNDArray.slice(int slice)
Returns the specified slice of this matrix.
|
INDArray |
INDArray.slice(int i)
Returns the specified slice of this ndarray
|
INDArray |
BaseNDArray.slice(int slice,
int dimension)
Returns the slice of this from the specified dimension
|
INDArray |
INDArray.slice(int i,
int dimension)
Returns the specified slice of this ndarray
|
INDArray |
BaseNDArray.std(boolean biasCorrected,
int... dimension) |
INDArray |
INDArray.std(boolean biasCorrected,
int... dimension)
Standard deviation of an ndarray along a dimension
|
INDArray |
BaseNDArray.std(int... dimension)
Standard deviation of an ndarray along a dimension
|
INDArray |
INDArray.std(int... dimension)
Standard deviation of an ndarray along a dimension
|
INDArray |
BaseNDArray.sub(INDArray other)
copy subtraction of two matrices
|
INDArray |
INDArray.sub(INDArray other)
copy subtraction of two NDArrays
|
INDArray |
BaseNDArray.sub(INDArray other,
INDArray result)
copy subtraction of two matrices
|
INDArray |
INDArray.sub(INDArray other,
INDArray result)
copy subtraction of two NDArrays
|
INDArray |
BaseNDArray.sub(Number n) |
INDArray |
INDArray.sub(Number n)
Scalar subtraction (copied)
|
INDArray |
BaseNDArray.sub(Number n,
INDArray result) |
INDArray |
INDArray.sub(Number n,
INDArray result) |
INDArray |
BaseNDArray.subArray(int[] offsets,
int[] shape,
int[] stride) |
INDArray |
INDArray.subArray(int[] offsets,
int[] shape,
int[] stride) |
INDArray |
BaseNDArray.subArray(ShapeOffsetResolution resolution) |
INDArray |
INDArray.subArray(ShapeOffsetResolution resolution)
Sub array based on the
pre calculated shape,strides, offsets
|
INDArray |
BaseNDArray.subColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.subColumnVector(INDArray columnVector)
Subtraction of a column vector (copy)
|
INDArray |
BaseNDArray.subi(INDArray other)
in place subtraction of two matrices
|
INDArray |
INDArray.subi(INDArray other)
in place subtraction of two NDArrays
|
INDArray |
BaseNDArray.subi(INDArray other,
INDArray result)
in place subtraction of two matrices
|
INDArray |
INDArray.subi(INDArray other,
INDArray result)
in place subtraction of two NDArrays
|
INDArray |
BaseNDArray.subi(Number n) |
INDArray |
INDArray.subi(Number n)
In place scalar subtraction
|
INDArray |
BaseNDArray.subi(Number n,
INDArray result) |
INDArray |
INDArray.subi(Number n,
INDArray result)
In place subtraction of this ndarray
|
INDArray |
BaseNDArray.subiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.subiColumnVector(INDArray columnVector)
In place subtraction of a column vector
|
INDArray |
BaseNDArray.subiRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.subiRowVector(INDArray rowVector)
In place subtraction of a row vector
|
INDArray |
BaseNDArray.subRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.subRowVector(INDArray rowVector)
Subtraction of a row vector (copy)
|
INDArray |
BaseNDArray.sum(int... dimension)
Returns the sum along the last dimension of this ndarray
|
INDArray |
INDArray.sum(int... dimension)
Returns the sum along the last dimension of this ndarray
|
INDArray |
BaseNDArray.swapAxes(int dimension,
int with)
Mainly here for people coming from numpy.
|
INDArray |
INDArray.swapAxes(int dimension,
int with)
Mainly here for people coming from numpy.
|
INDArray |
BaseNDArray.tensorAlongDimension(int index,
int... dimension) |
INDArray |
INDArray.tensorAlongDimension(int index,
int... dimension)
Get the vector along a particular dimension
|
INDArray |
BaseNDArray.transpose()
Return transposed copy of this matrix.
|
INDArray |
INDArray.transpose()
Flip the rows and columns of a matrix
|
INDArray |
BaseNDArray.transposei()
Return transposed version of this matrix.
|
INDArray |
INDArray.transposei()
Flip the rows and columns of a matrix
|
INDArray |
INDArray.unsafeDuplication() |
INDArray |
BaseNDArray.var(boolean biasCorrected,
int... dimension)
Returns the overall variance of this ndarray
|
INDArray |
INDArray.var(boolean biasCorrected,
int... dimension)
Returns the overall variance of this ndarray
|
INDArray |
BaseNDArray.var(int... dimension)
Returns the overall variance of this ndarray
|
INDArray |
INDArray.var(int... dimension)
Returns the overall variance of this ndarray
|
INDArray |
BaseNDArray.vectorAlongDimension(int index,
int dimension)
Get the vector along a particular dimension
|
INDArray |
INDArray.vectorAlongDimension(int index,
int dimension)
Get the vector along a particular dimension
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
BaseNDArray.add(INDArray other)
copy addition of two matrices
|
INDArray |
INDArray.add(INDArray other)
copy addition of two NDArrays
|
INDArray |
BaseNDArray.add(INDArray other,
INDArray result)
copy addition of two matrices
|
INDArray |
INDArray.add(INDArray other,
INDArray result)
copy addition of two NDArrays
|
INDArray |
BaseNDArray.add(Number n,
INDArray result) |
INDArray |
INDArray.add(Number n,
INDArray result) |
INDArray |
BaseNDArray.addColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.addColumnVector(INDArray columnVector)
Addition of a column vector (copy)
|
INDArray |
BaseNDArray.addi(INDArray other)
in place addition of two matrices
|
INDArray |
INDArray.addi(INDArray other)
in place addition of two NDArrays
|
INDArray |
BaseNDArray.addi(INDArray other,
INDArray result)
in place addition of two matrices
|
INDArray |
INDArray.addi(INDArray other,
INDArray result)
in place addition of two NDArrays
|
INDArray |
BaseNDArray.addi(Number n,
INDArray result) |
INDArray |
INDArray.addi(Number n,
INDArray result)
In place addition
|
INDArray |
BaseNDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
BaseNDArray.addiRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.addiRowVector(INDArray rowVector)
In place addition of a row vector
|
INDArray |
BaseNDArray.addRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.addRowVector(INDArray rowVector)
Addition of a row vector (copy)
|
protected void |
BaseNDArray.assertSlice(INDArray put,
int slice) |
INDArray |
BaseNDArray.assign(INDArray arr)
Assign all of the elements in the given
ndarray to this ndarray
|
INDArray |
INDArray.assign(INDArray arr)
Assign all of the elements in the given
ndarray to this ndarray
|
INDArray |
BaseNDArray.assignIf(INDArray arr,
Condition condition)
Assign all elements from given ndarray that are matching given condition,
ndarray to this ndarray
|
INDArray |
INDArray.assignIf(INDArray arr,
Condition condition)
Assign all elements from given ndarray that are matching given condition,
ndarray to this ndarray
|
void |
BaseNDArray.checkDimensions(INDArray other) |
void |
INDArray.checkDimensions(INDArray other)
Validate dimensions are equal
|
protected void |
BaseNDArray.copyRealTo(INDArray arr) |
double |
BaseNDArray.distance1(INDArray other)
Returns the (1-norm) distance.
|
double |
INDArray.distance1(INDArray other)
Returns the (1-norm) distance.
|
double |
BaseNDArray.distance2(INDArray other)
Returns the (euclidean) distance.
|
double |
INDArray.distance2(INDArray other)
Returns the (euclidean) distance.
|
INDArray |
BaseNDArray.div(INDArray other)
in place (element wise) division of two matrices
|
INDArray |
INDArray.div(INDArray other)
Copy (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two matrices
|
INDArray |
INDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.div(Number n,
INDArray result) |
INDArray |
INDArray.div(Number n,
INDArray result) |
INDArray |
BaseNDArray.divColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.divColumnVector(INDArray columnVector)
Division of a column vector (copy)
|
INDArray |
BaseNDArray.divi(INDArray other)
in place (element wise) division of two matrices
|
INDArray |
INDArray.divi(INDArray other)
in place (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.divi(INDArray other,
INDArray result)
in place (element wise) division of two matrices
|
INDArray |
INDArray.divi(INDArray other,
INDArray result)
in place (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.divi(Number n,
INDArray result) |
INDArray |
INDArray.divi(Number n,
INDArray result)
In place division of this ndarray
|
INDArray |
BaseNDArray.diviColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.diviColumnVector(INDArray columnVector)
In place division of a column vector
|
INDArray |
BaseNDArray.diviRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.diviRowVector(INDArray rowVector)
In place division of a row vector
|
INDArray |
BaseNDArray.divRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.divRowVector(INDArray rowVector)
Division of a row vector (copy)
|
protected INDArray |
BaseNDArray.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 INDArray |
BaseNDArray.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 |
BaseNDArray.eps(INDArray other)
epsilon equals than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
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 |
BaseNDArray.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 |
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 |
BaseNDArray.eq(INDArray other) |
INDArray |
INDArray.eq(INDArray other)
equal than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
BaseNDArray.eqi(INDArray other) |
INDArray |
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 |
BaseNDArray.gt(INDArray other) |
INDArray |
INDArray.gt(INDArray other)
greater than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
BaseNDArray.gti(INDArray other) |
INDArray |
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 |
BaseNDArray.lt(INDArray other) |
INDArray |
INDArray.lt(INDArray other)
less than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
BaseNDArray.lti(INDArray other) |
INDArray |
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 |
BaseNDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
INDArray |
INDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
INDArray |
BaseNDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
BaseNDArray.mmuli(INDArray other)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmuli(INDArray other)
Perform an inplace matrix multiplication
|
INDArray |
BaseNDArray.mmuli(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmuli(INDArray other,
INDArray result)
Perform an inplace matrix multiplication
|
INDArray |
BaseNDArray.mul(INDArray other)
copy (element wise) multiplication of two matrices
|
INDArray |
INDArray.mul(INDArray other)
copy (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two matrices
|
INDArray |
INDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.mul(Number n,
INDArray result) |
INDArray |
INDArray.mul(Number n,
INDArray result) |
INDArray |
BaseNDArray.mulColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.mulColumnVector(INDArray columnVector)
Multiplication of a column vector (copy)
|
INDArray |
BaseNDArray.muli(INDArray other)
in place (element wise) multiplication of two matrices
|
INDArray |
INDArray.muli(INDArray other)
in place (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.muli(INDArray other,
INDArray result)
in place (element wise) multiplication of two matrices
|
INDArray |
INDArray.muli(INDArray other,
INDArray result)
in place (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.muli(Number n,
INDArray result) |
INDArray |
INDArray.muli(Number n,
INDArray result)
In place multiplication of this ndarray
|
INDArray |
BaseNDArray.muliColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.muliColumnVector(INDArray columnVector)
In place multiplication of a column vector
|
INDArray |
BaseNDArray.muliRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.muliRowVector(INDArray rowVector)
In place multiplication of a row vector
|
INDArray |
BaseNDArray.mulRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.mulRowVector(INDArray rowVector)
Multiplication of a row vector (copy)
|
INDArray |
BaseNDArray.neq(INDArray other) |
INDArray |
INDArray.neq(INDArray other) |
INDArray |
BaseNDArray.neqi(INDArray other) |
INDArray |
INDArray.neqi(INDArray other) |
INDArray |
BaseNDArray.put(INDArrayIndex[] indices,
INDArray element) |
INDArray |
INDArray.put(INDArrayIndex[] indices,
INDArray element)
Put the elements of the ndarray
in to the specified indices
|
INDArray |
BaseNDArray.put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
INDArray |
INDArray.put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseNDArray.put(int i,
INDArray element)
Inserts the element at the specified index
|
INDArray |
INDArray.put(int i,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseNDArray.put(int i,
int j,
INDArray element)
Inserts the element at the specified index
|
INDArray |
INDArray.put(int i,
int j,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseNDArray.putColumn(int column,
INDArray toPut)
Insert a column in to this array
Will throw an exception if this
ndarray is not a matrix
|
INDArray |
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 |
BaseNDArray.putRow(int row,
INDArray toPut)
Insert a row in to this array
Will throw an exception if this
ndarray is not a matrix
|
INDArray |
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 |
BaseNDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
INDArray |
INDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
INDArray |
BaseNDArray.rdiv(INDArray other)
Reverse division
|
INDArray |
INDArray.rdiv(INDArray other)
Reverse division
|
INDArray |
BaseNDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
INDArray |
INDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
INDArray |
BaseNDArray.rdiv(Number n,
INDArray result) |
INDArray |
INDArray.rdiv(Number n,
INDArray result)
Reverse division (number / ndarray)
|
INDArray |
BaseNDArray.rdivColumnVector(INDArray columnVector) |
INDArray |
INDArray.rdivColumnVector(INDArray columnVector)
Reverse division of a column vector (copy)
|
INDArray |
BaseNDArray.rdivi(INDArray other)
Reverse divsion (in place)
|
INDArray |
INDArray.rdivi(INDArray other)
Reverse divsion (in place)
|
INDArray |
BaseNDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
INDArray |
INDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
INDArray |
BaseNDArray.rdivi(Number n,
INDArray result) |
INDArray |
INDArray.rdivi(Number n,
INDArray result)
Reverse in place division
|
INDArray |
BaseNDArray.rdiviColumnVector(INDArray columnVector) |
INDArray |
INDArray.rdiviColumnVector(INDArray columnVector)
In place reverse divison of a column vector
|
INDArray |
BaseNDArray.rdiviRowVector(INDArray rowVector) |
INDArray |
INDArray.rdiviRowVector(INDArray rowVector)
In place reverse division of a column vector
|
INDArray |
BaseNDArray.rdivRowVector(INDArray rowVector) |
INDArray |
INDArray.rdivRowVector(INDArray rowVector)
Reverse division of a column vector (copy)
|
INDArray |
BaseNDArray.replaceWhere(INDArray arr,
Condition condition)
Replaces all elements in this ndarray that are matching give condition, with corresponding elements from given array
|
INDArray |
INDArray.replaceWhere(INDArray arr,
Condition condition)
Replaces all elements in this ndarray that are matching give condition, with corresponding elements from given array
|
INDArray |
BaseNDArray.rsub(INDArray other) |
INDArray |
INDArray.rsub(INDArray other) |
INDArray |
BaseNDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
INDArray |
INDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
INDArray |
BaseNDArray.rsub(Number n,
INDArray result) |
INDArray |
INDArray.rsub(Number n,
INDArray result)
Reverse subtraction
|
INDArray |
BaseNDArray.rsubColumnVector(INDArray columnVector) |
INDArray |
INDArray.rsubColumnVector(INDArray columnVector)
Reverse subtraction of a column vector (copy)
|
INDArray |
BaseNDArray.rsubi(INDArray other) |
INDArray |
INDArray.rsubi(INDArray other) |
INDArray |
BaseNDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
INDArray |
INDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
INDArray |
BaseNDArray.rsubi(Number n,
INDArray result) |
INDArray |
INDArray.rsubi(Number n,
INDArray result)
Reverse in place subtraction
|
INDArray |
BaseNDArray.rsubiColumnVector(INDArray columnVector) |
INDArray |
INDArray.rsubiColumnVector(INDArray columnVector)
In place reverse subtraction of a column vector
|
INDArray |
BaseNDArray.rsubiRowVector(INDArray rowVector) |
INDArray |
INDArray.rsubiRowVector(INDArray rowVector)
In place reverse subtraction of a row vector
|
INDArray |
BaseNDArray.rsubRowVector(INDArray rowVector) |
INDArray |
INDArray.rsubRowVector(INDArray rowVector)
Reverse subtraction of a row vector (copy)
|
double |
BaseNDArray.squaredDistance(INDArray other)
Returns the squared (Euclidean) distance.
|
double |
INDArray.squaredDistance(INDArray other)
Returns the squared (Euclidean) distance.
|
INDArray |
BaseNDArray.sub(INDArray other)
copy subtraction of two matrices
|
INDArray |
INDArray.sub(INDArray other)
copy subtraction of two NDArrays
|
INDArray |
BaseNDArray.sub(INDArray other,
INDArray result)
copy subtraction of two matrices
|
INDArray |
INDArray.sub(INDArray other,
INDArray result)
copy subtraction of two NDArrays
|
INDArray |
BaseNDArray.sub(Number n,
INDArray result) |
INDArray |
INDArray.sub(Number n,
INDArray result) |
INDArray |
BaseNDArray.subColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.subColumnVector(INDArray columnVector)
Subtraction of a column vector (copy)
|
INDArray |
BaseNDArray.subi(INDArray other)
in place subtraction of two matrices
|
INDArray |
INDArray.subi(INDArray other)
in place subtraction of two NDArrays
|
INDArray |
BaseNDArray.subi(INDArray other,
INDArray result)
in place subtraction of two matrices
|
INDArray |
INDArray.subi(INDArray other,
INDArray result)
in place subtraction of two NDArrays
|
INDArray |
BaseNDArray.subi(Number n,
INDArray result) |
INDArray |
INDArray.subi(Number n,
INDArray result)
In place subtraction of this ndarray
|
INDArray |
BaseNDArray.subiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.subiColumnVector(INDArray columnVector)
In place subtraction of a column vector
|
INDArray |
BaseNDArray.subiRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.subiRowVector(INDArray rowVector)
In place subtraction of a row vector
|
INDArray |
BaseNDArray.subRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.subRowVector(INDArray rowVector)
Subtraction of a row vector (copy)
|
static void |
NdArrayJSONWriter.write(INDArray thisnD,
String filePath) |
| Modifier and Type | Method and Description |
|---|---|
void |
BaseNDArray.sliceVectors(List<INDArray> list)
Flattens the array for linear indexing
|
void |
INDArray.sliceVectors(List<INDArray> list) |
| Constructor and Description |
|---|
BaseNDArrayProxy(INDArray anInstance) |
| Constructor and Description |
|---|
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 | Field and Description |
|---|---|
protected INDArray |
BaseOp.x |
protected INDArray |
BaseOp.y |
protected INDArray |
BaseOp.z |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
BaseLossFunction.input() |
INDArray |
LossFunction.input()
The true
|
INDArray |
Accumulation.noOp()
Returns the no op version
of the input
Basically when a reduce can't happen (eg: sum(0) on a row vector)
you have a no op state for a given reduction.
|
INDArray |
BaseAccumulation.noOp() |
INDArray |
BaseLossFunction.output() |
INDArray |
LossFunction.output()
The guess
|
INDArray |
Op.x()
The origin ndarray
|
INDArray |
TadCollapseAccumulation.x() |
INDArray |
BaseOp.x() |
INDArray |
Op.y()
The pairwise op ndarray
|
INDArray |
TadCollapseAccumulation.y() |
INDArray |
BaseOp.y() |
INDArray |
Op.z()
The resulting ndarray
|
INDArray |
TadCollapseAccumulation.z() |
INDArray |
BaseOp.z() |
| Modifier and Type | Method and Description |
|---|---|
void |
BaseIndexAccumulation.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
BaseAccumulation.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
Op.init(INDArray x,
INDArray y,
INDArray z,
long n)
Initialize the operation based on the parameters
|
void |
BaseOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
Op.setX(INDArray x)
set x (the input ndarray)
|
void |
BaseOp.setX(INDArray x) |
void |
Op.setY(INDArray y)
set y(the pairwise ndarray)
|
void |
BaseOp.setY(INDArray y) |
void |
Op.setZ(INDArray z)
set z (the solution ndarray)
|
void |
BaseOp.setZ(INDArray z) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
OpExecutioner.exec(Accumulation accumulation,
int... dimension)
Execute an accumulation along one or more dimensions
|
INDArray |
DefaultOpExecutioner.exec(Accumulation op,
int... dimension) |
INDArray |
OpExecutioner.exec(BroadcastOp broadcast,
int... dimension)
Execute an broadcast along one or more dimensions
|
INDArray |
DefaultOpExecutioner.exec(BroadcastOp broadcast,
int... dimension) |
INDArray |
OpExecutioner.exec(IndexAccumulation indexAccum,
int... dimension)
Execute an index accumulation along one or more dimensions
|
INDArray |
DefaultOpExecutioner.exec(IndexAccumulation op,
int... dimension) |
INDArray |
OpExecutioner.exec(Variance accumulation,
boolean biasCorrected,
int... dimension)
Execute an accumulation along one or more dimensions
|
INDArray |
DefaultOpExecutioner.exec(Variance accumulation,
boolean biasCorrected,
int... dimension) |
INDArray |
OpExecutioner.execAndReturn(BroadcastOp op)
Execute and return the result from a vector op
|
INDArray |
DefaultOpExecutioner.execAndReturn(BroadcastOp op) |
INDArray |
OpExecutioner.execAndReturn(Op op)
Execute and return a result
ndarray from the given op
|
INDArray |
DefaultOpExecutioner.execAndReturn(Op op) |
INDArray |
OpExecutioner.execAndReturn(ScalarOp op)
Execute and return the result from a scalar op
|
INDArray |
DefaultOpExecutioner.execAndReturn(ScalarOp op) |
INDArray |
OpExecutioner.execAndReturn(TransformOp op)
Execute a TransformOp and return the result
|
INDArray |
DefaultOpExecutioner.execAndReturn(TransformOp op) |
| Modifier and Type | Method and Description |
|---|---|
static boolean |
OpExecutionerUtil.canDoOpDirectly(INDArray x)
Can we do the op (X = Op(X)) directly on the arrays without breaking X up into 1d tensors first?
In general, this is possible if the elements of X are contiguous in the buffer, OR if every element
of X is at position offset+i*elementWiseStride in the buffer
|
static boolean |
OpExecutionerUtil.canDoOpDirectly(INDArray x,
INDArray y)
Can we do the transform op (X = Op(X,Y)) directly on the arrays without breaking them up into 1d tensors first?
|
static boolean |
OpExecutionerUtil.canDoOpDirectly(INDArray x,
INDArray y,
INDArray z)
Can we do the transform op (Z = Op(X,Y)) directly on the arrays without breaking them up into 1d tensors first?
|
static int |
OpExecutionerUtil.chooseElementWiseTensorDimension(INDArray x)
Choose tensor dimension for operations with one argument: x=Op(x) or similar
When doing some operations in parallel, it is necessary to break up operations along a dimension to give a set of 1d tensors. |
static int |
OpExecutionerUtil.chooseElementWiseTensorDimension(INDArray x,
INDArray y)
Choose tensor dimension for operations with 2 arguments: x=Op(x,y) or similar
|
static int |
OpExecutionerUtil.chooseElementWiseTensorDimension(INDArray x,
INDArray y,
INDArray z)
Choose tensor dimension for operations with 3 arguments: z=Op(x,y) or similar
|
static OpExecutionerUtil.Tensor1DStats |
OpExecutionerUtil.get1DTensorStats(INDArray array,
int... dimension)
Tensor1DStats, used to efficiently iterate through tensors on a matrix (2d NDArray) for element-wise ops
For example, the offset of each 1d tensor can be calculated using only a single tensorAlongDimension method call,
hence is potentially faster than approaches requiring multiple tensorAlongDimension calls.
Note that this can only (generally) be used for 2d NDArrays. |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Variance.noOp() |
INDArray |
NormMax.noOp() |
INDArray |
Norm1.noOp() |
INDArray |
Norm2.noOp() |
| Modifier and Type | Method and Description |
|---|---|
void |
Variance.init(INDArray x,
INDArray y,
INDArray z,
long n) |
| Constructor and Description |
|---|
CosineSimilarity(INDArray x) |
CosineSimilarity(INDArray x,
INDArray y) |
CosineSimilarity(INDArray x,
INDArray y,
INDArray z,
long n) |
CosineSimilarity(INDArray x,
INDArray y,
long n) |
EuclideanDistance(INDArray x) |
EuclideanDistance(INDArray x,
INDArray y) |
EuclideanDistance(INDArray x,
INDArray y,
INDArray z,
long n) |
EuclideanDistance(INDArray x,
INDArray y,
long n) |
ManhattanDistance(INDArray x) |
ManhattanDistance(INDArray x,
INDArray y) |
ManhattanDistance(INDArray x,
INDArray y,
INDArray z,
long n) |
ManhattanDistance(INDArray x,
INDArray y,
long n) |
| Constructor and Description |
|---|
BroadcastAddOp(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
BroadcastCopyOp(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
BroadcastDivOp(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
BroadcastMulOp(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
BroadcastRDivOp(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
BroadcastRSubOp(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
BroadcastSubOp(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
| Constructor and Description |
|---|
BaseGridOp(INDArray x,
INDArray y) |
FreeGridOp(INDArray x,
INDArray y) |
| Constructor and Description |
|---|
IAMax(INDArray x) |
IAMax(INDArray x,
INDArray y) |
IAMax(INDArray x,
INDArray y,
long n) |
IMax(INDArray x) |
IMax(INDArray x,
INDArray y) |
IMax(INDArray x,
INDArray y,
long n) |
IMin(INDArray x) |
IMin(INDArray x,
INDArray y) |
IMin(INDArray x,
INDArray y,
long n) |
| Constructor and Description |
|---|
BaseMetaOp(INDArray x,
INDArray y) |
InvertedPredicateMetaOp(INDArray x,
INDArray y) |
PostulateMetaOp(INDArray x,
INDArray y) |
PredicateMetaOp(INDArray x,
INDArray y) |
ReduceMetaOp(INDArray x,
INDArray y) |
| Modifier and Type | Method and Description |
|---|---|
void |
ScalarMin.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
ScalarMax.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
ScalarSet.init(INDArray x,
INDArray y,
INDArray z,
long n) |
| Modifier and Type | Method and Description |
|---|---|
void |
LeakyReLU.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
RectifedLinear.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
Pow.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
SoftMax.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
DropOutInverted.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
SetRange.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
Step.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
ReplaceNans.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
DropOut.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
LeakyReLUDerivative.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
Stabilize.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
VectorIFFT.setX(INDArray x) |
void |
VectorFFT.setX(INDArray x) |
void |
VectorFFT.setY(INDArray y) |
void |
VectorIFFT.setZ(INDArray z) |
void |
VectorFFT.setZ(INDArray z) |
| Modifier and Type | Method and Description |
|---|---|
void |
DivOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
SubOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
Axpy.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
RDivOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
AddOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
RSubOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
MulOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
| Modifier and Type | Method and Description |
|---|---|
void |
CompareAndSet.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
CompareAndReplace.init(INDArray x,
INDArray y,
INDArray z,
long n) |
| Constructor and Description |
|---|
Col2Im(INDArray x,
int sy,
int sx,
int ph,
int pw,
int h,
int w) |
Col2Im(INDArray x,
int sy,
int sx,
int ph,
int pw,
int h,
int w,
INDArray z) |
Im2col(INDArray x,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
boolean coverAll) |
Im2col(INDArray x,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
boolean coverAll,
INDArray z) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Random.nextDouble(char order,
int[] shape)
Generate a uniform number ndarray
of the specified shape and order
|
INDArray |
DefaultRandom.nextDouble(char order,
int[] shape) |
INDArray |
Random.nextDouble(int[] shape)
Generate a uniform number ndarray
of the specified shape
|
INDArray |
DefaultRandom.nextDouble(int[] shape) |
INDArray |
Random.nextFloat(int[] shape)
Generate a gaussian number ndarray
of the specified shape
|
INDArray |
DefaultRandom.nextFloat(int[] shape) |
INDArray |
Random.nextGaussian(char order,
int[] shape)
Generate a gaussian number ndarray
of the specified shape and order
|
INDArray |
DefaultRandom.nextGaussian(char order,
int[] shape) |
INDArray |
Random.nextGaussian(int[] shape)
Generate a gaussian number ndarray
of the specified shape
|
INDArray |
DefaultRandom.nextGaussian(int[] shape) |
INDArray |
Random.nextInt(int[] shape)
Generate a random set of integers
of the specified shape.
|
INDArray |
DefaultRandom.nextInt(int[] shape) |
INDArray |
Random.nextInt(int n,
int[] shape)
Generate a random set of integers
of the specified shape.
|
INDArray |
DefaultRandom.nextInt(int n,
int[] shape) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
BaseDistribution.sample(int[] shape) |
INDArray |
Distribution.sample(int[] shape)
Sample the given shape
|
| Modifier and Type | Method and Description |
|---|---|
Distribution |
DistributionFactory.createBinomial(int n,
INDArray p)
Create a distribution
|
Distribution |
DefaultDistributionFactory.createBinomial(int n,
INDArray p) |
Distribution |
DistributionFactory.createNormal(INDArray mean,
double std)
Create a normal distribution
with the given mean and std
|
Distribution |
DefaultDistributionFactory.createNormal(INDArray mean,
double std) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
BinomialDistribution.sample(int[] shape) |
INDArray |
NormalDistribution.sample(int[] shape) |
| Constructor and Description |
|---|
BinomialDistribution(int n,
INDArray p) |
NormalDistribution(double standardDeviation,
INDArray means) |
NormalDistribution(INDArray mean,
double std) |
NormalDistribution(Random rng,
double standardDeviation,
INDArray means) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Shape.newShapeNoCopy(INDArray arr,
int[] newShape,
boolean isFOrder)
A port of numpy's reshaping algorithm that leverages
no copy where possible and returns
null if the reshape
couldn't happen without copying
|
static INDArray |
Shape.toMmulCompatible(INDArray input)
Idea: make an matrix compatible for mmul without needing to be copied first
A matrix is compatible for mmul if its values are contiguous in memory. |
static INDArray |
Shape.toOffsetZero(INDArray arr)
Create a copy of the matrix
where the new offset is zero
|
static INDArray |
Shape.toOffsetZeroCopy(INDArray arr)
Create a copy of the ndarray where the new offset is zero
|
static INDArray |
Shape.toOffsetZeroCopy(INDArray arr,
char order)
Create a copy of the ndarray where the new offset is zero, and has specified order
|
static INDArray |
Shape.toOffsetZeroCopyAnyOrder(INDArray arr)
Create a copy of the ndarray where the new offset is zero.
|
| Modifier and Type | Method and Description |
|---|---|
static double |
Shape.getDouble(INDArray arr,
int... indices)
Get a double based on the array and given indices
|
static char |
Shape.getOrder(INDArray arr)
Infer the order for the ndarray based on the
array's strides
|
static int[] |
Shape.ind2sub(INDArray arr,
long index)
Convert a linear index to
the equivalent nd index based on the shape of the specified ndarray.
|
static int[] |
Shape.ind2subC(INDArray arr,
long index)
Convert a linear index to
the equivalent nd index based on the shape of the specified ndarray.
|
static boolean |
Shape.isContiguousInBuffer(INDArray in)
Are the elements in the buffer contiguous for this NDArray?
|
static void |
Shape.iterate(INDArray arr,
CoordinateFunction coordinateFunction)
Iterate over 2
coordinate spaces given 2 arrays
|
static void |
Shape.iterate(INDArray arr,
INDArray arr2,
CoordinateFunction coordinateFunction)
Iterate over 2
coordinate spaces given 2 arrays
|
static INDArray |
Shape.newShapeNoCopy(INDArray arr,
int[] newShape,
boolean isFOrder)
A port of numpy's reshaping algorithm that leverages
no copy where possible and returns
null if the reshape
couldn't happen without copying
|
static long |
Shape.offsetFor(INDArray arr,
int[] indexes)
Compute the offset for the given array
given the indices
|
static RawArrayIterationInformation1 |
Shape.prepareRawArrayIter(INDArray dst)
Prepares two arrays for
raw iteration linearly through the data.
|
static String |
Shape.shapeToString(INDArray arr)
Prints the shape
for this shape information
|
static boolean |
Shape.strideDescendingCAscendingF(INDArray array)
Check if strides are in order suitable for non-strided mmul etc.
|
static INDArray |
Shape.toMmulCompatible(INDArray input)
Idea: make an matrix compatible for mmul without needing to be copied first
A matrix is compatible for mmul if its values are contiguous in memory. |
static INDArray |
Shape.toOffsetZero(INDArray arr)
Create a copy of the matrix
where the new offset is zero
|
static INDArray |
Shape.toOffsetZeroCopy(INDArray arr)
Create a copy of the ndarray where the new offset is zero
|
static INDArray |
Shape.toOffsetZeroCopy(INDArray arr,
char order)
Create a copy of the ndarray where the new offset is zero, and has specified order
|
static INDArray |
Shape.toOffsetZeroCopyAnyOrder(INDArray arr)
Create a copy of the ndarray where the new offset is zero.
|
| Constructor and Description |
|---|
CopyCoordinateFunction(INDArray from,
INDArray to) |
| Constructor and Description |
|---|
TimeOperations(INDArray n) |
TimeOperations(INDArray n,
int numTimesRun) |
| Modifier and Type | Method and Description |
|---|---|
org.apache.commons.math3.util.Pair<DataBuffer,DataBuffer> |
TADManager.getTADOnlyShapeInfo(INDArray array,
int[] dimension)
This method returns TAD shapeInfo and all offets for specified tensor and dimensions.
|
| Constructor and Description |
|---|
TadDescriptor(INDArray array,
int[] dimension) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
CheckUtil.convertFromApacheMatrix(org.apache.commons.math3.linear.RealMatrix matrix) |
| Modifier and Type | Method and Description |
|---|---|
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.get3dPermutedWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.get3dReshapedWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.get3dSubArraysWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.get3dTensorAlongDimensionWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.get4dPermutedWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.get4dReshapedWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.get4dSubArraysWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.get4dTensorAlongDimensionWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.get5dPermutedWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.get5dReshapedWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.get5dSubArraysWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.get5dTensorAlongDimensionWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.get6dPermutedWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.get6dReshapedWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.get6dSubArraysWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.getAll3dTestArraysWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.getAll4dTestArraysWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.getAll5dTestArraysWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.getAll6dTestArraysWithShape(int seed,
int... shape) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.getAllTestMatricesWithShape(char ordering,
int rows,
int cols,
int seed)
Get an array of INDArrays (2d) all with the specified shape.
|
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.getAllTestMatricesWithShape(int rows,
int cols,
int seed)
Get an array of INDArrays (2d) all with the specified shape.
|
static org.apache.commons.math3.util.Pair<INDArray,String> |
NDArrayCreationUtil.getPermutedWithShape(char ordering,
int rows,
int cols,
int seed) |
static org.apache.commons.math3.util.Pair<INDArray,String> |
NDArrayCreationUtil.getPermutedWithShape(int rows,
int cols,
int seed) |
static org.apache.commons.math3.util.Pair<INDArray,String> |
NDArrayCreationUtil.getReshapedWithShape(char ordering,
int rows,
int cols,
int seed) |
static org.apache.commons.math3.util.Pair<INDArray,String> |
NDArrayCreationUtil.getReshapedWithShape(int rows,
int cols,
int seed) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.getSubMatricesWithShape(char ordering,
int rows,
int cols,
int seed) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.getSubMatricesWithShape(int rows,
int cols,
int seed) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.getTensorAlongDimensionMatricesWithShape(char ordering,
int rows,
int cols,
int seed) |
static List<org.apache.commons.math3.util.Pair<INDArray,String>> |
NDArrayCreationUtil.getTensorAlongDimensionMatricesWithShape(int rows,
int cols,
int seed) |
static org.apache.commons.math3.util.Pair<INDArray,String> |
NDArrayCreationUtil.getTransposedMatrixWithShape(char ordering,
int rows,
int cols,
int seed) |
static org.apache.commons.math3.util.Pair<INDArray,String> |
NDArrayCreationUtil.getTransposedMatrixWithShape(int rows,
int cols,
int seed) |
| Modifier and Type | Method and Description |
|---|---|
static boolean |
CheckUtil.checkAdd(INDArray first,
INDArray second,
double maxRelativeDifference,
double minAbsDifference)
Same as checkMmul, but for matrix addition
|
static boolean |
CheckUtil.checkDivManually(INDArray first,
INDArray second,
double maxRelativeDifference,
double minAbsDifference) |
static boolean |
CheckUtil.checkEntries(INDArray expected,
INDArray actual,
double maxRelativeDifference,
double minAbsDifference) |
static boolean |
CheckUtil.checkEntries(org.apache.commons.math3.linear.RealMatrix rmResult,
INDArray result,
double maxRelativeDifference,
double minAbsDifference) |
static boolean |
CheckUtil.checkGemm(INDArray a,
INDArray b,
INDArray c,
boolean transposeA,
boolean transposeB,
double alpha,
double beta,
double maxRelativeDifference,
double minAbsDifference) |
static boolean |
CheckUtil.checkMmul(INDArray first,
INDArray second,
double maxRelativeDifference,
double minAbsDifference)
Check first.mmul(second) using Apache commons math mmul.
|
static boolean |
CheckUtil.checkMulManually(INDArray first,
INDArray second,
double maxRelativeDifference,
double minAbsDifference) |
static boolean |
CheckUtil.checkSubtract(INDArray first,
INDArray second,
double maxRelativeDifference,
double minAbsDifference)
Same as checkMmul, but for matrix subtraction
|
static org.apache.commons.math3.linear.RealMatrix |
CheckUtil.convertToApacheMatrix(INDArray matrix) |
static void |
CheckUtil.printFailureDetails(INDArray first,
INDArray second,
INDArray expected,
INDArray actual,
INDArray onCopies,
String op) |
static void |
CheckUtil.printFailureDetails(INDArray first,
INDArray second,
org.apache.commons.math3.linear.RealMatrix expected,
INDArray actual,
INDArray onCopies,
String op) |
static void |
CheckUtil.printGemmFailureDetails(INDArray a,
INDArray b,
INDArray c,
boolean transposeA,
boolean transposeB,
double alpha,
double beta,
org.apache.commons.math3.linear.RealMatrix expected,
INDArray actual,
INDArray onCopies) |
static void |
CheckUtil.printMatrixFullPrecision(INDArray matrix) |
static void |
CheckUtil.printNDArrayHeader(INDArray array) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NDArrayCompressor.compress(INDArray array)
This method returns compressed copy of referenced array
|
INDArray |
BasicNDArrayCompressor.compress(INDArray array) |
INDArray |
BasicNDArrayCompressor.compress(INDArray array,
String algorithm) |
INDArray |
NDArrayCompressor.decompress(INDArray array)
This method returns decompressed copy of referenced array
|
INDArray |
BasicNDArrayCompressor.decompress(INDArray array) |
| Modifier and Type | Method and Description |
|---|---|
void |
BasicNDArrayCompressor.autoDecompress(INDArray... arrays) |
void |
BasicNDArrayCompressor.autoDecompress(INDArray array) |
INDArray |
NDArrayCompressor.compress(INDArray array)
This method returns compressed copy of referenced array
|
INDArray |
BasicNDArrayCompressor.compress(INDArray array) |
INDArray |
BasicNDArrayCompressor.compress(INDArray array,
String algorithm) |
void |
NDArrayCompressor.compressi(INDArray array)
Inplace compression of INDArray
|
void |
BasicNDArrayCompressor.compressi(INDArray array) |
void |
BasicNDArrayCompressor.compressi(INDArray array,
String algorithm) |
INDArray |
NDArrayCompressor.decompress(INDArray array)
This method returns decompressed copy of referenced array
|
INDArray |
BasicNDArrayCompressor.decompress(INDArray array) |
void |
NDArrayCompressor.decompressi(INDArray array)
Inplace decompression of INDArray
|
void |
BasicNDArrayCompressor.decompressi(INDArray array) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Convolution.col2im(INDArray col,
INDArray z,
int sy,
int sx,
int ph,
int pw,
int h,
int w) |
static INDArray |
OldConvolution.col2im(INDArray col,
int[] stride,
int[] padding,
int height,
int width) |
static INDArray |
Convolution.col2im(INDArray col,
int[] stride,
int[] padding,
int height,
int width) |
static INDArray |
OldConvolution.col2im(INDArray col,
int sy,
int sx,
int ph,
int pw,
int h,
int w)
Rearrange matrix
columns into blocks
|
static INDArray |
Convolution.col2im(INDArray col,
int sy,
int sx,
int ph,
int pw,
int h,
int w)
Rearrange matrix
columns into blocks
|
INDArray |
ConvolutionInstance.conv2d(IComplexNDArray input,
IComplexNDArray kernel,
Convolution.Type type) |
INDArray |
BaseConvolution.conv2d(IComplexNDArray input,
IComplexNDArray kernel,
Convolution.Type type) |
static INDArray |
Convolution.conv2d(IComplexNDArray input,
IComplexNDArray kernel,
Convolution.Type type) |
INDArray |
ConvolutionInstance.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
INDArray |
BaseConvolution.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
static INDArray |
Convolution.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
INDArray |
ConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
INDArray |
BaseConvolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
static INDArray |
Convolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
INDArray |
ConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
INDArray |
DefaultConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
static INDArray |
Convolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
static INDArray |
OldConvolution.im2col(INDArray img,
int[] kernel,
int[] stride,
int[] padding) |
static INDArray |
Convolution.im2col(INDArray img,
int[] kernel,
int[] stride,
int[] padding) |
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
boolean coverAll)
Implement column formatted images
|
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
boolean coverAll,
INDArray out) |
static INDArray |
OldConvolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int pval,
boolean coverAll)
Implement column formatted images
|
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int pval,
boolean coverAll)
Implement column formatted images
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Convolution.col2im(INDArray col,
INDArray z,
int sy,
int sx,
int ph,
int pw,
int h,
int w) |
static INDArray |
OldConvolution.col2im(INDArray col,
int[] stride,
int[] padding,
int height,
int width) |
static INDArray |
Convolution.col2im(INDArray col,
int[] stride,
int[] padding,
int height,
int width) |
static INDArray |
OldConvolution.col2im(INDArray col,
int sy,
int sx,
int ph,
int pw,
int h,
int w)
Rearrange matrix
columns into blocks
|
static INDArray |
Convolution.col2im(INDArray col,
int sy,
int sx,
int ph,
int pw,
int h,
int w)
Rearrange matrix
columns into blocks
|
INDArray |
ConvolutionInstance.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
INDArray |
BaseConvolution.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
static INDArray |
Convolution.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
INDArray |
ConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
INDArray |
BaseConvolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
static INDArray |
Convolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
INDArray |
ConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
INDArray |
DefaultConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
static INDArray |
Convolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
static INDArray |
OldConvolution.im2col(INDArray img,
int[] kernel,
int[] stride,
int[] padding) |
static INDArray |
Convolution.im2col(INDArray img,
int[] kernel,
int[] stride,
int[] padding) |
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
boolean coverAll)
Implement column formatted images
|
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
boolean coverAll,
INDArray out) |
static INDArray |
OldConvolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int pval,
boolean coverAll)
Implement column formatted images
|
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int pval,
boolean coverAll)
Implement column formatted images
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
DataSet.exampleMaxs() |
INDArray |
DataSet.exampleMeans() |
INDArray |
DataSet.exampleSums() |
INDArray |
DataSet.getFeatureMatrix()
Get the feature matrix (inputs for the data)
|
INDArray |
DataSet.getFeatures() |
INDArray[] |
MultiDataSet.getFeatures() |
INDArray |
MultiDataSet.getFeatures(int index) |
INDArray |
DataSet.getFeaturesMaskArray() |
INDArray |
MultiDataSet.getFeaturesMaskArray(int index) |
INDArray[] |
MultiDataSet.getFeaturesMaskArrays() |
INDArray |
DataSet.getLabels()
Returns the labels for the dataset
|
INDArray[] |
MultiDataSet.getLabels() |
INDArray |
MultiDataSet.getLabels(int index) |
INDArray |
DataSet.getLabelsMaskArray() |
INDArray |
MultiDataSet.getLabelsMaskArray(int index) |
INDArray[] |
MultiDataSet.getLabelsMaskArrays() |
| Modifier and Type | Method and Description |
|---|---|
void |
DataSet.addFeatureVector(INDArray toAdd)
Adds a feature for each example on to the current feature vector
|
void |
DataSet.addFeatureVector(INDArray feature,
int example)
The feature to add, and the example/row number
|
List<String> |
DataSet.getLabelNames(INDArray idxs) |
void |
DataSet.setFeatures(INDArray features) |
void |
MultiDataSet.setFeatures(INDArray[] features) |
void |
MultiDataSet.setFeatures(int idx,
INDArray features) |
void |
DataSet.setFeaturesMaskArray(INDArray featuresMask) |
void |
MultiDataSet.setFeaturesMaskArray(int idx,
INDArray maskArray) |
void |
MultiDataSet.setFeaturesMaskArrays(INDArray[] maskArrays) |
void |
DataSet.setLabels(INDArray labels) |
void |
MultiDataSet.setLabels(INDArray[] labels) |
void |
MultiDataSet.setLabels(int idx,
INDArray labels) |
void |
DataSet.setLabelsMaskArray(INDArray labelsMask) |
void |
MultiDataSet.setLabelsMaskArray(INDArray[] labelsMaskArrays) |
void |
MultiDataSet.setLabelsMaskArray(int idx,
INDArray labelsMaskArray) |
| Constructor and Description |
|---|
DataSet(INDArray first,
INDArray second)
Creates a dataset with the specified input matrix and labels
|
DataSet(INDArray features,
INDArray labels,
INDArray featuresMask,
INDArray labelsMask)
Create a dataset with the specified input INDArray and labels (output) INDArray, plus (optionally) mask arrays
for the features and labels
|
MultiDataSet(INDArray[] features,
INDArray[] labels)
MultiDataSet constructor with no mask arrays
|
MultiDataSet(INDArray[] features,
INDArray[] labels)
MultiDataSet constructor with no mask arrays
|
MultiDataSet(INDArray[] features,
INDArray[] labels,
INDArray[] featuresMaskArrays,
INDArray[] labelsMaskArrays) |
MultiDataSet(INDArray[] features,
INDArray[] labels,
INDArray[] featuresMaskArrays,
INDArray[] labelsMaskArrays) |
MultiDataSet(INDArray[] features,
INDArray[] labels,
INDArray[] featuresMaskArrays,
INDArray[] labelsMaskArrays) |
MultiDataSet(INDArray[] features,
INDArray[] labels,
INDArray[] featuresMaskArrays,
INDArray[] labelsMaskArrays) |
MultiDataSet(INDArray features,
INDArray labels)
MultiDataSet constructor with single features/labels input, no mask arrays
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
DataSet.exampleMaxs() |
INDArray |
DataSet.exampleMeans() |
INDArray |
DataSet.exampleSums() |
INDArray |
DataSet.getFeatureMatrix()
Deprecated.
|
INDArray |
DataSet.getFeatures()
Returns the features array for the DataSet
|
INDArray[] |
MultiDataSet.getFeatures()
Get all of the input features, as an array of INDArrays
|
INDArray |
MultiDataSet.getFeatures(int index)
Get a single feature/input array
|
INDArray |
DataSet.getFeaturesMaskArray()
Input mask array: a mask array for input, where each value is in {0,1} in order to specify whether an input is
actually present or not.
|
INDArray |
MultiDataSet.getFeaturesMaskArray(int index)
Get the specified feature mask array.
|
INDArray[] |
MultiDataSet.getFeaturesMaskArrays()
Get the feature mask arrays.
|
INDArray |
DataSet.getLabels() |
INDArray[] |
MultiDataSet.getLabels()
Get all of the labels, as an array of INDArrays
|
INDArray |
MultiDataSet.getLabels(int index)
Get a single label/output array
|
INDArray |
DataSet.getLabelsMaskArray()
Labels (output) mask array: a mask array for input, where each value is in {0,1} in order to specify whether an
output is actually present or not.
|
INDArray |
MultiDataSet.getLabelsMaskArray(int index)
Get the specified label mask array.
|
INDArray[] |
MultiDataSet.getLabelsMaskArrays()
Get the labels mask arrays.
|
| Modifier and Type | Method and Description |
|---|---|
void |
DataSet.addFeatureVector(INDArray toAdd) |
void |
DataSet.addFeatureVector(INDArray feature,
int example) |
List<String> |
DataSet.getLabelNames(INDArray idxs) |
void |
DataSet.setFeatures(INDArray features)
Set the features array for the DataSet
|
void |
MultiDataSet.setFeatures(INDArray[] features)
Set all of the features arrays for the MultiDataSet
|
void |
MultiDataSet.setFeatures(int idx,
INDArray features)
Set a single features array (by index) for the MultiDataSet
|
void |
DataSet.setFeaturesMaskArray(INDArray inputMask)
Set the features mask array in this DataSet
|
void |
MultiDataSet.setFeaturesMaskArray(int idx,
INDArray maskArray)
Set a single feature mask array by index
|
void |
MultiDataSet.setFeaturesMaskArrays(INDArray[] maskArrays)
Set the feature mask arrays
|
void |
DataSet.setLabels(INDArray labels) |
void |
MultiDataSet.setLabels(INDArray[] labels)
Set all of the labels arrays for the MultiDataSet
|
void |
MultiDataSet.setLabels(int idx,
INDArray labels)
Set a single labels array (by index) for the MultiDataSet
|
void |
DataSet.setLabelsMaskArray(INDArray labelsMask)
Set the labels mask array in this data set
|
void |
MultiDataSet.setLabelsMaskArray(INDArray[] labels)
Set the labels mask arrays
|
void |
MultiDataSet.setLabelsMaskArray(int idx,
INDArray labelsMaskArray)
Set a single labels mask array by index
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
StandardScaler.getMean()
Deprecated.
|
INDArray |
StandardScaler.getStd()
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
protected INDArray |
BaseDataFetcher.createInputMatrix(int numRows)
Creates a feature vector
|
protected INDArray |
BaseDataFetcher.createOutputMatrix(int numRows) |
protected INDArray |
BaseDataFetcher.createOutputVector(int outcomeLabel)
Creates an output label matrix
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NormalizerStandardize.getLabelMean() |
INDArray |
NormalizerStandardize.getLabelStd() |
INDArray |
NormalizerMinMaxScaler.getMax() |
INDArray |
NormalizerStandardize.getMean() |
INDArray |
NormalizerMinMaxScaler.getMin() |
INDArray |
NormalizerStandardize.getStd() |
| Modifier and Type | Method and Description |
|---|---|
void |
NormalizerMinMaxScaler.preProcess(INDArray theFeatures) |
void |
NormalizerMinMaxScaler.transform(INDArray theFeatures) |
void |
NormalizerStandardize.transform(INDArray theFeatures)
Transform the given INDArray
|
void |
NormalizerStandardize.transform(INDArray theArray,
boolean isFeatures) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
PCA.pca(INDArray X,
int nDims,
boolean normalize)
Reduce the dimension of x
to the specified number of dimensions.
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
PCA.pca(INDArray X,
int nDims,
boolean normalize)
Reduce the dimension of x
to the specified number of dimensions.
|
| Modifier and Type | Field and Description |
|---|---|
static INDArray |
Eigen.dummy |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A)
Compute generalized eigenvalues of the problem A x = L B x.
|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A,
INDArray B)
Compute generalized eigenvalues of the problem A x = L B x.
|
| Modifier and Type | Method and Description |
|---|---|
static IComplexNDArray |
Eigen.eigenvalues(INDArray A)
Computes the eigenvalues of a general matrix.
|
static IComplexNDArray[] |
Eigen.eigenvectors(INDArray A)
Computes the eigenvalues and eigenvectors of a general matrix.
|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A)
Compute generalized eigenvalues of the problem A x = L B x.
|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A,
INDArray B)
Compute generalized eigenvalues of the problem A x = L B x.
|
| Modifier and Type | Field and Description |
|---|---|
protected static ReferenceQueue<INDArray> |
Nd4j.referenceQueue |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Nd4j.append(INDArray arr,
int padAmount,
double val,
int axis)
Append the given
array with the specified value size
along a particular axis
|
INDArray |
BaseNDArrayFactory.appendBias(INDArray... vectors)
Merge the vectors and append a bias.
|
static INDArray |
Nd4j.appendBias(INDArray... vectors) |
INDArray |
NDArrayFactory.appendBias(INDArray... vectors) |
static INDArray |
Nd4j.arange(double end)
Array of evenly spaced values.
|
INDArray |
BaseNDArrayFactory.arange(double begin,
double end)
Array of evenly spaced values.
|
static INDArray |
Nd4j.arange(double begin,
double end)
Array of evenly spaced values.
|
INDArray |
NDArrayFactory.arange(double begin,
double end)
Array of evenly spaced values.
|
static INDArray |
Nd4j.argMax(INDArray arr,
int... dimension) |
INDArray |
NDArrayFactory.average(Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
static INDArray |
Nd4j.averageAndPropagate(Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray[] arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array.
|
INDArray |
BlasWrapper.axpy(double da,
INDArray dx,
INDArray dy)
Deprecated.
|
INDArray |
BaseBlasWrapper.axpy(double da,
INDArray dx,
INDArray dy) |
INDArray |
BlasWrapper.axpy(float da,
INDArray dx,
INDArray dy)
Deprecated.
|
INDArray |
BaseBlasWrapper.axpy(float da,
INDArray dx,
INDArray dy) |
INDArray |
BlasWrapper.axpy(Number da,
INDArray dx,
INDArray dy)
Compute y <- y + x * alpha
|
INDArray |
BaseBlasWrapper.axpy(Number da,
INDArray dx,
INDArray dy) |
INDArray |
BaseNDArrayFactory.bilinearProducts(INDArray curr,
INDArray in)
Returns a column vector where each entry is the nth bilinear
product of the nth slices of the two tensors.
|
static INDArray |
Nd4j.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.
|
INDArray |
NDArrayFactory.bilinearProducts(INDArray curr,
INDArray in)
Returns a column vector where each entry is the nth bilinear
product of the nth slices of the two tensors.
|
static INDArray |
Nd4j.complexZeros(int rows,
int columns)
Creates a matrix of zeros
|
INDArray |
BaseNDArrayFactory.concat(int dimension,
INDArray... toConcat)
concatenate ndarrays along a dimension
|
static INDArray |
Nd4j.concat(int dimension,
INDArray... toConcat)
Concatneate ndarrays along a dimension
|
INDArray |
NDArrayFactory.concat(int dimension,
INDArray... toConcat)
Concatneate ndarrays along a dimension
|
INDArray |
NDArrayFactory.convertDataEx(DataBuffer.TypeEx typeSrc,
INDArray source,
DataBuffer.TypeEx typeDst)
This method converts Single/Double precision databuffer to Half-precision databuffer
|
INDArray |
BlasWrapper.copy(INDArray x,
INDArray y)
Compute y <- x (copy a matrix)
|
INDArray |
BaseBlasWrapper.copy(INDArray x,
INDArray y) |
static INDArray |
Nd4j.create(DataBuffer buffer) |
INDArray |
NDArrayFactory.create(DataBuffer data)
Creates a row vector with the data
|
static INDArray |
Nd4j.create(DataBuffer data,
int[] shape) |
INDArray |
NDArrayFactory.create(DataBuffer data,
int[] shape)
Create an ndrray with the specified shape
|
static INDArray |
Nd4j.create(DataBuffer data,
int[] shape,
int offset) |
INDArray |
NDArrayFactory.create(DataBuffer buffer,
int[] shape,
int offset) |
INDArray |
BaseNDArrayFactory.create(DataBuffer buffer,
int[] shape,
int[] stride,
char order,
int offset) |
INDArray |
NDArrayFactory.create(DataBuffer buffer,
int[] shape,
int[] stride,
char order,
int offset) |
static INDArray |
Nd4j.create(DataBuffer data,
int[] shape,
int[] strides,
int offset) |
INDArray |
NDArrayFactory.create(DataBuffer data,
int[] shape,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(DataBuffer data,
int[] newShape,
int[] newStride,
int offset,
char ordering) |
INDArray |
NDArrayFactory.create(DataBuffer data,
int[] newShape,
int[] newStride,
int offset,
char ordering) |
INDArray |
NDArrayFactory.create(DataBuffer data,
int rows,
int columns,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(double[] data)
Creates a row vector with the data
|
static INDArray |
Nd4j.create(double[] data)
Creates a row vector with the data
|
INDArray |
NDArrayFactory.create(double[] data)
Creates a row vector with the data
|
static INDArray |
Nd4j.create(double[][] data)
Create an ndarray based on the given data layout
|
INDArray |
NDArrayFactory.create(double[][] data)
Create an ndarray with the given data layout
|
static INDArray |
Nd4j.create(double[][] data,
char ordering) |
INDArray |
NDArrayFactory.create(double[][] data,
char ordering) |
INDArray |
BaseNDArrayFactory.create(double[] data,
char order) |
static INDArray |
Nd4j.create(double[] data,
char order)
Creates a row vector with the data
|
INDArray |
NDArrayFactory.create(double[] data,
char order) |
INDArray |
BaseNDArrayFactory.create(double[] data,
int[] shape)
Create an ndrray with the specified shape
|
static INDArray |
Nd4j.create(double[] data,
int[] shape)
Create an ndrray with the specified shape
|
INDArray |
NDArrayFactory.create(double[] data,
int[] shape)
Create an ndrray with the specified shape
|
static INDArray |
Nd4j.create(double[] data,
int[] shape,
char ordering)
Create an ndrray with the specified shape
|
INDArray |
NDArrayFactory.create(double[] data,
int[] shape,
char ordering) |
static INDArray |
Nd4j.create(double[] data,
int[] shape,
int offset) |
INDArray |
NDArrayFactory.create(double[] data,
int[] shape,
int offset) |
INDArray |
BaseNDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
char order,
int offset) |
INDArray |
NDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
char order,
int offset) |
abstract INDArray |
BaseNDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(double[] data,
int[] shape,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(double[] data,
int[] shape,
int[] stride,
int offset,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
int offset,
char ordering) |
static INDArray |
Nd4j.create(double[] data,
int[] shape,
int offset,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(double[] data,
int rows,
int columns,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(double[] data,
int rows,
int columns,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(double[] data,
int rows,
int columns,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(double[] data,
int rows,
int columns,
int[] stride,
int offset,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(float[] data)
Creates a row vector with the data
|
static INDArray |
Nd4j.create(float[] data)
Creates a row vector with the data
|
INDArray |
NDArrayFactory.create(float[] data)
Creates a row vector with the data
|
static INDArray |
Nd4j.create(float[][] data) |
INDArray |
NDArrayFactory.create(float[][] floats) |
static INDArray |
Nd4j.create(float[][] data,
char ordering) |
INDArray |
NDArrayFactory.create(float[][] data,
char ordering) |
INDArray |
BaseNDArrayFactory.create(float[] data,
char order) |
static INDArray |
Nd4j.create(float[] data,
char order)
Creates a row vector with the data
|
INDArray |
NDArrayFactory.create(float[] data,
char order) |
INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape)
Create an ndrray with the specified shape
|
static INDArray |
Nd4j.create(float[] data,
int[] shape)
Create an ndrray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
int[] shape)
Create an ndrray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape,
char ordering) |
static INDArray |
Nd4j.create(float[] data,
int[] shape,
char ordering)
Create an ndrray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
char ordering) |
static INDArray |
Nd4j.create(float[] data,
int[] shape,
char ordering,
int offset) |
INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape,
int offset) |
static INDArray |
Nd4j.create(float[] data,
int[] shape,
int offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
int offset) |
INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
char order,
int offset) |
static INDArray |
Nd4j.create(float[] data,
int[] shape,
int[] stride,
char ordering,
int offset) |
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
char order,
int offset) |
abstract INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(float[] data,
int[] shape,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(float[] data,
int[] shape,
int[] stride,
int offset,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
int offset,
char ordering) |
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
int offset,
Character order) |
INDArray |
BaseNDArrayFactory.create(float[] data,
int rows,
int columns,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(float[] data,
int rows,
int columns,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
int rows,
int columns,
int[] stride,
int offset) |
static INDArray |
Nd4j.create(float[] data,
int rows,
int columns,
int[] stride,
int offset,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
int rows,
int columns,
int[] stride,
int offset,
char ordering) |
static INDArray |
Nd4j.create(int... shape)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(int columns)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.create(int columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.create(int columns)
Creates a row vector with the specified number of columns
|
INDArray |
BaseNDArrayFactory.create(int[] shape)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int[] shape)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int[] shape,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int[] shape,
char ordering) |
INDArray |
BaseNDArrayFactory.create(int[] shape,
DataBuffer.Type dataType) |
static INDArray |
Nd4j.create(int[] shape,
DataBuffer.Type dataType) |
INDArray |
NDArrayFactory.create(int[] shape,
DataBuffer.Type dataType) |
INDArray |
NDArrayFactory.create(int[] shape,
DataBuffer buffer)
Create an ndarray with the given shape
and data
|
static INDArray |
Nd4j.create(int[] sliceShape,
double[]... arrays)
Create an ndarray based on the given data
|
static INDArray |
Nd4j.create(int[] sliceShape,
float[]... arrays)
Create an ndarray based on the given data
|
INDArray |
BaseNDArrayFactory.create(int[] shape,
int[] stride)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int[] shape,
int[] stride)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int[] shape,
int[] stride)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int[] shape,
int[] stride,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(int[] shape,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int[] shape,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int[] shape,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(int[] data,
int[] shape,
int[] stride,
char order,
int offset) |
INDArray |
NDArrayFactory.create(int[] shape,
int[] ints1,
int[] stride,
char order,
int offset) |
INDArray |
BaseNDArrayFactory.create(int[] ints,
int[] ints1,
int[] stride,
int offset) |
INDArray |
NDArrayFactory.create(int[] ints,
int[] ints1,
int[] stride,
int offset) |
INDArray |
BaseNDArrayFactory.create(int[] shape,
int[] stride,
int offset,
char ordering) |
static INDArray |
Nd4j.create(int[] shape,
int[] stride,
int offset,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int[] shape,
int[] stride,
int offset,
char ordering) |
static INDArray |
Nd4j.create(int columns,
char order)
Creates a row vector with the specified number of columns
|
INDArray |
BaseNDArrayFactory.create(int rows,
int columns)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int rows,
int columns)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int rows,
int columns)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(int rows,
int columns,
char ordering) |
static INDArray |
Nd4j.create(int rows,
int columns,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int rows,
int columns,
char ordering) |
INDArray |
BaseNDArrayFactory.create(int rows,
int columns,
int[] stride)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int rows,
int columns,
int[] stride)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int rows,
int columns,
int[] stride)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int rows,
int columns,
int[] stride,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(int rows,
int columns,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int rows,
int columns,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int rows,
int columns,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int rows,
int columns,
int[] stride,
int offset,
char ordering)
Creates an ndarray with the specified shape
|
abstract INDArray |
BaseNDArrayFactory.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(List<INDArray> list,
int[] shape,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(List<INDArray> list,
int[] shape,
char ordering) |
static INDArray |
Nd4j.createArrayFromShapeBuffer(DataBuffer data,
DataBuffer shapeInfo) |
static INDArray |
Nd4j.createUninitialized(int[] shape,
char ordering)
Creates an *uninitialized* ndarray with the specified shape and ordering.
NOTE: The underlying memory (DataBuffer) will not be initialized. |
INDArray |
NDArrayFactory.createUninitialized(int[] shape,
char ordering) |
static INDArray |
Nd4j.cumsum(INDArray compute) |
static INDArray |
Nd4j.cumsum(INDArray compute,
int dimension) |
static INDArray |
Nd4j.diag(INDArray x)
Creates a new matrix where the values of the given vector are the diagonal values of
the matrix if a vector is passed in, if a matrix is returns the kth diagonal
in the matrix
|
static INDArray |
Nd4j.diag(INDArray x,
int k)
Creates a new matrix where the values of the given vector are the diagonal values of
the matrix if a vector is passed in, if a matrix is returns the kth diagonal
in the matrix
|
static INDArray |
Nd4j.emptyLike(INDArray arr)
Empty like
|
INDArray |
BaseNDArrayFactory.eye(int n)
Create the identity ndarray
|
static INDArray |
Nd4j.eye(int n)
Create the identity ndarray
|
INDArray |
NDArrayFactory.eye(int n)
Create the identity ndarray
|
static INDArray |
Nd4j.fromByteArray(byte[] arr)
Read an ndarray from a byte array
|
INDArray |
BlasWrapper.gemm(double alpha,
INDArray a,
INDArray b,
double beta,
INDArray c)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemm(double alpha,
INDArray a,
INDArray b,
double beta,
INDArray c) |
INDArray |
BlasWrapper.gemm(float alpha,
INDArray a,
INDArray b,
float beta,
INDArray c)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemm(float alpha,
INDArray a,
INDArray b,
float beta,
INDArray c) |
static INDArray |
Nd4j.gemm(INDArray a,
INDArray b,
boolean transposeA,
boolean transposeB)
matrix multiply: implements op(a)*op(b)
where op(x) means transpose x (or not) depending on
setting of arguments transposea and transposeb.
so gemm(a,b,false,false) == a.mmul(b), gemm(a,b,true,false) == a.transpose().mmul(b) etc. |
static INDArray |
Nd4j.gemm(INDArray a,
INDArray b,
INDArray c,
boolean transposeA,
boolean transposeB,
double alpha,
double beta)
Matrix multiply: Implements c = alpha*op(a)*op(b) + beta*c where op(X) means transpose X (or not)
depending on setting of arguments transposeA and transposeB.
Note that matrix c MUST be fortran order, have zero offset and have c.data().length == c.length(). |
INDArray |
BlasWrapper.gemv(double alpha,
INDArray a,
INDArray x,
double beta,
INDArray y)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemv(double alpha,
INDArray a,
INDArray x,
double beta,
INDArray y) |
INDArray |
BlasWrapper.gemv(float alpha,
INDArray a,
INDArray x,
float beta,
INDArray y)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemv(float alpha,
INDArray a,
INDArray x,
float beta,
INDArray y) |
INDArray |
BlasWrapper.gemv(Number alpha,
INDArray a,
INDArray x,
double beta,
INDArray y)
************************************************************************
BLAS Level 2
|
INDArray |
BaseBlasWrapper.gemv(Number alpha,
INDArray a,
INDArray x,
double beta,
INDArray y) |
INDArray |
BlasWrapper.ger(double alpha,
INDArray x,
INDArray y,
INDArray a)
Deprecated.
|
INDArray |
BaseBlasWrapper.ger(double alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.ger(float alpha,
INDArray x,
INDArray y,
INDArray a)
Compute A <- alpha * x * y^T + A (general rank-1 update)
|
INDArray |
BaseBlasWrapper.ger(float alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.ger(Number alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BaseBlasWrapper.ger(Number alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.gesv(INDArray a,
int[] ipiv,
INDArray b)
************************************************************************
LAPACK
|
INDArray |
BaseBlasWrapper.gesv(INDArray a,
int[] ipiv,
INDArray b) |
static INDArray |
Nd4j.hstack(Collection<INDArray> arrs)
Concatenates two matrices horizontally.
|
INDArray |
BaseNDArrayFactory.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
static INDArray |
Nd4j.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
INDArray |
NDArrayFactory.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
INDArray |
BaseNDArrayFactory.linspace(int lower,
int upper,
int num)
Generate a linearly spaced vector
|
static INDArray |
Nd4j.linspace(int lower,
int upper,
int num)
Generate a linearly spaced vector
|
INDArray |
NDArrayFactory.linspace(int lower,
int upper,
int num)
Generate a linearly spaced vector
|
static INDArray |
Nd4j.max(INDArray compute) |
static INDArray |
Nd4j.max(INDArray compute,
int dimension) |
static INDArray |
Nd4j.mean(INDArray compute) |
static INDArray |
Nd4j.mean(INDArray compute,
int dimension) |
static INDArray |
Nd4j.min(INDArray compute) |
static INDArray |
Nd4j.min(INDArray compute,
int dimension) |
static INDArray |
Nd4j.norm1(INDArray compute) |
static INDArray |
Nd4j.norm1(INDArray compute,
int dimension) |
static INDArray |
Nd4j.norm2(INDArray compute) |
static INDArray |
Nd4j.norm2(INDArray compute,
int dimension) |
static INDArray |
Nd4j.normmax(INDArray compute) |
static INDArray |
Nd4j.normmax(INDArray compute,
int dimension) |
static INDArray |
Nd4j.ones(int... shape)
Create an ndarray of ones
|
INDArray |
BaseNDArrayFactory.ones(int columns)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.ones(int columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.ones(int columns)
Creates a row vector with the specified number of columns
|
INDArray |
BaseNDArrayFactory.ones(int[] shape)
Create an ndarray of ones
|
INDArray |
NDArrayFactory.ones(int[] shape)
Create an ndarray of ones
|
INDArray |
BaseNDArrayFactory.ones(int rows,
int columns)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.ones(int rows,
int columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.ones(int rows,
int columns)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.onesLike(INDArray arr)
Ones like
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[][] padWidth,
List<double[]> constantValues,
Nd4j.PadMode padMode)
Pad the given ndarray to the size along each dimension
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[][] padWidth,
Nd4j.PadMode padMode)
Pad the given ndarray to the size along each dimension
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[] padWidth,
List<double[]> constantValues,
Nd4j.PadMode padMode)
Pad the given ndarray to the size along each dimension
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[] padWidth,
Nd4j.PadMode padMode)
Pad the given ndarray to the size along each dimension
|
static INDArray |
Nd4j.prepend(INDArray arr,
int padAmount,
double val,
int axis)
Append the given
array with the specified value size
along a particular axis
|
static INDArray |
Nd4j.prod(INDArray compute) |
static INDArray |
Nd4j.prod(INDArray compute,
int dimension) |
INDArray |
BaseNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
static INDArray |
Nd4j.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
NDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
BaseNDArrayFactory.rand(char order,
int[] shape)
Create a random ndarray with the given shape and order
|
static INDArray |
Nd4j.rand(char order,
int[] shape)
Create a random ndarray with the given shape and array order
|
INDArray |
NDArrayFactory.rand(char order,
int[] shape)
Create a random ndarray with the given shape, and specified output order
|
INDArray |
BaseNDArrayFactory.rand(char order,
int rows,
int columns)
Create a random (uniform 0-1) NDArray with the specified shape and order
|
static INDArray |
Nd4j.rand(char order,
int rows,
int columns)
Create a random ndarray with the given shape and output order
|
INDArray |
NDArrayFactory.rand(char order,
int rows,
int columns)
Create a random (uniform 0-1) NDArray with the specified shape and order
|
INDArray |
BaseNDArrayFactory.rand(int[] shape)
Create a random ndarray with the given shape using
the current time as the seed
|
static INDArray |
Nd4j.rand(int[] shape)
Create a random ndarray with the given shape using
the current time as the seed
|
INDArray |
NDArrayFactory.rand(int[] shape)
Create a random ndarray with the given shape using
the current time as the seed
|
INDArray |
BaseNDArrayFactory.rand(int[] shape,
Distribution r)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(int[] shape,
Distribution dist)
Create a random ndarray with the given shape using the given rng
|
INDArray |
NDArrayFactory.rand(int[] shape,
Distribution r)
Create a random ndarray with the given shape using the given rng
|
INDArray |
BaseNDArrayFactory.rand(int[] shape,
double min,
double max,
Random rng) |
static INDArray |
Nd4j.rand(int[] shape,
double min,
double max,
Random rng)
Generates a random matrix between min and max
|
INDArray |
NDArrayFactory.rand(int[] shape,
double min,
double max,
Random rng) |
INDArray |
BaseNDArrayFactory.rand(int[] shape,
float min,
float max,
Random rng)
Generates a random matrix between min and max
|
INDArray |
NDArrayFactory.rand(int[] shape,
float min,
float max,
Random rng)
Generates a random matrix between min and max
|
INDArray |
BaseNDArrayFactory.rand(int[] shape,
long seed)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(int[] shape,
long seed)
Create a random ndarray with the given shape using given seed
|
INDArray |
NDArrayFactory.rand(int[] shape,
long seed)
Create a random ndarray with the given shape using the given rng
|
INDArray |
BaseNDArrayFactory.rand(int[] shape,
Random r)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(int[] shape,
Random rng)
Create a random ndarray with the given shape using the given RandomGenerator
|
INDArray |
NDArrayFactory.rand(int[] shape,
Random r)
Create a random ndarray with the given shape using the given rng
|
INDArray |
BaseNDArrayFactory.rand(int rows,
int columns)
Create a random ndarray with the given shape using
the current time as the seed
|
static INDArray |
Nd4j.rand(int rows,
int columns)
Create a random ndarray with the given shape using
the current time as the seed
|
INDArray |
NDArrayFactory.rand(int rows,
int columns)
Create a random ndarray with the given shape using
the current time as the seed
|
INDArray |
BaseNDArrayFactory.rand(int rows,
int columns,
double min,
double max,
Random rng) |
static INDArray |
Nd4j.rand(int rows,
int columns,
double min,
double max,
Random rng)
Generates a random matrix between min and max
|
INDArray |
NDArrayFactory.rand(int rows,
int columns,
double min,
double max,
Random rng) |
INDArray |
BaseNDArrayFactory.rand(int rows,
int columns,
float min,
float max,
Random rng)
Generates a random matrix between min and max
|
INDArray |
NDArrayFactory.rand(int rows,
int columns,
float min,
float max,
Random rng)
Generates a random matrix between min and max
|
INDArray |
BaseNDArrayFactory.rand(int rows,
int columns,
long seed)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(int rows,
int columns,
long seed)
Create a random ndarray with the given shape using the given seed
|
INDArray |
NDArrayFactory.rand(int rows,
int columns,
long seed)
Create a random ndarray with the given shape using the given rng
|
INDArray |
BaseNDArrayFactory.rand(int rows,
int columns,
Random r)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(int rows,
int columns,
Random rng)
Deprecated.
|
INDArray |
NDArrayFactory.rand(int rows,
int columns,
Random r)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(long seed,
int... shape)
Create a random ndarray with the given shape using the given seed
|
INDArray |
BaseNDArrayFactory.randn(char order,
int[] shape)
Random normal using the current time stamp
as the seed
|
static INDArray |
Nd4j.randn(char order,
int[] shape)
Random normal N(0,1) with the specified shape and array order
|
INDArray |
NDArrayFactory.randn(char order,
int[] shape)
Random normal N(0,1) with the specified shape and order
|
INDArray |
BaseNDArrayFactory.randn(char order,
int rows,
int columns)
Generate a random normal N(0,1) with the specified order and shape
|
static INDArray |
Nd4j.randn(char order,
int rows,
int columns)
Random normal N(0,1) with the specified shape and array order
|
INDArray |
NDArrayFactory.randn(char order,
int rows,
int columns)
Random normal N(0,1), with specified output order
|
INDArray |
BaseNDArrayFactory.randn(int[] shape)
Random normal N(0,1) with the specified shape and
|
static INDArray |
Nd4j.randn(int[] shape)
Random normal using the current time stamp
as the seed
|
INDArray |
NDArrayFactory.randn(int[] shape)
Random normal N(0,1) using the current time stamp
as the seed
|
INDArray |
BaseNDArrayFactory.randn(int[] shape,
long seed)
Random normal using the specified seed
|
static INDArray |
Nd4j.randn(int[] shape,
long seed)
Random normal using the specified seed
|
INDArray |
NDArrayFactory.randn(int[] shape,
long seed)
Random normal using the specified seed
|
INDArray |
BaseNDArrayFactory.randn(int[] shape,
Random r)
Random normal using the given rng
|
static INDArray |
Nd4j.randn(int[] shape,
Random r)
Random normal using the given rng
|
INDArray |
NDArrayFactory.randn(int[] shape,
Random r)
Random normal using the given rng
|
INDArray |
BaseNDArrayFactory.randn(int rows,
int columns)
Random normal using the current time stamp
as the seed
|
static INDArray |
Nd4j.randn(int rows,
int columns)
Random normal using the current time stamp
as the seed
|
INDArray |
NDArrayFactory.randn(int rows,
int columns)
Random normal (N(0,1)) using the current time stamp
as the seed
|
INDArray |
BaseNDArrayFactory.randn(int rows,
int columns,
long seed)
Random normal using the specified seed
|
static INDArray |
Nd4j.randn(int rows,
int columns,
long seed)
Random normal using the specified seed
|
INDArray |
NDArrayFactory.randn(int rows,
int columns,
long seed)
Random normal using the specified seed
|
INDArray |
BaseNDArrayFactory.randn(int rows,
int columns,
Random r)
Random normal using the given rng
|
static INDArray |
Nd4j.randn(int rows,
int columns,
Random r)
Random normal using the given rng
|
INDArray |
NDArrayFactory.randn(int rows,
int columns,
Random r)
Random normal using the given rng
|
static INDArray |
Nd4j.read(DataInputStream dis)
Read in an ndarray from a data input stream
|
static INDArray |
Nd4j.read(InputStream reader)
Raad an ndarray from an input stream
|
static INDArray |
Nd4j.readBinary(File read)
Read a binary ndarray from the given file
|
static INDArray |
Nd4j.readNumpy(InputStream filePath,
String split)
Read line via input streams
|
static INDArray |
Nd4j.readNumpy(String filePath)
Read line via input streams
|
static INDArray |
Nd4j.readNumpy(String filePath,
String split)
Read line via input streams
|
static INDArray |
Nd4j.readTxt(String filePath)
Read from a file
|
static INDArray |
Nd4j.readTxt(String filePath,
String sep)
Read line via input streams
|
static INDArray |
Nd4j.readTxtString(InputStream ndarray)
Read from a file
|
static INDArray |
Nd4j.readTxtString(InputStream ndarray,
String sep)
Read line via input streams
|
static INDArray |
Nd4j.repeat(INDArray n,
int num)
Create an n x (shape)
ndarray where the ndarray is repeated num times
|
INDArray |
BaseNDArrayFactory.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
static INDArray |
Nd4j.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
NDArrayFactory.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
static INDArray |
Nd4j.rollAxis(INDArray a,
int axis)
Roll the specified axis backwards,
until it lies in a given position.
|
static INDArray |
Nd4j.rollAxis(INDArray a,
int axis,
int start)
Roll the specified axis backwards,
until it lies in a given position.
|
INDArray |
BaseNDArrayFactory.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
static INDArray |
Nd4j.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
NDArrayFactory.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
BlasWrapper.scal(double alpha,
INDArray x)
Deprecated.
|
INDArray |
BaseBlasWrapper.scal(double alpha,
INDArray x) |
INDArray |
BlasWrapper.scal(float alpha,
INDArray x)
Deprecated.
|
INDArray |
BaseBlasWrapper.scal(float alpha,
INDArray x) |
INDArray |
BaseNDArrayFactory.scalar(double value)
Create a scalar nd array with the specified value and offset
|
static INDArray |
Nd4j.scalar(double value)
Create a scalar nd array with the specified value and offset
|
INDArray |
NDArrayFactory.scalar(double value)
Create a scalar nd array with the specified value and offset
|
INDArray |
BaseNDArrayFactory.scalar(double value,
int offset)
Create a scalar nd array with the specified value and offset
|
static INDArray |
Nd4j.scalar(double value,
int offset)
Create a scalar nd array with the specified value and offset
|
INDArray |
NDArrayFactory.scalar(double value,
int offset)
Create a scalar nd array with the specified value and offset
|
INDArray |
BaseNDArrayFactory.scalar(float value)
Create a scalar nd array with the specified value and offset
|
static INDArray |
Nd4j.scalar(float value)
Create a scalar nd array with the specified value and offset
|
INDArray |
NDArrayFactory.scalar(float value)
Create a scalar nd array with the specified value and offset
|
INDArray |
BaseNDArrayFactory.scalar(float value,
int offset)
Create a scalar nd array with the specified value and offset
|
static INDArray |
Nd4j.scalar(float value,
int offset)
Create a scalar nd array with the specified value and offset
|
INDArray |
NDArrayFactory.scalar(float value,
int offset)
Create a scalar nd array with the specified value and offset
|
INDArray |
BaseNDArrayFactory.scalar(int value,
int offset)
Create a scalar nd array with the specified value and offset
|
INDArray |
NDArrayFactory.scalar(int value,
int offset) |
INDArray |
BaseNDArrayFactory.scalar(Number value)
Create a scalar ndarray with the specified offset
|
static INDArray |
Nd4j.scalar(Number value)
Create a scalar ndarray with the specified offset
|
INDArray |
NDArrayFactory.scalar(Number value)
Create a scalar ndarray with the specified offset
|
INDArray |
BaseNDArrayFactory.scalar(Number value,
int offset)
Create a scalar ndarray with the specified offset
|
static INDArray |
Nd4j.scalar(Number value,
int offset)
Create a scalar ndarray with the specified offset
|
INDArray |
NDArrayFactory.scalar(Number value,
int offset)
Create a scalar ndarray with the specified offset
|
static INDArray |
Nd4j.sort(INDArray ndarray,
int dimension,
boolean ascending)
Sort an ndarray along a particular dimension
|
static INDArray |
Nd4j.sortColumns(INDArray in,
int rowIdx,
boolean ascending)
Sort (shuffle) the columns of a 2d array according to the value at a specified row.
|
static INDArray |
Nd4j.sortRows(INDArray in,
int colIdx,
boolean ascending)
Sort (shuffle) the rows of a 2d array according to the value at a specified column.
|
static INDArray[] |
Nd4j.sortWithIndices(IComplexNDArray ndarray,
int dimension,
boolean ascending)
Sort an ndarray along a particular dimension
|
static INDArray[] |
Nd4j.sortWithIndices(INDArray ndarray,
int dimension,
boolean ascending)
Sort an ndarray along a particular dimension
|
static INDArray |
Nd4j.std(INDArray compute) |
static INDArray |
Nd4j.std(INDArray compute,
int dimension) |
static INDArray |
Nd4j.stripOnes(INDArray toStrip)
Reshapes an ndarray to remove leading 1s
|
static INDArray |
Nd4j.sum(INDArray compute) |
static INDArray |
Nd4j.sum(INDArray compute,
int dimension) |
INDArray |
BlasWrapper.swap(INDArray x,
INDArray y)
Compute x <-> y (swap two matrices)
|
INDArray |
BaseBlasWrapper.swap(INDArray x,
INDArray y) |
INDArray |
BlasWrapper.sysv(char uplo,
INDArray a,
int[] ipiv,
INDArray b) |
INDArray |
BaseBlasWrapper.sysv(char uplo,
INDArray a,
int[] ipiv,
INDArray b) |
static INDArray |
Nd4j.tensorMmul(INDArray a,
INDArray b,
int[][] axes)
Tensor matrix multiplication.
|
static INDArray |
Nd4j.tile(INDArray tile,
int... repeat)
An alias for repmat
|
static INDArray |
Nd4j.toFlattened(char order,
Collection<INDArray> matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
NDArrayFactory.toFlattened(char order,
Collection<INDArray> matrices)
Returns a flattened ndarray with all elements in each ndarray
regardless of dimension.
|
INDArray |
BaseNDArrayFactory.toFlattened(char order,
INDArray... matrices) |
static INDArray |
Nd4j.toFlattened(char order,
INDArray... matrices)
Create a long row vector of all of the given ndarrays/
|
INDArray |
NDArrayFactory.toFlattened(char order,
INDArray... matrices)
Flatten all of the ndarrays in to one long vector
|
INDArray |
BaseNDArrayFactory.toFlattened(Collection<INDArray> matrices)
Returns a vector with all of the elements in every nd array
equal to the sum of the lengths of the ndarrays
|
static INDArray |
Nd4j.toFlattened(Collection<INDArray> matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
NDArrayFactory.toFlattened(Collection<INDArray> matrices)
/**
Returns a flattened ndarray with all of the elements in each ndarray
regardless of dimension
|
INDArray |
BaseNDArrayFactory.toFlattened(INDArray... matrices) |
static INDArray |
Nd4j.toFlattened(INDArray... matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
NDArrayFactory.toFlattened(INDArray... matrices)
Flatten all of the ndarrays in to one long vector
|
INDArray |
BaseNDArrayFactory.toFlattened(int length,
Iterator<? extends INDArray>... matrices) |
static INDArray |
Nd4j.toFlattened(int length,
Iterator<? extends INDArray>... matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
NDArrayFactory.toFlattened(int length,
Iterator<? extends INDArray>... matrices)
Returns a flattened ndarray with all of the elements in each ndarray
regardless of dimension
|
static INDArray |
Nd4j.typeConversion(INDArray array,
DataBuffer.TypeEx targetType) |
INDArray |
BaseNDArrayFactory.valueArrayOf(int[] shape,
double value)
Creates an ndarray with the specified value
as the only value in the ndarray
|
static INDArray |
Nd4j.valueArrayOf(int[] shape,
double value)
Creates an ndarray with the specified value
as the only value in the ndarray
|
INDArray |
NDArrayFactory.valueArrayOf(int[] shape,
double value)
Creates an ndarray with the specified value
as the only value in the ndarray
|
static INDArray |
Nd4j.valueArrayOf(int num,
double value)
Creates a row vector ndarray with the specified value
as the only value in the ndarray
|
INDArray |
BaseNDArrayFactory.valueArrayOf(int rows,
int columns,
double value)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.valueArrayOf(int rows,
int columns,
double value)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.valueArrayOf(int rows,
int columns,
double value)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.var(INDArray compute) |
static INDArray |
Nd4j.var(INDArray compute,
int dimension) |
static INDArray |
Nd4j.vstack(Collection<INDArray> arrs)
Concatenates two matrices vertically.
|
INDArray |
BaseNDArrayFactory.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
static INDArray |
Nd4j.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
INDArray |
NDArrayFactory.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
static INDArray |
Nd4j.zeros(int... shape)
Create an ndarray of zeros
|
INDArray |
BaseNDArrayFactory.zeros(int columns)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.zeros(int columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.zeros(int columns)
Creates a row vector with the specified number of columns
|
INDArray |
BaseNDArrayFactory.zeros(int[] shape)
Create an ndarray of zeros
|
INDArray |
NDArrayFactory.zeros(int[] shape)
Create an ndarray of zeros
|
static INDArray |
Nd4j.zeros(int[] shape,
char order)
Create an ndarray of zeros
|
static INDArray |
Nd4j.zeros(int[] shape,
DataBuffer.Type dataType) |
static INDArray |
Nd4j.zeros(int[] shape,
int[] stride) |
static INDArray |
Nd4j.zeros(int[] shape,
int[] stride,
char ordering) |
static INDArray |
Nd4j.zeros(int[] shape,
int[] stride,
int offset) |
static INDArray |
Nd4j.zeros(int[] shape,
int[] stride,
int offset,
char ordering) |
static INDArray |
Nd4j.zeros(int columns,
char order) |
INDArray |
BaseNDArrayFactory.zeros(int rows,
int columns)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.zeros(int rows,
int columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.zeros(int rows,
int columns)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.zeros(int rows,
int columns,
char ordering) |
static INDArray |
Nd4j.zeros(int rows,
int columns,
int[] stride) |
static INDArray |
Nd4j.zeros(int rows,
int columns,
int[] stride,
char ordering) |
static INDArray |
Nd4j.zeros(int rows,
int columns,
int[] stride,
int offset) |
static INDArray |
Nd4j.zeros(int rows,
int columns,
int[] stride,
int offset,
char ordering) |
static INDArray |
Nd4j.zerosLike(INDArray arr)
Empty like
|
| Modifier and Type | Method and Description |
|---|---|
static ReferenceQueue<INDArray> |
Nd4j.refQueue()
The reference queue used for cleaning up
ndarrays
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Nd4j.append(INDArray arr,
int padAmount,
double val,
int axis)
Append the given
array with the specified value size
along a particular axis
|
INDArray |
BaseNDArrayFactory.appendBias(INDArray... vectors)
Merge the vectors and append a bias.
|
static INDArray |
Nd4j.appendBias(INDArray... vectors) |
INDArray |
NDArrayFactory.appendBias(INDArray... vectors) |
static INDArray |
Nd4j.argMax(INDArray arr,
int... dimension) |
static void |
DataTypeValidation.assertDouble(INDArray... d) |
static void |
DataTypeValidation.assertDouble(INDArray d) |
static void |
DataTypeValidation.assertFloat(INDArray... d2) |
static void |
DataTypeValidation.assertFloat(INDArray d2) |
static void |
DataTypeValidation.assertSameDataType(INDArray... indArrays) |
double |
BlasWrapper.asum(INDArray x)
Compute || x ||_1 (1-norm, sum of absolute values)
|
double |
BaseBlasWrapper.asum(INDArray x) |
INDArray |
NDArrayFactory.average(INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
static INDArray |
Nd4j.averageAndPropagate(INDArray[] arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array.
|
INDArray |
BlasWrapper.axpy(double da,
INDArray dx,
INDArray dy)
Deprecated.
|
INDArray |
BaseBlasWrapper.axpy(double da,
INDArray dx,
INDArray dy) |
INDArray |
BlasWrapper.axpy(float da,
INDArray dx,
INDArray dy)
Deprecated.
|
INDArray |
BaseBlasWrapper.axpy(float da,
INDArray dx,
INDArray dy) |
INDArray |
BlasWrapper.axpy(Number da,
INDArray dx,
INDArray dy)
Compute y <- y + x * alpha
|
INDArray |
BaseBlasWrapper.axpy(Number da,
INDArray dx,
INDArray dy) |
INDArray |
BaseNDArrayFactory.bilinearProducts(INDArray curr,
INDArray in)
Returns a column vector where each entry is the nth bilinear
product of the nth slices of the two tensors.
|
static INDArray |
Nd4j.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.
|
INDArray |
NDArrayFactory.bilinearProducts(INDArray curr,
INDArray in)
Returns a column vector where each entry is the nth bilinear
product of the nth slices of the two tensors.
|
static void |
Nd4j.clearNans(INDArray arr)
Clear nans from an ndarray
|
INDArray |
BaseNDArrayFactory.concat(int dimension,
INDArray... toConcat)
concatenate ndarrays along a dimension
|
static INDArray |
Nd4j.concat(int dimension,
INDArray... toConcat)
Concatneate ndarrays along a dimension
|
INDArray |
NDArrayFactory.concat(int dimension,
INDArray... toConcat)
Concatneate ndarrays along a dimension
|
INDArray |
NDArrayFactory.convertDataEx(DataBuffer.TypeEx typeSrc,
INDArray source,
DataBuffer.TypeEx typeDst)
This method converts Single/Double precision databuffer to Half-precision databuffer
|
void |
BaseNDArrayFactory.copy(INDArray a,
INDArray b)
Copy a to b
|
static void |
Nd4j.copy(INDArray a,
INDArray b)
Copy a to b
|
void |
NDArrayFactory.copy(INDArray a,
INDArray b)
Copy a to b
|
INDArray |
BlasWrapper.copy(INDArray x,
INDArray y)
Compute y <- x (copy a matrix)
|
INDArray |
BaseBlasWrapper.copy(INDArray x,
INDArray y) |
abstract IComplexNDArray |
BaseNDArrayFactory.createComplex(INDArray arr)
Create a complex ndarray from the passed in indarray
|
static IComplexNDArray |
Nd4j.createComplex(INDArray arr)
Create a complex ndarray from the passed in indarray
|
IComplexNDArray |
NDArrayFactory.createComplex(INDArray arr)
Create a complex ndarray from the passed in indarray
|
static IComplexNDArray |
Nd4j.createComplex(INDArray real,
INDArray imag)
Create a complex ndarray based on the
real and imaginary
|
static INDArray |
Nd4j.cumsum(INDArray compute) |
static INDArray |
Nd4j.cumsum(INDArray compute,
int dimension) |
static INDArray |
Nd4j.diag(INDArray x)
Creates a new matrix where the values of the given vector are the diagonal values of
the matrix if a vector is passed in, if a matrix is returns the kth diagonal
in the matrix
|
static INDArray |
Nd4j.diag(INDArray x,
int k)
Creates a new matrix where the values of the given vector are the diagonal values of
the matrix if a vector is passed in, if a matrix is returns the kth diagonal
in the matrix
|
static void |
Nd4j.doAlongDiagonal(INDArray x,
com.google.common.base.Function<Number,Number> func)
Perform an operation along a diagonal
|
double |
BlasWrapper.dot(INDArray x,
INDArray y)
Compute x^T * y (dot product)
|
double |
BaseBlasWrapper.dot(INDArray x,
INDArray y) |
static INDArray |
Nd4j.emptyLike(INDArray arr)
Empty like
|
int |
BlasWrapper.geev(char jobvl,
char jobvr,
INDArray A,
INDArray WR,
INDArray WI,
INDArray VL,
INDArray VR) |
int |
BaseBlasWrapper.geev(char jobvl,
char jobvr,
INDArray A,
INDArray WR,
INDArray WI,
INDArray VL,
INDArray VR) |
void |
BlasWrapper.gelsd(INDArray A,
INDArray B)
Generalized Least Squares via *GELSD.
|
void |
BaseBlasWrapper.gelsd(INDArray A,
INDArray B) |
INDArray |
BlasWrapper.gemm(double alpha,
INDArray a,
INDArray b,
double beta,
INDArray c)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemm(double alpha,
INDArray a,
INDArray b,
double beta,
INDArray c) |
INDArray |
BlasWrapper.gemm(float alpha,
INDArray a,
INDArray b,
float beta,
INDArray c)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemm(float alpha,
INDArray a,
INDArray b,
float beta,
INDArray c) |
static INDArray |
Nd4j.gemm(INDArray a,
INDArray b,
boolean transposeA,
boolean transposeB)
matrix multiply: implements op(a)*op(b)
where op(x) means transpose x (or not) depending on
setting of arguments transposea and transposeb.
so gemm(a,b,false,false) == a.mmul(b), gemm(a,b,true,false) == a.transpose().mmul(b) etc. |
static INDArray |
Nd4j.gemm(INDArray a,
INDArray b,
INDArray c,
boolean transposeA,
boolean transposeB,
double alpha,
double beta)
Matrix multiply: Implements c = alpha*op(a)*op(b) + beta*c where op(X) means transpose X (or not)
depending on setting of arguments transposeA and transposeB.
Note that matrix c MUST be fortran order, have zero offset and have c.data().length == c.length(). |
INDArray |
BlasWrapper.gemv(double alpha,
INDArray a,
INDArray x,
double beta,
INDArray y)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemv(double alpha,
INDArray a,
INDArray x,
double beta,
INDArray y) |
INDArray |
BlasWrapper.gemv(float alpha,
INDArray a,
INDArray x,
float beta,
INDArray y)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemv(float alpha,
INDArray a,
INDArray x,
float beta,
INDArray y) |
INDArray |
BlasWrapper.gemv(Number alpha,
INDArray a,
INDArray x,
double beta,
INDArray y)
************************************************************************
BLAS Level 2
|
INDArray |
BaseBlasWrapper.gemv(Number alpha,
INDArray a,
INDArray x,
double beta,
INDArray y) |
void |
BlasWrapper.geqrf(INDArray A,
INDArray tau) |
void |
BaseBlasWrapper.geqrf(INDArray A,
INDArray tau) |
INDArray |
BlasWrapper.ger(double alpha,
INDArray x,
INDArray y,
INDArray a)
Deprecated.
|
INDArray |
BaseBlasWrapper.ger(double alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.ger(float alpha,
INDArray x,
INDArray y,
INDArray a)
Compute A <- alpha * x * y^T + A (general rank-1 update)
|
INDArray |
BaseBlasWrapper.ger(float alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.ger(Number alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BaseBlasWrapper.ger(Number alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.gesv(INDArray a,
int[] ipiv,
INDArray b)
************************************************************************
LAPACK
|
INDArray |
BaseBlasWrapper.gesv(INDArray a,
int[] ipiv,
INDArray b) |
INDArray |
BaseNDArrayFactory.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
static INDArray |
Nd4j.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
INDArray |
NDArrayFactory.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
int |
BlasWrapper.iamax(INDArray x)
Compute index of element with largest absolute value (index of absolute
value maximum)
|
int |
BaseBlasWrapper.iamax(INDArray x) |
static INDArray |
Nd4j.max(INDArray compute) |
static INDArray |
Nd4j.max(INDArray compute,
int dimension) |
static INDArray |
Nd4j.mean(INDArray compute) |
static INDArray |
Nd4j.mean(INDArray compute,
int dimension) |
static INDArray |
Nd4j.min(INDArray compute) |
static INDArray |
Nd4j.min(INDArray compute,
int dimension) |
static INDArray |
Nd4j.norm1(INDArray compute) |
static INDArray |
Nd4j.norm1(INDArray compute,
int dimension) |
static INDArray |
Nd4j.norm2(INDArray compute) |
static INDArray |
Nd4j.norm2(INDArray compute,
int dimension) |
static INDArray |
Nd4j.normmax(INDArray compute) |
static INDArray |
Nd4j.normmax(INDArray compute,
int dimension) |
double |
BlasWrapper.nrm2(INDArray x)
Compute || x ||_2 (2-norm)
|
double |
BaseBlasWrapper.nrm2(INDArray x) |
static INDArray |
Nd4j.onesLike(INDArray arr)
Ones like
|
void |
BlasWrapper.ormqr(char side,
char trans,
INDArray A,
INDArray tau,
INDArray C) |
void |
BaseBlasWrapper.ormqr(char side,
char trans,
INDArray A,
INDArray tau,
INDArray C) |
static INDArray |
Nd4j.pad(INDArray toPad,
int[][] padWidth,
List<double[]> constantValues,
Nd4j.PadMode padMode)
Pad the given ndarray to the size along each dimension
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[][] padWidth,
Nd4j.PadMode padMode)
Pad the given ndarray to the size along each dimension
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[] padWidth,
List<double[]> constantValues,
Nd4j.PadMode padMode)
Pad the given ndarray to the size along each dimension
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[] padWidth,
Nd4j.PadMode padMode)
Pad the given ndarray to the size along each dimension
|
void |
BlasWrapper.posv(char uplo,
INDArray A,
INDArray B) |
void |
BaseBlasWrapper.posv(char uplo,
INDArray A,
INDArray B) |
static INDArray |
Nd4j.prepend(INDArray arr,
int padAmount,
double val,
int axis)
Append the given
array with the specified value size
along a particular axis
|
static INDArray |
Nd4j.prod(INDArray compute) |
static INDArray |
Nd4j.prod(INDArray compute,
int dimension) |
INDArray |
BaseNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
static INDArray |
Nd4j.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
NDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
static INDArray |
Nd4j.repeat(INDArray n,
int num)
Create an n x (shape)
ndarray where the ndarray is repeated num times
|
INDArray |
BaseNDArrayFactory.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
static INDArray |
Nd4j.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
NDArrayFactory.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
static INDArray |
Nd4j.rollAxis(INDArray a,
int axis)
Roll the specified axis backwards,
until it lies in a given position.
|
static INDArray |
Nd4j.rollAxis(INDArray a,
int axis,
int start)
Roll the specified axis backwards,
until it lies in a given position.
|
INDArray |
BaseNDArrayFactory.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
static INDArray |
Nd4j.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
NDArrayFactory.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
void |
BaseNDArrayFactory.rot90(INDArray toRotate)
Rotate a matrix 90 degrees
|
static void |
Nd4j.rot90(INDArray toRotate)
Rotate a matrix 90 degrees
|
void |
NDArrayFactory.rot90(INDArray toRotate)
Rotate a matrix 90 degrees
|
static void |
Nd4j.saveBinary(INDArray arr,
File saveTo)
Save an ndarray to the given file
|
void |
BlasWrapper.saxpy(double alpha,
INDArray x,
INDArray y)
Deprecated.
|
void |
BaseBlasWrapper.saxpy(double alpha,
INDArray x,
INDArray y) |
void |
BlasWrapper.saxpy(float alpha,
INDArray x,
INDArray y)
Deprecated.
|
void |
BaseBlasWrapper.saxpy(float alpha,
INDArray x,
INDArray y) |
INDArray |
BlasWrapper.scal(double alpha,
INDArray x)
Deprecated.
|
INDArray |
BaseBlasWrapper.scal(double alpha,
INDArray x) |
INDArray |
BlasWrapper.scal(float alpha,
INDArray x)
Deprecated.
|
INDArray |
BaseBlasWrapper.scal(float alpha,
INDArray x) |
static void |
Nd4j.setParams(INDArray theta,
Collection<INDArray>... matrices)
Given a sequence of Iterators over a transform of matrices, fill in all of
the matrices with the entries in the theta vector.
|
static void |
Nd4j.setParams(INDArray theta,
Iterator<? extends INDArray>... matrices)
Given a sequence of Iterators over a transform of matrices, fill in all of
the matrices with the entries in the theta vector.
|
static int[] |
Nd4j.shape(INDArray arr)
Returns the shape of the ndarray
|
static void |
Nd4j.shuffle(INDArray toShuffle,
int... dimension)
In place shuffle of an ndarray
along a specified set of dimensions
|
static void |
Nd4j.shuffle(INDArray toShuffle,
Random random,
int... dimension)
In place shuffle of an ndarray
along a specified set of dimensions
|
void |
NDArrayFactory.shuffle(INDArray array,
Random rnd,
int... dimension)
In place shuffle of an ndarray
along a specified set of dimensions
|
static INDArray |
Nd4j.sort(INDArray ndarray,
int dimension,
boolean ascending)
Sort an ndarray along a particular dimension
|
static INDArray |
Nd4j.sortColumns(INDArray in,
int rowIdx,
boolean ascending)
Sort (shuffle) the columns of a 2d array according to the value at a specified row.
|
static INDArray |
Nd4j.sortRows(INDArray in,
int colIdx,
boolean ascending)
Sort (shuffle) the rows of a 2d array according to the value at a specified column.
|
static INDArray[] |
Nd4j.sortWithIndices(INDArray ndarray,
int dimension,
boolean ascending)
Sort an ndarray along a particular dimension
|
static INDArray |
Nd4j.std(INDArray compute) |
static INDArray |
Nd4j.std(INDArray compute,
int dimension) |
static INDArray |
Nd4j.stripOnes(INDArray toStrip)
Reshapes an ndarray to remove leading 1s
|
static INDArray |
Nd4j.sum(INDArray compute) |
static INDArray |
Nd4j.sum(INDArray compute,
int dimension) |
INDArray |
BlasWrapper.swap(INDArray x,
INDArray y)
Compute x <-> y (swap two matrices)
|
INDArray |
BaseBlasWrapper.swap(INDArray x,
INDArray y) |
int |
BlasWrapper.syev(char jobz,
char uplo,
INDArray a,
INDArray w) |
int |
BaseBlasWrapper.syev(char jobz,
char uplo,
INDArray a,
INDArray w) |
int |
BlasWrapper.syevd(char jobz,
char uplo,
INDArray A,
INDArray w) |
int |
BaseBlasWrapper.syevd(char jobz,
char uplo,
INDArray A,
INDArray w) |
int |
BlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
double vl,
double vu,
int il,
int iu,
double abstol,
INDArray w,
INDArray z,
int[] isuppz)
Deprecated.
|
int |
BaseBlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
double vl,
double vu,
int il,
int iu,
double abstol,
INDArray w,
INDArray z,
int[] isuppz) |
int |
BlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
float abstol,
INDArray w,
INDArray z,
int[] isuppz)
Deprecated.
|
int |
BaseBlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
float abstol,
INDArray w,
INDArray z,
int[] isuppz) |
int |
BlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
Number abstol,
INDArray w,
INDArray z,
int[] isuppz) |
int |
BaseBlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
Number abstol,
INDArray w,
INDArray z,
int[] isuppz) |
int |
BlasWrapper.syevx(char jobz,
char range,
char uplo,
INDArray a,
double vl,
double vu,
int il,
int iu,
double abstol,
INDArray w,
INDArray z) |
int |
BaseBlasWrapper.syevx(char jobz,
char range,
char uplo,
INDArray a,
double vl,
double vu,
int il,
int iu,
double abstol,
INDArray w,
INDArray z) |
int |
BlasWrapper.syevx(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
float abstol,
INDArray w,
INDArray z) |
int |
BaseBlasWrapper.syevx(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
float abstol,
INDArray w,
INDArray z) |
int |
BlasWrapper.sygvd(int itype,
char jobz,
char uplo,
INDArray A,
INDArray B,
INDArray W) |
int |
BaseBlasWrapper.sygvd(int itype,
char jobz,
char uplo,
INDArray A,
INDArray B,
INDArray W) |
INDArray |
BlasWrapper.sysv(char uplo,
INDArray a,
int[] ipiv,
INDArray b) |
INDArray |
BaseBlasWrapper.sysv(char uplo,
INDArray a,
int[] ipiv,
INDArray b) |
static INDArray |
Nd4j.tensorMmul(INDArray a,
INDArray b,
int[][] axes)
Tensor matrix multiplication.
|
static INDArray |
Nd4j.tile(INDArray tile,
int... repeat)
An alias for repmat
|
static byte[] |
Nd4j.toByteArray(INDArray arr)
Convert an ndarray to a byte array
|
INDArray |
BaseNDArrayFactory.toFlattened(char order,
INDArray... matrices) |
static INDArray |
Nd4j.toFlattened(char order,
INDArray... matrices)
Create a long row vector of all of the given ndarrays/
|
INDArray |
NDArrayFactory.toFlattened(char order,
INDArray... matrices)
Flatten all of the ndarrays in to one long vector
|
INDArray |
BaseNDArrayFactory.toFlattened(INDArray... matrices) |
static INDArray |
Nd4j.toFlattened(INDArray... matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
NDArrayFactory.toFlattened(INDArray... matrices)
Flatten all of the ndarrays in to one long vector
|
static INDArray |
Nd4j.typeConversion(INDArray array,
DataBuffer.TypeEx targetType) |
protected static void |
BaseNDArrayFactory.validateConcat(int dimension,
INDArray... arrs) |
static INDArray |
Nd4j.var(INDArray compute) |
static INDArray |
Nd4j.var(INDArray compute,
int dimension) |
INDArray |
BaseNDArrayFactory.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
static INDArray |
Nd4j.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
INDArray |
NDArrayFactory.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
static void |
Nd4j.write(INDArray arr,
DataOutputStream dataOutputStream)
Write an ndarray to the specified outputstream
|
static void |
Nd4j.write(OutputStream writer,
INDArray write)
Y
Write an ndarray to a writer
|
static void |
Nd4j.writeNumpy(INDArray write,
String filePath,
String split)
Read line via input streams
|
static void |
Nd4j.writeTxt(INDArray write,
String filePath) |
static void |
Nd4j.writeTxt(INDArray write,
String filePath,
int precision) |
static void |
Nd4j.writeTxt(INDArray write,
String filePath,
String split) |
static void |
Nd4j.writeTxt(INDArray write,
String filePath,
String split,
int precision)
Read line via input streams
|
static void |
Nd4j.writeTxtString(INDArray write,
OutputStream os) |
static void |
Nd4j.writeTxtString(INDArray write,
OutputStream os,
int precision) |
static void |
Nd4j.writeTxtString(INDArray write,
OutputStream os,
String split) |
static void |
Nd4j.writeTxtString(INDArray write,
OutputStream os,
String split,
int precision)
Output line via input streams
|
static INDArray |
Nd4j.zerosLike(INDArray arr)
Empty like
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NDArrayFactory.average(Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
static INDArray |
Nd4j.averageAndPropagate(Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array.
|
abstract INDArray |
BaseNDArrayFactory.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(List<INDArray> list,
int[] shape,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(List<INDArray> list,
int[] shape,
char ordering) |
static INDArray |
Nd4j.hstack(Collection<INDArray> arrs)
Concatenates two matrices horizontally.
|
static void |
Nd4j.shuffle(Collection<INDArray> toShuffle,
int... dimension)
Symmetric in place shuffle of an ndarray
along a specified set of dimensions
|
static void |
Nd4j.shuffle(Collection<INDArray> toShuffle,
Random rnd,
int... dimension)
Symmetric in place shuffle of an ndarray
along a specified set of dimensions
|
void |
NDArrayFactory.shuffle(Collection<INDArray> array,
Random rnd,
int... dimension)
Symmetric in place shuffle of an ndarray
along a specified set of dimensions.
|
static void |
Nd4j.shuffle(List<INDArray> toShuffle,
Random rnd,
List<int[]> dimensions)
Symmetric in place shuffle of an ndarray
along a variable dimensions
|
void |
NDArrayFactory.shuffle(List<INDArray> array,
Random rnd,
List<int[]> dimensions)
Symmetric in place shuffle of an ndarray
along a specified set of dimensions.
|
static INDArray |
Nd4j.toFlattened(char order,
Collection<INDArray> matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
NDArrayFactory.toFlattened(char order,
Collection<INDArray> matrices)
Returns a flattened ndarray with all elements in each ndarray
regardless of dimension.
|
INDArray |
BaseNDArrayFactory.toFlattened(Collection<INDArray> matrices)
Returns a vector with all of the elements in every nd array
equal to the sum of the lengths of the ndarrays
|
static INDArray |
Nd4j.toFlattened(Collection<INDArray> matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
NDArrayFactory.toFlattened(Collection<INDArray> matrices)
/**
Returns a flattened ndarray with all of the elements in each ndarray
regardless of dimension
|
static INDArray |
Nd4j.vstack(Collection<INDArray> arrs)
Concatenates two matrices vertically.
|
| Modifier and Type | Method and Description |
|---|---|
IComplexNDArray |
BaseFFTInstance.fft(INDArray input)
1d discrete fourier op, note that this will
throw an exception if the passed in input
isn't a vector.
|
IComplexNDArray |
FFTInstance.fft(INDArray input)
1d discrete fourier op, note that this will
throw an exception if the passed in input
isn't a vector.
|
static IComplexNDArray |
FFT.fft(INDArray input)
1d discrete fourier op, note that this will
throw an exception if the passed in input
isn't a vector.
|
IComplexNDArray |
BaseFFTInstance.fft(INDArray transform,
int numElements)
FFT along a particular dimension
|
IComplexNDArray |
FFTInstance.fft(INDArray transform,
int numElements)
FFT along a particular dimension
|
static IComplexNDArray |
FFT.fft(INDArray transform,
int numElements)
FFT along a particular dimension
|
IComplexNDArray |
DefaultFFTInstance.fft(INDArray transform,
int numElements,
int dimension)
FFT along a particular dimension
|
IComplexNDArray |
FFTInstance.fft(INDArray transform,
int numElements,
int dimension)
FFT along a particular dimension
|
static IComplexNDArray |
FFT.fft(INDArray transform,
int numElements,
int dimension)
FFT along a particular dimension
|
IComplexNDArray |
BaseFFTInstance.fftn(INDArray transform)
FFT on the whole array (n is equal the first dimension shape)
|
IComplexNDArray |
FFTInstance.fftn(INDArray transform)
FFT on the whole array (n is equal the first dimension shape)
|
static IComplexNDArray |
FFT.fftn(INDArray transform)
FFT on the whole array (n is equal the first dimension shape)
|
IComplexNDArray |
BaseFFTInstance.fftn(INDArray transform,
int dimension,
int numElements)
Computes the fft along the first non singleton dimension of op
when it is a matrix
|
IComplexNDArray |
FFTInstance.fftn(INDArray transform,
int dimension,
int numElements)
Computes the fft along the first non singleton dimension of op
when it is a matrix
|
static IComplexNDArray |
FFT.fftn(INDArray transform,
int dimension,
int numElements)
Computes the fft along the first non singleton dimension of op
when it is a matrix
|
protected Op |
DefaultFFTInstance.getFftOp(INDArray arr,
int n) |
protected Op |
DefaultFFTInstance.getIfftOp(INDArray arr,
int n) |
IComplexNDArray |
DefaultFFTInstance.ifft(INDArray transform,
int numElements)
FFT along a particular dimension
|
IComplexNDArray |
FFTInstance.ifft(INDArray transform,
int numElements)
FFT along a particular dimension
|
static IComplexNDArray |
FFT.ifft(INDArray transform,
int numElements)
FFT along a particular dimension
|
IComplexNDArray |
DefaultFFTInstance.ifft(INDArray transform,
int numElements,
int dimension)
IFFT along a particular dimension
|
IComplexNDArray |
FFTInstance.ifft(INDArray transform,
int numElements,
int dimension)
IFFT along a particular dimension
|
static IComplexNDArray |
FFT.ifft(INDArray transform,
int numElements,
int dimension)
IFFT along a particular dimension
|
IComplexNDArray |
BaseFFTInstance.ifftn(INDArray transform) |
IComplexNDArray |
FFTInstance.ifftn(INDArray transform) |
IComplexNDArray |
BaseFFTInstance.ifftn(INDArray transform,
int dimension,
int numElements)
ND IFFT, computes along the first on singleton dimension of
op
|
IComplexNDArray |
FFTInstance.ifftn(INDArray transform,
int dimension,
int numElements)
ND IFFT, computes along the first on singleton dimension of
op
|
static IComplexNDArray |
FFT.ifftn(INDArray transform,
int dimension,
int numElements)
ND IFFT, computes along the first on singleton dimension of
op
|
| Modifier and Type | Method and Description |
|---|---|
static Task |
TaskUtils.buildTask(INDArray array) |
static Task |
TaskUtils.buildTask(INDArray[] array,
INDArray[] labels) |
static Task |
TaskUtils.buildTask(INDArray[] array,
INDArray[] labels) |
static Task |
TaskUtils.buildTask(INDArray array,
INDArray labels) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ShapeOffsetResolution.getArr() |
| Modifier and Type | Method and Description |
|---|---|
static INDArrayIndex[] |
NDArrayIndex.allFor(INDArray arr)
Generate an all index
equal to the rank of the given array
|
static boolean |
BooleanIndexing.and(INDArray n,
Condition cond)
And over the whole ndarray given some condition
|
static boolean[] |
BooleanIndexing.and(INDArray n,
Condition condition,
int... dimension)
And over the whole ndarray given some condition, with respect to dimensions
|
static void |
BooleanIndexing.applyWhere(INDArray to,
Condition condition,
com.google.common.base.Function<Number,Number> function)
Based on the matching elements
op to based on condition to with function function
|
static void |
BooleanIndexing.applyWhere(INDArray to,
Condition condition,
com.google.common.base.Function<Number,Number> function,
com.google.common.base.Function<Number,Number> alternativeFunction)
Based on the matching elements
op to based on condition to with function function
|
static void |
BooleanIndexing.applyWhere(INDArray to,
Condition condition,
Number number)
This method sets provided number to all elements which match specified condition
|
static void |
BooleanIndexing.assignIf(INDArray to,
INDArray from,
Condition condition)
This method does element-wise assing for 2 equal-sized matrices, for each element that matches Condition
|
static INDArrayIndex[] |
NDArrayIndex.create(INDArray index)
Create from a matrix.
|
static INDArrayIndex[] |
Indices.createFromStartAndEnd(INDArray start,
INDArray end)
Create an n dimensional index
based on the given interval indices.
|
static INDArrayIndex[] |
Indices.createFromStartAndEnd(INDArray start,
INDArray end,
boolean inclusive)
Create indices representing intervals
along each dimension
|
void |
SpecifiedIndex.init(INDArray arr,
int dimension) |
void |
IntervalIndex.init(INDArray arr,
int dimension) |
void |
PointIndex.init(INDArray arr,
int dimension) |
void |
NDArrayIndex.init(INDArray arr,
int dimension) |
void |
INDArrayIndex.init(INDArray arr,
int dimension)
Init the index wrt
the dimension and the given nd array
|
void |
NDArrayIndexEmpty.init(INDArray arr,
int dimension) |
void |
NewAxis.init(INDArray arr,
int dimension) |
void |
SpecifiedIndex.init(INDArray arr,
int begin,
int dimension) |
void |
IntervalIndex.init(INDArray arr,
int begin,
int dimension) |
void |
PointIndex.init(INDArray arr,
int begin,
int dimension) |
void |
NDArrayIndex.init(INDArray arr,
int begin,
int dimension) |
void |
INDArrayIndex.init(INDArray arr,
int begin,
int dimension)
Init the index wrt
the dimension and the given nd array
|
void |
NDArrayIndexEmpty.init(INDArray arr,
int begin,
int dimension) |
void |
NewAxis.init(INDArray arr,
int begin,
int dimension) |
void |
NDArrayIndexAll.init(INDArray arr,
int begin,
int dimension) |
static boolean |
Indices.isScalar(INDArray indexOver,
INDArrayIndex... indexes)
Check if the given indexes
over the specified array
are searching for a scalar
|
static int |
Indices.linearOffset(int index,
INDArray arr)
Compute the linear offset
for an index in an ndarray.
|
static int |
NDArrayIndex.offset(INDArray arr,
INDArrayIndex... indices)
Compute the offset given an array of offsets.
|
static int |
NDArrayIndex.offset(INDArray arr,
int... offsets)
Compute the offset given an array of offsets.
|
static boolean |
BooleanIndexing.or(INDArray n,
Condition cond)
Or over the whole ndarray given some condition
|
static boolean[] |
BooleanIndexing.or(INDArray n,
Condition condition,
int... dimension)
Or over the whole ndarray given some condition, with respect to dimensions
|
static void |
BooleanIndexing.replaceWhere(INDArray to,
INDArray from,
Condition condition)
This method does element-wise assing for 2 equal-sized matrices, for each element that matches Condition
|
static void |
BooleanIndexing.replaceWhere(INDArray to,
Number set,
Condition condition)
This method does element-wise assing for 2 equal-sized matrices, for each element that matches Condition
|
static INDArrayIndex[] |
NDArrayIndex.resolve(INDArray arr,
INDArrayIndex... intendedIndexes)
Given an all index and
the intended indexes, return an
index array containing a combination of all elements
for slicing and overriding particular indexes where necessary
|
static int |
Indices.rowNumber(int index,
INDArray arr)
Compute the linear offset
for an index in an ndarray.
|
void |
ShapeOffsetResolution.setArr(INDArray arr) |
static int[] |
Indices.stride(INDArray arr,
INDArrayIndex[] indexes,
int... shape)
Return the stride to be used for indexing
|
static void |
NDArrayIndex.updateForNewAxes(INDArray arr,
INDArrayIndex... indexes)
Set the shape and stride for
new axes based dimensions
|
| Constructor and Description |
|---|
ShapeOffsetResolution(INDArray arr)
Specify the array to use for resolution
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
InvertMatrix.invert(INDArray arr,
boolean inPlace)
Inverts a matrix
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
InvertMatrix.invert(INDArray arr,
boolean inPlace)
Inverts a matrix
|
| Modifier and Type | Field and Description |
|---|---|
INDArray |
AdaGrad.historicalGradient |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NoOpUpdater.getGradient(INDArray gradient,
int iteration) |
INDArray |
GradientUpdater.getGradient(INDArray gradient,
int iteration)
Modify the gradient
to be an update
|
INDArray |
Sgd.getGradient(INDArray gradient,
int iteration) |
INDArray |
AdaGrad.getGradient(INDArray gradient,
int iteration)
Gets feature specific learning rates
Adagrad keeps a history of gradients being passed in.
|
INDArray |
Adam.getGradient(INDArray gradient,
int iteration)
Calculate the update based on the given gradient
|
INDArray |
RmsProp.getGradient(INDArray gradient,
int iteration) |
INDArray |
Nesterovs.getGradient(INDArray gradient,
int iteration)
Get the nesterov update
|
INDArray |
AdaDelta.getGradient(INDArray gradient,
int iteration)
Get the updated gradient for the given gradient
and also update the state of ada delta.
|
INDArray |
AdaGrad.getGradient(INDArray gradient,
int slice,
int[] shape) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NoOpUpdater.getGradient(INDArray gradient,
int iteration) |
INDArray |
GradientUpdater.getGradient(INDArray gradient,
int iteration)
Modify the gradient
to be an update
|
INDArray |
Sgd.getGradient(INDArray gradient,
int iteration) |
INDArray |
AdaGrad.getGradient(INDArray gradient,
int iteration)
Gets feature specific learning rates
Adagrad keeps a history of gradients being passed in.
|
INDArray |
Adam.getGradient(INDArray gradient,
int iteration)
Calculate the update based on the given gradient
|
INDArray |
RmsProp.getGradient(INDArray gradient,
int iteration) |
INDArray |
Nesterovs.getGradient(INDArray gradient,
int iteration)
Get the nesterov update
|
INDArray |
AdaDelta.getGradient(INDArray gradient,
int iteration)
Get the updated gradient for the given gradient
and also update the state of ada delta.
|
INDArray |
AdaGrad.getGradient(INDArray gradient,
int slice,
int[] shape) |
void |
NoOpUpdater.setStateViewArray(INDArray viewArray,
int[] shape,
char order,
boolean initialize) |
void |
GradientUpdater.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize)
For the internal updater state (if any): set this to use the provided array.
|
void |
Sgd.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
AdaGrad.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
Adam.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
RmsProp.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
Nesterovs.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
AdaDelta.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ILossFunction.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask)
Compute the gradient of the loss function with respect to the inputs: dL/dOutput
|
INDArray |
ILossFunction.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask)
Compute the score (loss function value) for each example individually.
|
static INDArray |
LossUtil.dLdZsoftmax(INDArray dlda,
INDArray a)
Calculate dL/dz for softmax activation function, from dL/da and a, where
a: output activations dL/da: derivative of loss function with respect to the output activations Note: This version does NOT modify either input arrays. |
static INDArray |
LossUtil.dLdZsoftmaxi(INDArray dlda,
INDArray a)
Calculate dL/dz for softmax activation function, from dL/da and a, where
a: output activations dL/da: derivative of loss function with respect to the output activations Note: This version WILL modify both input arrays (for efficiency). |
static INDArray |
LossUtil.dLdZsoftmaxPreOut(INDArray dlda,
INDArray z) |
INDArray |
LossCalculation.scoreExamples()
Calculate the score for each example individually.
|
| Modifier and Type | Method and Description |
|---|---|
org.apache.commons.math3.util.Pair<Double,INDArray> |
ILossFunction.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average)
Compute both the score (loss function value) and gradient.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ILossFunction.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask)
Compute the gradient of the loss function with respect to the inputs: dL/dOutput
|
org.apache.commons.math3.util.Pair<Double,INDArray> |
ILossFunction.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average)
Compute both the score (loss function value) and gradient.
|
double |
ILossFunction.computeScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average)
Compute the score (loss function value) for the given inputs.
|
INDArray |
ILossFunction.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask)
Compute the score (loss function value) for each example individually.
|
static INDArray |
LossUtil.dLdZsoftmax(INDArray dlda,
INDArray a)
Calculate dL/dz for softmax activation function, from dL/da and a, where
a: output activations dL/da: derivative of loss function with respect to the output activations Note: This version does NOT modify either input arrays. |
static INDArray |
LossUtil.dLdZsoftmaxi(INDArray dlda,
INDArray a)
Calculate dL/dz for softmax activation function, from dL/da and a, where
a: output activations dL/da: derivative of loss function with respect to the output activations Note: This version WILL modify both input arrays (for efficiency). |
static INDArray |
LossUtil.dLdZsoftmaxPreOut(INDArray dlda,
INDArray z) |
static double |
LossFunctions.score(INDArray labels,
LossFunctions.LossFunction lossFunction,
INDArray z,
double l2,
double l1,
boolean useRegularization)
Generic scoring function.
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
LossMCXENT.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossL2.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMSLE.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMAPE.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMAE.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossHinge.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossL1.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossBinaryXENT.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMSE.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossKLD.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossPoisson.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMCXENT.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossL2.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMSLE.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMAPE.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMAE.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossHinge.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossL1.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossBinaryXENT.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMSE.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossKLD.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossPoisson.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossL2.scoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMSLE.scoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMAPE.scoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.scoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.scoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossHinge.scoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossL1.scoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossPoisson.scoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
| Modifier and Type | Method and Description |
|---|---|
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossMCXENT.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossL2.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossMSLE.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossMAPE.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossSquaredHinge.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossCosineProximity.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossHinge.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossL1.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossBinaryXENT.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossKLD.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossPoisson.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
LossMCXENT.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossL2.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMSLE.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMAPE.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMAE.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossHinge.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossL1.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossBinaryXENT.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMSE.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossKLD.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossPoisson.computeGradient(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossMCXENT.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossL2.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossMSLE.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossMAPE.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossSquaredHinge.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossCosineProximity.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossHinge.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossL1.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossBinaryXENT.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossKLD.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
org.apache.commons.math3.util.Pair<Double,INDArray> |
LossPoisson.computeGradientAndScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
double |
LossMCXENT.computeScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
double |
LossL2.computeScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
double |
LossMSLE.computeScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
double |
LossMAPE.computeScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
double |
LossSquaredHinge.computeScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
double |
LossMAE.computeScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
double |
LossCosineProximity.computeScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
double |
LossHinge.computeScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
double |
LossL1.computeScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
double |
LossBinaryXENT.computeScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
double |
LossMSE.computeScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
double |
LossKLD.computeScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
double |
LossPoisson.computeScore(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask,
boolean average) |
INDArray |
LossMCXENT.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossL2.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMSLE.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMAPE.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMAE.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossHinge.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossL1.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossBinaryXENT.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMSE.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossKLD.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossPoisson.computeScoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossL2.scoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMSLE.scoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossMAPE.scoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.scoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.scoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossHinge.scoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossL1.scoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
INDArray |
LossPoisson.scoreArray(INDArray labels,
INDArray preOutput,
String activationFn,
INDArray mask) |
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Transforms.abs(INDArray ndArray)
Abs funciton
|
static INDArray |
Transforms.abs(INDArray ndArray,
boolean dup)
Abs function
|
static INDArray |
Transforms.acos(INDArray arr) |
static INDArray |
Transforms.acos(INDArray in,
boolean copy) |
static INDArray |
Transforms.asin(INDArray arr) |
static INDArray |
Transforms.asin(INDArray in,
boolean copy) |
static INDArray |
Transforms.atan(INDArray arr) |
static INDArray |
Transforms.atan(INDArray in,
boolean copy) |
static INDArray |
Transforms.ceil(INDArray arr) |
static INDArray |
Transforms.ceil(INDArray in,
boolean copy) |
static INDArray |
Transforms.ceiling(INDArray ndArray)
Binary matrix of whether the number at a given index is greater than
|
static INDArray |
Transforms.ceiling(INDArray ndArray,
boolean copyOnOps)
Ceiling function
|
static INDArray |
Transforms.cos(INDArray in) |
static INDArray |
Transforms.cos(INDArray in,
boolean copy) |
static INDArray |
Transforms.eps(INDArray ndArray) |
static INDArray |
Transforms.eps(INDArray ndArray,
boolean dup)
Eps function
|
static INDArray |
Transforms.exp(INDArray ndArray) |
static INDArray |
Transforms.exp(INDArray ndArray,
boolean dup)
Exp function
|
static INDArray |
Transforms.floor(INDArray ndArray)
Binary matrix of whether the number at a given index is greater than
|
static INDArray |
Transforms.floor(INDArray ndArray,
boolean dup)
Floor function
|
static INDArray |
Transforms.greaterThanOrEqual(INDArray first,
INDArray ndArray)
1 if greater than or equal to 0 otherwise (at each element)
|
static INDArray |
Transforms.greaterThanOrEqual(INDArray first,
INDArray ndArray,
boolean dup)
Eps function
|
static INDArray |
Transforms.hardTanh(INDArray ndArray) |
static INDArray |
Transforms.hardTanh(INDArray ndArray,
boolean dup)
Hard tanh
|
static INDArray |
Transforms.identity(INDArray ndArray) |
static INDArray |
Transforms.identity(INDArray ndArray,
boolean dup)
Identity function
|
static INDArray |
Transforms.leakyRelu(INDArray arr) |
static INDArray |
Transforms.leakyRelu(INDArray in,
boolean copy) |
static INDArray |
Transforms.lessThanOrEqual(INDArray first,
INDArray ndArray)
1 if less than or equal to 0 otherwise (at each element)
|
static INDArray |
Transforms.lessThanOrEqual(INDArray first,
INDArray ndArray,
boolean dup)
Eps function
|
static INDArray |
Transforms.log(INDArray ndArray) |
static INDArray |
Transforms.log(INDArray ndArray,
boolean dup)
Log function
|
static INDArray |
Transforms.max(INDArray ndArray,
double k)
Stabilize to be within a range of k
|
static INDArray |
Transforms.max(INDArray ndArray,
double k,
boolean dup)
Stabilize to be within a range of k
|
static INDArray |
Transforms.neg(INDArray ndArray)
Returns the negative of an ndarray
|
static INDArray |
Transforms.neg(INDArray ndArray,
boolean dup)
Negative
|
static INDArray |
Transforms.normalizeZeroMeanAndUnitVariance(INDArray toNormalize)
Normalize data to zero mean and unit variance
substract by the mean and divide by the standard deviation
|
static INDArray |
Transforms.pow(INDArray ndArray,
Number power)
Pow function
|
static INDArray |
Transforms.pow(INDArray ndArray,
Number power,
boolean dup)
Pow function
|
static INDArray |
Transforms.relu(INDArray arr) |
static INDArray |
Transforms.relu(INDArray in,
boolean copy) |
static INDArray |
Transforms.round(INDArray ndArray)
Rounding function
|
static INDArray |
Transforms.round(INDArray ndArray,
boolean dup)
Rounding function
|
static INDArray |
Transforms.sigmoid(INDArray ndArray)
Sigmoid function
|
static INDArray |
Transforms.sigmoid(INDArray ndArray,
boolean dup)
Sigmoid function
|
static INDArray |
Transforms.sign(INDArray toSign)
Signum function of this ndarray
|
static INDArray |
Transforms.sign(INDArray toSign,
boolean dup)
Signum function of this ndarray
|
static INDArray |
Transforms.sin(INDArray in) |
static INDArray |
Transforms.sin(INDArray in,
boolean copy) |
static INDArray |
Transforms.softPlus(INDArray arr) |
static INDArray |
Transforms.softPlus(INDArray in,
boolean copy) |
static INDArray |
Transforms.sqrt(INDArray ndArray)
Sqrt function
|
static INDArray |
Transforms.sqrt(INDArray ndArray,
boolean dup)
Sqrt function
|
static INDArray |
Transforms.stabilize(INDArray ndArray,
double k) |
static INDArray |
Transforms.stabilize(INDArray ndArray,
double k,
boolean dup)
Stabilize to be within a range of k
|
static INDArray |
Transforms.tanh(INDArray ndArray)
Tanh function
|
static INDArray |
Transforms.tanh(INDArray ndArray,
boolean dup)
Tanh function
|
static INDArray |
Transforms.unitVec(INDArray toScale)
Scale by 1 / norm2 of the matrix
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
Transforms.abs(INDArray ndArray)
Abs funciton
|
static INDArray |
Transforms.abs(INDArray ndArray,
boolean dup)
Abs function
|
static INDArray |
Transforms.acos(INDArray arr) |
static INDArray |
Transforms.acos(INDArray in,
boolean copy) |
static INDArray |
Transforms.asin(INDArray arr) |
static INDArray |
Transforms.asin(INDArray in,
boolean copy) |
static INDArray |
Transforms.atan(INDArray arr) |
static INDArray |
Transforms.atan(INDArray in,
boolean copy) |
static INDArray |
Transforms.ceil(INDArray arr) |
static INDArray |
Transforms.ceil(INDArray in,
boolean copy) |
static INDArray |
Transforms.ceiling(INDArray ndArray)
Binary matrix of whether the number at a given index is greater than
|
static INDArray |
Transforms.ceiling(INDArray ndArray,
boolean copyOnOps)
Ceiling function
|
static INDArray |
Transforms.cos(INDArray in) |
static INDArray |
Transforms.cos(INDArray in,
boolean copy) |
static double |
Transforms.cosineSim(INDArray d1,
INDArray d2)
Cosine similarity
|
static INDArray |
Transforms.eps(INDArray ndArray) |
static INDArray |
Transforms.eps(INDArray ndArray,
boolean dup)
Eps function
|
static INDArray |
Transforms.exp(INDArray ndArray) |
static INDArray |
Transforms.exp(INDArray ndArray,
boolean dup)
Exp function
|
static INDArray |
Transforms.floor(INDArray ndArray)
Binary matrix of whether the number at a given index is greater than
|
static INDArray |
Transforms.floor(INDArray ndArray,
boolean dup)
Floor function
|
static INDArray |
Transforms.greaterThanOrEqual(INDArray first,
INDArray ndArray)
1 if greater than or equal to 0 otherwise (at each element)
|
static INDArray |
Transforms.greaterThanOrEqual(INDArray first,
INDArray ndArray,
boolean dup)
Eps function
|
static INDArray |
Transforms.hardTanh(INDArray ndArray) |
static INDArray |
Transforms.hardTanh(INDArray ndArray,
boolean dup)
Hard tanh
|
static INDArray |
Transforms.identity(INDArray ndArray) |
static INDArray |
Transforms.identity(INDArray ndArray,
boolean dup)
Identity function
|
static INDArray |
Transforms.leakyRelu(INDArray arr) |
static INDArray |
Transforms.leakyRelu(INDArray in,
boolean copy) |
static INDArray |
Transforms.lessThanOrEqual(INDArray first,
INDArray ndArray)
1 if less than or equal to 0 otherwise (at each element)
|
static INDArray |
Transforms.lessThanOrEqual(INDArray first,
INDArray ndArray,
boolean dup)
Eps function
|
static INDArray |
Transforms.log(INDArray ndArray) |
static INDArray |
Transforms.log(INDArray ndArray,
boolean dup)
Log function
|
static INDArray |
Transforms.max(INDArray ndArray,
double k)
Stabilize to be within a range of k
|
static INDArray |
Transforms.max(INDArray ndArray,
double k,
boolean dup)
Stabilize to be within a range of k
|
static INDArray |
Transforms.neg(INDArray ndArray)
Returns the negative of an ndarray
|
static INDArray |
Transforms.neg(INDArray ndArray,
boolean dup)
Negative
|
static INDArray |
Transforms.normalizeZeroMeanAndUnitVariance(INDArray toNormalize)
Normalize data to zero mean and unit variance
substract by the mean and divide by the standard deviation
|
static INDArray |
Transforms.pow(INDArray ndArray,
Number power)
Pow function
|
static INDArray |
Transforms.pow(INDArray ndArray,
Number power,
boolean dup)
Pow function
|
static INDArray |
Transforms.relu(INDArray arr) |
static INDArray |
Transforms.relu(INDArray in,
boolean copy) |
static INDArray |
Transforms.round(INDArray ndArray)
Rounding function
|
static INDArray |
Transforms.round(INDArray ndArray,
boolean dup)
Rounding function
|
static INDArray |
Transforms.sigmoid(INDArray ndArray)
Sigmoid function
|
static INDArray |
Transforms.sigmoid(INDArray ndArray,
boolean dup)
Sigmoid function
|
static INDArray |
Transforms.sign(INDArray toSign)
Signum function of this ndarray
|
static INDArray |
Transforms.sign(INDArray toSign,
boolean dup)
Signum function of this ndarray
|
static INDArray |
Transforms.sin(INDArray in) |
static INDArray |
Transforms.sin(INDArray in,
boolean copy) |
static INDArray |
Transforms.softPlus(INDArray arr) |
static INDArray |
Transforms.softPlus(INDArray in,
boolean copy) |
static INDArray |
Transforms.sqrt(INDArray ndArray)
Sqrt function
|
static INDArray |
Transforms.sqrt(INDArray ndArray,
boolean dup)
Sqrt function
|
static INDArray |
Transforms.stabilize(INDArray ndArray,
double k) |
static INDArray |
Transforms.stabilize(INDArray ndArray,
double k,
boolean dup)
Stabilize to be within a range of k
|
static INDArray |
Transforms.tanh(INDArray ndArray)
Tanh function
|
static INDArray |
Transforms.tanh(INDArray ndArray,
boolean dup)
Tanh function
|
static INDArray |
Transforms.unitVec(INDArray toScale)
Scale by 1 / norm2 of the matrix
|
| Modifier and Type | Method and Description |
|---|---|
String |
NDArrayStrings.format(INDArray arr)
Format the given ndarray as a string
|
| Modifier and Type | Method and Description |
|---|---|
static INDArray |
NDArrayUtil.toNDArray(int[] nums) |
static INDArray |
NDArrayUtil.toNDArray(int[][] nums) |
static INDArray |
FeatureUtil.toOutcomeMatrix(int[] index,
int numOutcomes)
Creates an out come vector from the specified inputs
|
static INDArray |
FeatureUtil.toOutcomeVector(int index,
int numOutcomes)
Creates an out come vector from the specified inputs
|
| Modifier and Type | Method and Description |
|---|---|
static void |
LinAlgExceptions.assertColumns(INDArray n,
INDArray n2) |
static void |
LinAlgExceptions.assertMatrix(INDArray... arr) |
static void |
LinAlgExceptions.assertMatrix(INDArray arr) |
static void |
LinAlgExceptions.assertMultiplies(INDArray nd1,
INDArray nd2)
Asserts matrix multiply rules (columns of left == rows of right or rows of left == columns of right)
|
static void |
LinAlgExceptions.assertRows(INDArray n,
INDArray n2) |
static void |
LinAlgExceptions.assertSameLength(INDArray n,
INDArray n2)
Asserts both arrays be the same length
|
static void |
LinAlgExceptions.assertSameShape(INDArray n,
INDArray n2) |
static void |
LinAlgExceptions.assertValidNum(INDArray n) |
static void |
LinAlgExceptions.assertVector(INDArray... arr) |
static void |
LinAlgExceptions.assertVector(INDArray arr) |
static int |
NDArrayMath.lengthPerSlice(INDArray arr)
Return the length of a slice
|
static int |
NDArrayMath.lengthPerSlice(INDArray arr,
int... dimension)
The number of elements in a slice
along a set of dimensions
|
static int |
NDArrayMath.mapIndexOntoTensor(int index,
INDArray arr,
int... rank)
This maps an index of a vector
on to a vector in the matrix that can be used
for indexing in to a tensor
|
static int |
NDArrayMath.mapIndexOntoVector(int index,
INDArray arr)
This maps an index of a vector
on to a vector in the matrix that can be used
for indexing in to a tensor
|
static int |
NDArrayMath.matricesPerSlice(INDArray arr)
The number of vectors
in each slice of an ndarray.
|
static void |
FeatureUtil.normalizeMatrix(INDArray toNormalize) |
static int |
NDArrayMath.numVectors(INDArray arr)
Return the number of vectors for an array
the number of vectors for an array
|
static int |
NDArrayMath.offsetForSlice(INDArray arr,
int slice)
Compute the offset for a given slice
|
static void |
FeatureUtil.scaleByMax(INDArray toScale)
Divides each row by its max
|
static void |
FeatureUtil.scaleMinMax(double min,
double max,
INDArray toScale)
Scales the ndarray columns
to the given min/max values
|
static int |
NDArrayMath.sliceOffsetForTensor(int index,
INDArray arr,
int[] tensorShape)
calculates the offset for a tensor
|
static int |
NDArrayMath.tensorsPerSlice(INDArray arr,
int[] tensorShape)
Computes the tensors per slice
given a tensor shape and array
|
static int[] |
NDArrayUtil.toInts(INDArray n) |
static int |
NDArrayMath.vectorsPerSlice(INDArray arr)
The number of vectors
in each slice of an ndarray.
|
static int |
NDArrayMath.vectorsPerSlice(INDArray arr,
int... rank)
The number of vectors
in each slice of an ndarray.
|
Copyright © 2016. All Rights Reserved.