| 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) |
void |
BaseLapack.getrf(int M,
int N,
INDArray A,
int lda,
int[] IPIV,
int INFO) |
void |
BaseLapack.getri(int N,
INDArray A,
int lda,
int[] IPIV,
INDArray WORK,
int lwork,
int INFO) |
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 |
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 |
INDArray.add(INDArray other)
copy addition of two NDArrays
|
INDArray |
BaseNDArray.add(INDArray other)
copy addition of two matrices
|
INDArray |
INDArray.add(INDArray other,
INDArray result)
copy addition of two NDArrays
|
INDArray |
BaseNDArray.add(INDArray other,
INDArray result)
copy addition of two matrices
|
INDArray |
INDArray.add(Number n)
Scalar addition (cloning)
|
INDArray |
BaseNDArray.add(Number n) |
INDArray |
INDArray.add(Number n,
INDArray result) |
INDArray |
BaseNDArray.add(Number n,
INDArray result) |
INDArray |
INDArray.addColumnVector(INDArray columnVector)
Addition of a column vector (copy)
|
INDArray |
BaseNDArray.addColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.addi(INDArray other)
in place addition of two NDArrays
|
INDArray |
BaseNDArray.addi(INDArray other)
in place addition of two matrices
|
INDArray |
INDArray.addi(INDArray other,
INDArray result)
in place addition of two NDArrays
|
INDArray |
BaseNDArray.addi(INDArray other,
INDArray result)
in place addition of two matrices
|
INDArray |
INDArray.addi(Number n)
In place scalar addition
|
INDArray |
BaseNDArray.addi(Number n) |
INDArray |
INDArray.addi(Number n,
INDArray result)
In place addition
|
INDArray |
BaseNDArray.addi(Number n,
INDArray result) |
INDArray |
INDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
BaseNDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.addiRowVector(INDArray rowVector)
In place addition of a row vector
|
INDArray |
BaseNDArray.addiRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.addRowVector(INDArray rowVector)
Addition of a row vector (copy)
|
INDArray |
BaseNDArray.addRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.assign(INDArray arr)
Assign all of the elements in the given
ndarray to this ndarray
|
INDArray |
BaseNDArray.assign(INDArray arr)
Assign all of the elements in the given
ndarray to this ndarray
|
INDArray |
INDArray.assign(Number value)
Set the value of the ndarray to the specified value
|
INDArray |
BaseNDArray.assign(Number value)
Set the value of the ndarray to the specified value
|
INDArray |
INDArray.broadcast(int... shape)
Broadcasts this ndarray to be the specified shape
|
INDArray |
BaseNDArray.broadcast(int... shape)
Broadcasts this ndarray to be the specified shape
|
INDArray |
INDArray.cond(Condition condition)
1 in the ndarray if the element matches
the condition 0 otherwise
|
INDArray |
BaseNDArray.cond(Condition condition) |
INDArray |
INDArray.condi(Condition condition)
1 in the ndarray if the element matches
the condition 0 otherwise
|
INDArray |
BaseNDArray.condi(Condition condition) |
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 |
INDArray.cumsum(int dimension)
Cumulative sum along a dimension (in place)
|
INDArray |
BaseNDArray.cumsum(int dimension)
Cumulative sum along a dimension (in place)
|
INDArray |
INDArray.cumsumi(int dimension)
Cumulative sum along a dimension
|
INDArray |
BaseNDArray.cumsumi(int dimension)
Cumulative sum along a dimension
|
INDArray |
INDArray.dimShuffle(Object[] rearrange,
int[] newOrder,
boolean[] broadCastable)
Dimshuffle: an extension of permute that adds the ability
to broadcast various dimensions.
|
INDArray |
BaseNDArray.dimShuffle(Object[] rearrange,
int[] newOrder,
boolean[] broadCastable)
Dimshuffle: an extension of permute that adds the ability
to broadcast various dimensions.
|
INDArray |
INDArray.div(INDArray other)
Copy (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.div(INDArray other)
in place (element wise) division of two matrices
|
INDArray |
INDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two matrices
|
INDArray |
INDArray.div(Number n)
Division by a number
|
INDArray |
BaseNDArray.div(Number n) |
INDArray |
INDArray.div(Number n,
INDArray result) |
INDArray |
BaseNDArray.div(Number n,
INDArray result) |
INDArray |
INDArray.divColumnVector(INDArray columnVector)
Division of a column vector (copy)
|
INDArray |
BaseNDArray.divColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.divi(INDArray other)
in place (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.divi(INDArray other)
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(INDArray other,
INDArray result)
in place (element wise) division of two matrices
|
INDArray |
INDArray.divi(Number n)
In place scalar division
|
INDArray |
BaseNDArray.divi(Number n) |
INDArray |
INDArray.divi(Number n,
INDArray result)
In place division of this ndarray
|
INDArray |
BaseNDArray.divi(Number n,
INDArray result) |
INDArray |
INDArray.diviColumnVector(INDArray columnVector)
In place division of a column vector
|
INDArray |
BaseNDArray.diviColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.diviRowVector(INDArray rowVector)
In place division of a row vector
|
INDArray |
BaseNDArray.diviRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.divRowVector(INDArray rowVector)
Division of a row vector (copy)
|
INDArray |
BaseNDArray.divRowVector(INDArray rowVector)
In place addition of a column vector
|
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 |
INDArray.dup()
Return a copy of this ndarray
|
INDArray |
BaseNDArray.dup() |
INDArray |
INDArray.dup(char order)
Return a copy of this ndarray, where the returned ndarray has the specified order
|
INDArray |
BaseNDArray.dup(char order) |
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(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(Number other)
Returns an ndarray with 1 if the element is epsilon equals
|
INDArray |
BaseNDArray.eps(Number other)
Returns an ndarray with 1 if the element is epsilon equals
|
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(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(Number other)
Returns an ndarray with 1 if the element is epsilon equals
|
INDArray |
BaseNDArray.epsi(Number other)
Returns an ndarray with 1 if the element is epsilon equals
|
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(INDArray 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.eq(Number 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(INDArray 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.eqi(Number other) |
INDArray |
INDArray.get(INDArrayIndex... indexes)
Returns a subset of this array based on the specified
indexes
|
INDArray |
BaseNDArray.get(INDArrayIndex... indexes)
Returns a subset of this array based on the specified
indexes
|
INDArray |
INDArray.getColumn(int i)
Returns the specified column.
|
INDArray |
BaseNDArray.getColumn(int c)
Get the specified column
|
INDArray |
INDArray.getColumns(int... columns)
Get a list of specified columns
|
INDArray |
BaseNDArray.getColumns(int... cindices)
Get whole columns
from the passed indices.
|
INDArray |
INDArray.getRow(int i)
Returns the specified row.
|
INDArray |
BaseNDArray.getRow(int r)
Get a copy of a 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 i)
Returns the element at the specified index
|
INDArray |
BaseNDArray.getScalar(int i) |
INDArray |
INDArray.getScalar(int[] indices)
Returns the elements at the the specified indices
|
INDArray |
INDArray.getScalar(int row,
int column)
Returns the element at the specified row/column
This will throw an exception if the
|
INDArray |
BaseNDArray.getScalar(int row,
int column)
Returns the element at the specified row/column
This will throw an exception if the
|
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(INDArray other) |
INDArray |
INDArray.gt(Number other)
Greater than boolean (copying)(
|
INDArray |
BaseNDArray.gt(Number 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(INDArray 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.gti(Number other) |
INDArray |
INDArray.linearView()
Returns a linear view reference of shape
1,length(ndarray)
|
INDArray |
BaseNDArray.linearView()
Returns a linear view reference of shape
1,length(ndarray)
|
INDArray |
INDArray.linearViewColumnOrder()
Returns a linear view reference of shape
1,length(ndarray)
|
INDArray |
BaseNDArray.linearViewColumnOrder() |
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(INDArray 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.lt(Number 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(INDArray 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.lti(Number other) |
INDArray |
INDArray.max(int... dimension)
Returns the overall max of this ndarray
|
INDArray |
BaseNDArray.max(int... dimension)
Returns the overall max of this ndarray
|
INDArray |
INDArray.mean(int... dimension)
Returns the overall mean of this ndarray
|
INDArray |
BaseNDArray.mean(int... dimension)
Returns the overall mean of this ndarray
|
INDArray |
INDArray.min(int... dimension)
Returns the overall min of this ndarray
|
INDArray |
BaseNDArray.min(int... dimension)
Returns the overall min of this ndarray
|
INDArray |
INDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
INDArray |
BaseNDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
INDArray |
INDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
BaseNDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmuli(INDArray other)
Perform an inplace matrix multiplication
|
INDArray |
BaseNDArray.mmuli(INDArray other)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmuli(INDArray other,
INDArray result)
Perform an inplace matrix multiplication
|
INDArray |
BaseNDArray.mmuli(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mul(INDArray other)
copy (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.mul(INDArray other)
copy (element wise) multiplication of two matrices
|
INDArray |
INDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two matrices
|
INDArray |
INDArray.mul(Number n)
Scalar multiplication (copy)
|
INDArray |
BaseNDArray.mul(Number n) |
INDArray |
INDArray.mul(Number n,
INDArray result) |
INDArray |
BaseNDArray.mul(Number n,
INDArray result) |
INDArray |
INDArray.mulColumnVector(INDArray columnVector)
Multiplication of a column vector (copy)
|
INDArray |
BaseNDArray.mulColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.muli(INDArray other)
in place (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.muli(INDArray other)
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(INDArray other,
INDArray result)
in place (element wise) multiplication of two matrices
|
INDArray |
INDArray.muli(Number n)
In place scalar multiplication
|
INDArray |
BaseNDArray.muli(Number n) |
INDArray |
INDArray.muli(Number n,
INDArray result)
In place multiplication of this ndarray
|
INDArray |
BaseNDArray.muli(Number n,
INDArray result) |
INDArray |
INDArray.muliColumnVector(INDArray columnVector)
In place multiplication of a column vector
|
INDArray |
BaseNDArray.muliColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.muliRowVector(INDArray rowVector)
In place multiplication of a row vector
|
INDArray |
BaseNDArray.muliRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.mulRowVector(INDArray rowVector)
Multiplication of a row vector (copy)
|
INDArray |
BaseNDArray.mulRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.neg()
Returns the ndarray negative (cloned)
|
INDArray |
BaseNDArray.neg()
Negate each element.
|
INDArray |
INDArray.negi()
In place setting of the negative version of this ndarray
|
INDArray |
BaseNDArray.negi()
Negate each element (in-place).
|
INDArray |
INDArray.neq(INDArray other) |
INDArray |
BaseNDArray.neq(INDArray other) |
INDArray |
INDArray.neq(Number other)
Not equal
|
INDArray |
BaseNDArray.neq(Number other) |
INDArray |
INDArray.neqi(INDArray other) |
INDArray |
BaseNDArray.neqi(INDArray other) |
INDArray |
INDArray.neqi(Number other)
In place not equal
|
INDArray |
BaseNDArray.neqi(Number other) |
protected INDArray |
BaseNDArray.newShape(int[] newShape,
char ordering) |
INDArray |
INDArray.norm1(int... dimension)
Returns the norm1 along the specified dimension
|
INDArray |
BaseNDArray.norm1(int... dimension)
Returns the norm1 along the specified dimension
|
INDArray |
INDArray.norm2(int... dimension)
Returns the norm2 along the specified dimension
|
INDArray |
BaseNDArray.norm2(int... dimension)
Returns the norm2 along the specified dimension
|
INDArray |
INDArray.normmax(int... dimension)
Returns the normmax along the specified dimension
|
INDArray |
BaseNDArray.normmax(int... dimension)
Returns the normmax along the specified dimension
|
INDArray |
INDArray.permute(int... rearrange)
See: http://www.mathworks.com/help/matlab/ref/permute.html
|
INDArray |
BaseNDArray.permute(int... rearrange)
See: http://www.mathworks.com/help/matlab/ref/permute.html
|
INDArray |
INDArray.permutei(int... rearrange)
An in-place version of permute.
|
INDArray |
BaseNDArray.permutei(int... rearrange)
An in-place version of permute.
|
INDArray |
INDArray.prod(int... dimension)
Returns the product along a given dimension
|
INDArray |
BaseNDArray.prod(int... dimension)
Returns the product along a given dimension
|
INDArray |
INDArray.put(INDArrayIndex[] indices,
INDArray element)
Put the elements of the ndarray
in to the specified indices
|
INDArray |
BaseNDArray.put(INDArrayIndex[] indices,
INDArray element) |
INDArray |
INDArray.put(INDArrayIndex[] indices,
Number element)
Put the elements of the ndarray
in to the specified indices
|
INDArray |
BaseNDArray.put(INDArrayIndex[] indices,
Number element) |
INDArray |
INDArray.put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseNDArray.put(int[] indices,
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,
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,
INDArray 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.put(int i,
int j,
Number element)
Inserts the element at the specified index
|
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.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.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.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.putScalar(int[] i,
double value)
Insert the item at the specified indices
|
INDArray |
BaseNDArray.putScalar(int[] indexes,
double value) |
INDArray |
INDArray.putScalar(int[] indexes,
float value) |
INDArray |
BaseNDArray.putScalar(int[] indexes,
float value) |
INDArray |
INDArray.putScalar(int[] indexes,
int value) |
INDArray |
BaseNDArray.putScalar(int[] indexes,
int value) |
INDArray |
INDArray.putScalar(int i,
double value)
Insert the number linearly in to the ndarray
|
INDArray |
BaseNDArray.putScalar(int i,
double value) |
INDArray |
INDArray.putScalar(int i,
float value)
Insert a scalar float at the specified index
|
INDArray |
BaseNDArray.putScalar(int i,
float value) |
INDArray |
INDArray.putScalar(int i,
int value)
Insert a scalar int at the specified index
|
INDArray |
BaseNDArray.putScalar(int i,
int 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 row,
int col,
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,
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.putScalar(int dim0,
int dim1,
int dim2,
int dim3,
double value) |
INDArray |
INDArray.putScalarUnsafe(int offset,
double value)
Insert a scalar
at the given linear offset
|
INDArray |
BaseNDArray.putScalarUnsafe(int offset,
double value) |
INDArray |
INDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
INDArray |
BaseNDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
INDArray |
INDArray.ravel()
Returns a flattened version (row vector) of this ndarray
|
INDArray |
BaseNDArray.ravel()
Flattens the array for linear indexing
|
INDArray |
INDArray.ravel(char order)
Returns a flattened version (row vector) of this ndarray
|
INDArray |
BaseNDArray.ravel(char ordering)
Flattens the array for linear indexing
|
INDArray |
INDArray.rdiv(INDArray other)
Reverse division
|
INDArray |
BaseNDArray.rdiv(INDArray other)
Reverse division
|
INDArray |
INDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
INDArray |
BaseNDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
INDArray |
INDArray.rdiv(Number n)
Reverse division
|
INDArray |
BaseNDArray.rdiv(Number n) |
INDArray |
INDArray.rdiv(Number n,
INDArray result)
Reverse division (number / ndarray)
|
INDArray |
BaseNDArray.rdiv(Number n,
INDArray result) |
INDArray |
INDArray.rdivColumnVector(INDArray columnVector)
Reverse division of a column vector (copy)
|
INDArray |
BaseNDArray.rdivColumnVector(INDArray columnVector) |
INDArray |
INDArray.rdivi(INDArray other)
Reverse divsion (in place)
|
INDArray |
BaseNDArray.rdivi(INDArray other)
Reverse divsion (in place)
|
INDArray |
INDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
INDArray |
BaseNDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
INDArray |
INDArray.rdivi(Number n)
In place reverse division
|
INDArray |
BaseNDArray.rdivi(Number n) |
INDArray |
INDArray.rdivi(Number n,
INDArray result)
Reverse in place division
|
INDArray |
BaseNDArray.rdivi(Number n,
INDArray result) |
INDArray |
INDArray.rdiviColumnVector(INDArray columnVector)
In place reverse divison of a column vector
|
INDArray |
BaseNDArray.rdiviColumnVector(INDArray columnVector) |
INDArray |
INDArray.rdiviRowVector(INDArray rowVector)
In place reverse division of a column vector
|
INDArray |
BaseNDArray.rdiviRowVector(INDArray rowVector) |
INDArray |
INDArray.rdivRowVector(INDArray rowVector)
Reverse division of a column vector (copy)
|
INDArray |
BaseNDArray.rdivRowVector(INDArray rowVector) |
INDArray |
INDArray.repeat(int... repeats)
Returns a flat array
with the elements repeated k times along each given dimension
|
INDArray |
BaseNDArray.repeat(int... repeats) |
INDArray |
INDArray.repeat(int dimension,
int... repeats)
Repeat elements along a specified dimension.
|
INDArray |
BaseNDArray.repeat(int dimension,
int... repeats) |
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 |
INDArray.reshape(char order,
int... newShape)
Reshapes the ndarray (can't change the length of the ndarray)
|
INDArray |
BaseNDArray.reshape(char order,
int... newShape) |
INDArray |
INDArray.reshape(char order,
int rows,
int columns)
Reshapes the ndarray (can't change the length of the ndarray)
|
INDArray |
BaseNDArray.reshape(char order,
int rows,
int columns) |
INDArray |
INDArray.reshape(int... newShape)
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 rows,
int columns)
Reshapes the ndarray (can't change the length of the ndarray)
|
INDArray |
BaseNDArray.reshape(int newRows,
int newColumns)
Reshape the matrix.
|
INDArray |
INDArray.rsub(INDArray other) |
INDArray |
BaseNDArray.rsub(INDArray other) |
INDArray |
INDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
INDArray |
BaseNDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
INDArray |
INDArray.rsub(Number n)
Reverse subtraction with duplicates
|
INDArray |
BaseNDArray.rsub(Number n) |
INDArray |
INDArray.rsub(Number n,
INDArray result)
Reverse subtraction
|
INDArray |
BaseNDArray.rsub(Number n,
INDArray result) |
INDArray |
INDArray.rsubColumnVector(INDArray columnVector)
Reverse subtraction of a column vector (copy)
|
INDArray |
BaseNDArray.rsubColumnVector(INDArray columnVector) |
INDArray |
INDArray.rsubi(INDArray other) |
INDArray |
BaseNDArray.rsubi(INDArray other) |
INDArray |
INDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
INDArray |
BaseNDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
INDArray |
INDArray.rsubi(Number n) |
INDArray |
BaseNDArray.rsubi(Number n) |
INDArray |
INDArray.rsubi(Number n,
INDArray result)
Reverse in place subtraction
|
INDArray |
BaseNDArray.rsubi(Number n,
INDArray result) |
INDArray |
INDArray.rsubiColumnVector(INDArray columnVector)
In place reverse subtraction of a column vector
|
INDArray |
BaseNDArray.rsubiColumnVector(INDArray columnVector) |
INDArray |
INDArray.rsubiRowVector(INDArray rowVector)
In place reverse subtraction of a row vector
|
INDArray |
BaseNDArray.rsubiRowVector(INDArray rowVector) |
INDArray |
INDArray.rsubRowVector(INDArray rowVector)
Reverse subtraction of a row vector (copy)
|
INDArray |
BaseNDArray.rsubRowVector(INDArray rowVector) |
INDArray |
INDArray.slice(int i)
Returns the specified slice of this ndarray
|
INDArray |
BaseNDArray.slice(int slice)
Returns the specified slice of this matrix.
|
INDArray |
INDArray.slice(int i,
int dimension)
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.std(boolean biasCorrected,
int... dimension)
Standard deviation of an ndarray along a dimension
|
INDArray |
BaseNDArray.std(boolean biasCorrected,
int... dimension) |
INDArray |
INDArray.std(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.sub(INDArray other)
copy subtraction of two NDArrays
|
INDArray |
BaseNDArray.sub(INDArray other)
copy subtraction of two matrices
|
INDArray |
INDArray.sub(INDArray other,
INDArray result)
copy subtraction of two NDArrays
|
INDArray |
BaseNDArray.sub(INDArray other,
INDArray result)
copy subtraction of two matrices
|
INDArray |
INDArray.sub(Number n)
Scalar subtraction (copied)
|
INDArray |
BaseNDArray.sub(Number n) |
INDArray |
INDArray.sub(Number n,
INDArray result) |
INDArray |
BaseNDArray.sub(Number n,
INDArray result) |
INDArray |
INDArray.subArray(int[] offsets,
int[] shape,
int[] stride) |
INDArray |
BaseNDArray.subArray(int[] offsets,
int[] shape,
int[] stride) |
INDArray |
INDArray.subArray(ShapeOffsetResolution resolution)
Sub array based on the
pre calculated shape,strides, offsets
|
INDArray |
BaseNDArray.subArray(ShapeOffsetResolution resolution) |
INDArray |
INDArray.subColumnVector(INDArray columnVector)
Subtraction of a column vector (copy)
|
INDArray |
BaseNDArray.subColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.subi(INDArray other)
in place subtraction of two NDArrays
|
INDArray |
BaseNDArray.subi(INDArray other)
in place subtraction of two matrices
|
INDArray |
INDArray.subi(INDArray other,
INDArray result)
in place subtraction of two NDArrays
|
INDArray |
BaseNDArray.subi(INDArray other,
INDArray result)
in place subtraction of two matrices
|
INDArray |
INDArray.subi(Number n)
In place scalar subtraction
|
INDArray |
BaseNDArray.subi(Number n) |
INDArray |
INDArray.subi(Number n,
INDArray result)
In place subtraction of this ndarray
|
INDArray |
BaseNDArray.subi(Number n,
INDArray result) |
INDArray |
INDArray.subiColumnVector(INDArray columnVector)
In place subtraction of a column vector
|
INDArray |
BaseNDArray.subiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.subiRowVector(INDArray rowVector)
In place subtraction of a row vector
|
INDArray |
BaseNDArray.subiRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.subRowVector(INDArray rowVector)
Subtraction of a row vector (copy)
|
INDArray |
BaseNDArray.subRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.sum(int... dimension)
Returns the sum along the last dimension of this ndarray
|
INDArray |
BaseNDArray.sum(int... dimension)
Returns the sum along the last dimension of this ndarray
|
INDArray |
INDArray.swapAxes(int dimension,
int with)
Mainly here for people coming from numpy.
|
INDArray |
BaseNDArray.swapAxes(int dimension,
int with)
Mainly here for people coming from numpy.
|
INDArray |
INDArray.tensorAlongDimension(int index,
int... dimension)
Get the vector along a particular dimension
|
INDArray |
BaseNDArray.tensorAlongDimension(int index,
int... dimension) |
INDArray |
INDArray.transpose()
Flip the rows and columns of a matrix
|
INDArray |
BaseNDArray.transpose()
Return transposed copy of this matrix.
|
INDArray |
INDArray.transposei()
Flip the rows and columns of a matrix
|
INDArray |
BaseNDArray.transposei()
Return transposed version of this matrix.
|
INDArray |
INDArray.var(boolean biasCorrected,
int... dimension)
Returns the overall variance of this ndarray
|
INDArray |
BaseNDArray.var(boolean biasCorrected,
int... dimension)
Returns the overall variance of this ndarray
|
INDArray |
INDArray.var(int... dimension)
Returns the overall variance of this ndarray
|
INDArray |
BaseNDArray.var(int... dimension)
Returns the overall variance of this ndarray
|
INDArray |
INDArray.vectorAlongDimension(int index,
int dimension)
Get the vector along a particular dimension
|
INDArray |
BaseNDArray.vectorAlongDimension(int index,
int dimension)
Get the vector along a particular dimension
|
| Modifier and Type | Method and Description |
|---|---|
INDArray |
INDArray.add(INDArray other)
copy addition of two NDArrays
|
INDArray |
BaseNDArray.add(INDArray other)
copy addition of two matrices
|
INDArray |
INDArray.add(INDArray other,
INDArray result)
copy addition of two NDArrays
|
INDArray |
BaseNDArray.add(INDArray other,
INDArray result)
copy addition of two matrices
|
INDArray |
INDArray.add(Number n,
INDArray result) |
INDArray |
BaseNDArray.add(Number n,
INDArray result) |
INDArray |
INDArray.addColumnVector(INDArray columnVector)
Addition of a column vector (copy)
|
INDArray |
BaseNDArray.addColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.addi(INDArray other)
in place addition of two NDArrays
|
INDArray |
BaseNDArray.addi(INDArray other)
in place addition of two matrices
|
INDArray |
INDArray.addi(INDArray other,
INDArray result)
in place addition of two NDArrays
|
INDArray |
BaseNDArray.addi(INDArray other,
INDArray result)
in place addition of two matrices
|
INDArray |
INDArray.addi(Number n,
INDArray result)
In place addition
|
INDArray |
BaseNDArray.addi(Number n,
INDArray result) |
INDArray |
INDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
BaseNDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.addiRowVector(INDArray rowVector)
In place addition of a row vector
|
INDArray |
BaseNDArray.addiRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.addRowVector(INDArray rowVector)
Addition of a row vector (copy)
|
INDArray |
BaseNDArray.addRowVector(INDArray rowVector)
In place addition of a column vector
|
protected void |
BaseNDArray.assertColumnVector(INDArray column) |
protected void |
BaseNDArray.assertRowVector(INDArray rowVector) |
protected void |
BaseNDArray.assertSlice(INDArray put,
int slice) |
INDArray |
INDArray.assign(INDArray arr)
Assign all of the elements in the given
ndarray to this ndarray
|
INDArray |
BaseNDArray.assign(INDArray arr)
Assign all of the elements in the given
ndarray to this ndarray
|
void |
INDArray.checkDimensions(INDArray other)
Validate dimensions are equal
|
void |
BaseNDArray.checkDimensions(INDArray other) |
protected void |
BaseNDArray.copyRealTo(INDArray arr) |
double |
INDArray.distance1(INDArray other)
Returns the (1-norm) distance.
|
double |
BaseNDArray.distance1(INDArray other)
Returns the (1-norm) distance.
|
double |
INDArray.distance2(INDArray other)
Returns the (euclidean) distance.
|
double |
BaseNDArray.distance2(INDArray other)
Returns the (euclidean) distance.
|
INDArray |
INDArray.div(INDArray other)
Copy (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.div(INDArray other)
in place (element wise) division of two matrices
|
INDArray |
INDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two matrices
|
INDArray |
INDArray.div(Number n,
INDArray result) |
INDArray |
BaseNDArray.div(Number n,
INDArray result) |
INDArray |
INDArray.divColumnVector(INDArray columnVector)
Division of a column vector (copy)
|
INDArray |
BaseNDArray.divColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.divi(INDArray other)
in place (element wise) division of two NDArrays
|
INDArray |
BaseNDArray.divi(INDArray other)
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(INDArray other,
INDArray result)
in place (element wise) division of two matrices
|
INDArray |
INDArray.divi(Number n,
INDArray result)
In place division of this ndarray
|
INDArray |
BaseNDArray.divi(Number n,
INDArray result) |
INDArray |
INDArray.diviColumnVector(INDArray columnVector)
In place division of a column vector
|
INDArray |
BaseNDArray.diviColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.diviRowVector(INDArray rowVector)
In place division of a row vector
|
INDArray |
BaseNDArray.diviRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.divRowVector(INDArray rowVector)
Division of a row vector (copy)
|
INDArray |
BaseNDArray.divRowVector(INDArray rowVector)
In place addition of a column vector
|
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 |
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(INDArray other)
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(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.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(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(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(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(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(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(INDArray other) |
INDArray |
INDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
INDArray |
BaseNDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
INDArray |
INDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
BaseNDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmuli(INDArray other)
Perform an inplace matrix multiplication
|
INDArray |
BaseNDArray.mmuli(INDArray other)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmuli(INDArray other,
INDArray result)
Perform an inplace matrix multiplication
|
INDArray |
BaseNDArray.mmuli(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mul(INDArray other)
copy (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.mul(INDArray other)
copy (element wise) multiplication of two matrices
|
INDArray |
INDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two matrices
|
INDArray |
INDArray.mul(Number n,
INDArray result) |
INDArray |
BaseNDArray.mul(Number n,
INDArray result) |
INDArray |
INDArray.mulColumnVector(INDArray columnVector)
Multiplication of a column vector (copy)
|
INDArray |
BaseNDArray.mulColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.muli(INDArray other)
in place (element wise) multiplication of two NDArrays
|
INDArray |
BaseNDArray.muli(INDArray other)
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(INDArray other,
INDArray result)
in place (element wise) multiplication of two matrices
|
INDArray |
INDArray.muli(Number n,
INDArray result)
In place multiplication of this ndarray
|
INDArray |
BaseNDArray.muli(Number n,
INDArray result) |
INDArray |
INDArray.muliColumnVector(INDArray columnVector)
In place multiplication of a column vector
|
INDArray |
BaseNDArray.muliColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.muliRowVector(INDArray rowVector)
In place multiplication of a row vector
|
INDArray |
BaseNDArray.muliRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.mulRowVector(INDArray rowVector)
Multiplication of a row vector (copy)
|
INDArray |
BaseNDArray.mulRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.neq(INDArray other) |
INDArray |
BaseNDArray.neq(INDArray other) |
INDArray |
INDArray.neqi(INDArray other) |
INDArray |
BaseNDArray.neqi(INDArray other) |
INDArray |
INDArray.put(INDArrayIndex[] indices,
INDArray element)
Put the elements of the ndarray
in to the specified indices
|
INDArray |
BaseNDArray.put(INDArrayIndex[] indices,
INDArray element) |
INDArray |
INDArray.put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseNDArray.put(int[] indices,
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,
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,
INDArray element)
Inserts the element at the specified index
|
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.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.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.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.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
INDArray |
BaseNDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
INDArray |
INDArray.rdiv(INDArray other)
Reverse division
|
INDArray |
BaseNDArray.rdiv(INDArray other)
Reverse division
|
INDArray |
INDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
INDArray |
BaseNDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
INDArray |
INDArray.rdiv(Number n,
INDArray result)
Reverse division (number / ndarray)
|
INDArray |
BaseNDArray.rdiv(Number n,
INDArray result) |
INDArray |
INDArray.rdivColumnVector(INDArray columnVector)
Reverse division of a column vector (copy)
|
INDArray |
BaseNDArray.rdivColumnVector(INDArray columnVector) |
INDArray |
INDArray.rdivi(INDArray other)
Reverse divsion (in place)
|
INDArray |
BaseNDArray.rdivi(INDArray other)
Reverse divsion (in place)
|
INDArray |
INDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
INDArray |
BaseNDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
INDArray |
INDArray.rdivi(Number n,
INDArray result)
Reverse in place division
|
INDArray |
BaseNDArray.rdivi(Number n,
INDArray result) |
INDArray |
INDArray.rdiviColumnVector(INDArray columnVector)
In place reverse divison of a column vector
|
INDArray |
BaseNDArray.rdiviColumnVector(INDArray columnVector) |
INDArray |
INDArray.rdiviRowVector(INDArray rowVector)
In place reverse division of a column vector
|
INDArray |
BaseNDArray.rdiviRowVector(INDArray rowVector) |
INDArray |
INDArray.rdivRowVector(INDArray rowVector)
Reverse division of a column vector (copy)
|
INDArray |
BaseNDArray.rdivRowVector(INDArray rowVector) |
INDArray |
INDArray.rsub(INDArray other) |
INDArray |
BaseNDArray.rsub(INDArray other) |
INDArray |
INDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
INDArray |
BaseNDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
INDArray |
INDArray.rsub(Number n,
INDArray result)
Reverse subtraction
|
INDArray |
BaseNDArray.rsub(Number n,
INDArray result) |
INDArray |
INDArray.rsubColumnVector(INDArray columnVector)
Reverse subtraction of a column vector (copy)
|
INDArray |
BaseNDArray.rsubColumnVector(INDArray columnVector) |
INDArray |
INDArray.rsubi(INDArray other) |
INDArray |
BaseNDArray.rsubi(INDArray other) |
INDArray |
INDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
INDArray |
BaseNDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
INDArray |
INDArray.rsubi(Number n,
INDArray result)
Reverse in place subtraction
|
INDArray |
BaseNDArray.rsubi(Number n,
INDArray result) |
INDArray |
INDArray.rsubiColumnVector(INDArray columnVector)
In place reverse subtraction of a column vector
|
INDArray |
BaseNDArray.rsubiColumnVector(INDArray columnVector) |
INDArray |
INDArray.rsubiRowVector(INDArray rowVector)
In place reverse subtraction of a row vector
|
INDArray |
BaseNDArray.rsubiRowVector(INDArray rowVector) |
INDArray |
INDArray.rsubRowVector(INDArray rowVector)
Reverse subtraction of a row vector (copy)
|
INDArray |
BaseNDArray.rsubRowVector(INDArray rowVector) |
double |
INDArray.squaredDistance(INDArray other)
Returns the squared (Euclidean) distance.
|
double |
BaseNDArray.squaredDistance(INDArray other)
Returns the squared (Euclidean) distance.
|
INDArray |
INDArray.sub(INDArray other)
copy subtraction of two NDArrays
|
INDArray |
BaseNDArray.sub(INDArray other)
copy subtraction of two matrices
|
INDArray |
INDArray.sub(INDArray other,
INDArray result)
copy subtraction of two NDArrays
|
INDArray |
BaseNDArray.sub(INDArray other,
INDArray result)
copy subtraction of two matrices
|
INDArray |
INDArray.sub(Number n,
INDArray result) |
INDArray |
BaseNDArray.sub(Number n,
INDArray result) |
INDArray |
INDArray.subColumnVector(INDArray columnVector)
Subtraction of a column vector (copy)
|
INDArray |
BaseNDArray.subColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.subi(INDArray other)
in place subtraction of two NDArrays
|
INDArray |
BaseNDArray.subi(INDArray other)
in place subtraction of two matrices
|
INDArray |
INDArray.subi(INDArray other,
INDArray result)
in place subtraction of two NDArrays
|
INDArray |
BaseNDArray.subi(INDArray other,
INDArray result)
in place subtraction of two matrices
|
INDArray |
INDArray.subi(Number n,
INDArray result)
In place subtraction of this ndarray
|
INDArray |
BaseNDArray.subi(Number n,
INDArray result) |
INDArray |
INDArray.subiColumnVector(INDArray columnVector)
In place subtraction of a column vector
|
INDArray |
BaseNDArray.subiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.subiRowVector(INDArray rowVector)
In place subtraction of a row vector
|
INDArray |
BaseNDArray.subiRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.subRowVector(INDArray rowVector)
Subtraction of a row vector (copy)
|
INDArray |
BaseNDArray.subRowVector(INDArray rowVector)
In place addition of a column vector
|
| Modifier and Type | Method and Description |
|---|---|
void |
INDArray.sliceVectors(List<INDArray> list) |
void |
BaseNDArray.sliceVectors(List<INDArray> list)
Flattens the array for linear indexing
|
| 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 |
LossFunction.input()
The true
|
INDArray |
BaseLossFunction.input() |
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 |
LossFunction.output()
The guess
|
INDArray |
BaseLossFunction.output() |
INDArray |
Op.x()
The origin ndarray
|
INDArray |
BaseOp.x() |
INDArray |
TadCollapseAccumulation.x() |
INDArray |
Op.y()
The pairwise op ndarray
|
INDArray |
BaseOp.y() |
INDArray |
TadCollapseAccumulation.y() |
INDArray |
Op.z()
The resulting ndarray
|
INDArray |
BaseOp.z() |
INDArray |
TadCollapseAccumulation.z() |
| Modifier and Type | Method and Description |
|---|---|
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 |
BaseAccumulation.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
BaseIndexAccumulation.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) |
void |
BaseAccumulation.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) |
void |
Bias.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 |
|---|
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) |
| Modifier and Type | Method and Description |
|---|---|
void |
ScalarMax.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
ScalarSet.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
ScalarMin.init(INDArray x,
INDArray y,
INDArray z,
long n) |
| Modifier and Type | Method and Description |
|---|---|
void |
LogSoftMax.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
SoftMax.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
SetRange.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
LeakyReLU.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
Pow.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
Stabilize.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
LeakyReLUDerivative.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
RectifedLinear.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
Step.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 |
CopyOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
AddOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
MulOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
RDivOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
RSubOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
SubOp.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 | Field and Description |
|---|---|
protected INDArray[] |
TaskCreator.ForkJoinArrayINDArrayTask.arr |
protected INDArray |
TaskCreator.ForkJoinINDArrayTask.arr |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
ParallelExecutioner.execBasedOnArraysAlongDimension(INDArray arr,
Accumulation task,
OpExecutioner executioner,
int... dimension) |
INDArray |
DefaultParallelExecutioner.execBasedOnArraysAlongDimension(INDArray arr,
Accumulation task,
OpExecutioner executioner,
int... dimension) |
INDArray[] |
TaskCreator.ForkJoinArrayINDArrayTask.getRawResult() |
INDArray |
TaskCreator.ForkJoinINDArrayTask.getRawResult() |
| Modifier and Type | Method and Description |
|---|---|
void |
ParallelExecutioner.execBasedOnArraysAlongDimension(INDArray[] arr,
TaskCreator.INDArrayTask task,
int... dimension) |
void |
DefaultParallelExecutioner.execBasedOnArraysAlongDimension(INDArray[] arr,
TaskCreator.INDArrayTask task,
int... dimension) |
INDArray |
ParallelExecutioner.execBasedOnArraysAlongDimension(INDArray arr,
Accumulation task,
OpExecutioner executioner,
int... dimension) |
INDArray |
DefaultParallelExecutioner.execBasedOnArraysAlongDimension(INDArray arr,
Accumulation task,
OpExecutioner executioner,
int... dimension) |
void |
ParallelExecutioner.execBasedOnArraysAlongDimension(INDArray arr,
Op task,
OpExecutioner executioner,
int... dimension) |
void |
DefaultParallelExecutioner.execBasedOnArraysAlongDimension(INDArray arr,
Op task,
OpExecutioner executioner,
int... dimension) |
void |
ParallelExecutioner.execBasedOnArraysAlongDimension(INDArray arr,
TaskCreator.INDArrayTask task,
int... dimension) |
void |
DefaultParallelExecutioner.execBasedOnArraysAlongDimension(INDArray arr,
TaskCreator.INDArrayTask task,
int... dimension) |
void |
ParallelExecutioner.execBasedOnSlices(INDArray arr,
Op task,
OpExecutioner executioner) |
void |
DefaultParallelExecutioner.execBasedOnSlices(INDArray arr,
Op task,
OpExecutioner executioner) |
void |
ParallelExecutioner.execBasedOnSlices(INDArray arr,
TaskCreator.INDArrayTask task) |
void |
DefaultParallelExecutioner.execBasedOnSlices(INDArray arr,
TaskCreator.INDArrayTask task) |
static org.apache.commons.math3.util.Pair<List<ForkJoinTask<INDArray[]>>,CountDownLatch> |
TaskCreator.parititonForkJoinBasedOnSlices(INDArray[] arr,
TaskCreator.INDArrayTask task) |
static org.apache.commons.math3.util.Pair<List<ForkJoinTask<INDArray>>,CountDownLatch> |
TaskCreator.parititonForkJoinBasedOnSlices(INDArray arr,
Op op,
OpExecutioner opExecutioner) |
static org.apache.commons.math3.util.Pair<List<ForkJoinTask<INDArray>>,CountDownLatch> |
TaskCreator.parititonForkJoinBasedOnSlices(INDArray arr,
TaskCreator.INDArrayTask task) |
static org.apache.commons.math3.util.Pair<List<ForkJoinTask<INDArray[]>>,CountDownLatch> |
TaskCreator.parititonForkJoinBasedOnTensorsAlongDimension(INDArray[] arr,
Op op,
OpExecutioner opExecutioner,
int... dimension) |
static org.apache.commons.math3.util.Pair<List<ForkJoinTask<INDArray[]>>,CountDownLatch> |
TaskCreator.parititonForkJoinBasedOnTensorsAlongDimension(INDArray[] arr,
TaskCreator.INDArrayTask task,
int... dimension) |
static List<ForkJoinTask<INDArray>> |
TaskCreator.parititonForkJoinBasedOnTensorsAlongDimension(INDArray arr,
Accumulation op,
OpExecutioner opExecutioner,
INDArray retArray,
int... dimension) |
static org.apache.commons.math3.util.Pair<CountDownLatch,List<ForkJoinTask<INDArray>>> |
TaskCreator.parititonForkJoinBasedOnTensorsAlongDimension(INDArray arr,
Op op,
OpExecutioner opExecutioner,
int... dimension) |
static org.apache.commons.math3.util.Pair<List<ForkJoinTask<INDArray>>,CountDownLatch> |
TaskCreator.parititonForkJoinBasedOnTensorsAlongDimension(INDArray arr,
TaskCreator.INDArrayTask task,
int... dimension) |
static org.apache.commons.math3.util.Pair<List<Runnable>,CountDownLatch> |
TaskCreator.parititonRunnablesBasedOnSlices(INDArray[] arr,
TaskCreator.INDArrayTask task) |
static org.apache.commons.math3.util.Pair<List<Runnable>,CountDownLatch> |
TaskCreator.parititonRunnablesBasedOnSlices(INDArray arr,
Op op,
OpExecutioner opExecutioner) |
static org.apache.commons.math3.util.Pair<List<Runnable>,CountDownLatch> |
TaskCreator.parititonRunnablesBasedOnSlices(INDArray arr,
TaskCreator.INDArrayTask task) |
static List<Runnable> |
TaskCreator.parititonRunnablesBasedOnTensorsAlongDimension(INDArray[] arr,
TaskCreator.INDArrayTask task,
int... dimension) |
static org.apache.commons.math3.util.Pair<List<Runnable>,CountDownLatch> |
TaskCreator.parititonRunnablesBasedOnTensorsAlongDimension(INDArray arr,
Op task,
OpExecutioner opExecutioner,
int... dimension) |
static List<Runnable> |
TaskCreator.parititonRunnablesBasedOnTensorsAlongDimension(INDArray arr,
TaskCreator.INDArrayTask task,
int... dimension) |
void |
TaskCreator.INDArrayTask.perform(INDArray... arr) |
void |
TaskCreator.AccumulationINDArrayTask.perform(INDArray... arr) |
void |
TaskCreator.OpINDArrayTask.perform(INDArray... arr) |
protected void |
TaskCreator.ForkJoinINDArrayTask.setRawResult(INDArray value) |
protected void |
TaskCreator.ForkJoinArrayINDArrayTask.setRawResult(INDArray[] value) |
| Constructor and Description |
|---|
AccumulationINDArrayTask(Accumulation op,
OpExecutioner opExecutioner,
INDArray retArray) |
AccumulationINDArrayTask(Accumulation op,
OpExecutioner opExecutioner,
INDArray retArray,
int slice) |
AccumulationINDArrayTask(Accumulation op,
OpExecutioner opExecutioner,
int slice,
INDArray retArray,
int[] dimension) |
ForkJoinArrayINDArrayTask(INDArray[] arr,
TaskCreator.INDArrayTask task,
CountDownLatch latch) |
ForkJoinINDArrayTask(INDArray arr,
TaskCreator.INDArrayTask task,
CountDownLatch latch) |
RunnableINDArrayTask(INDArray arr,
TaskCreator.INDArrayTask task) |
RunnableMultipleINDArrayTask(INDArray[] arr,
TaskCreator.INDArrayTask task,
CountDownLatch latch) |
| Modifier and Type | Method and Description |
|---|---|
Task<INDArray> |
TaskFactory.getAccumulationTask(Accumulation op,
int... dimension) |
Task<INDArray> |
TaskFactory.getCol2ImTask(INDArray col,
int strideY,
int strideX,
int padHeight,
int padWidth,
int imgHeight,
int imgWidth) |
Task<INDArray> |
TaskFactory.getIm2ColTask(INDArray img,
int kernelHeight,
int kernelWidth,
int strideY,
int strideX,
int padHeight,
int padWidth,
boolean coverAll) |
Task<INDArray> |
TaskFactory.getIndexAccumulationTask(IndexAccumulation op,
int... dimension) |
| Modifier and Type | Method and Description |
|---|---|
Task<INDArray> |
TaskFactory.getCol2ImTask(INDArray col,
int strideY,
int strideX,
int padHeight,
int padWidth,
int imgHeight,
int imgWidth) |
Task<INDArray> |
TaskFactory.getIm2ColTask(INDArray img,
int kernelHeight,
int kernelWidth,
int strideY,
int strideX,
int padHeight,
int padWidth,
boolean coverAll) |
| Modifier and Type | Method and Description |
|---|---|
Task<INDArray> |
CPUTaskFactory.getAccumulationTask(Accumulation op,
int... dimension) |
Task<INDArray> |
CPUTaskFactory.getCol2ImTask(INDArray col,
int strideY,
int strideX,
int padHeight,
int padWidth,
int imgHeight,
int imgWidth) |
Task<INDArray> |
CPUTaskFactory.getIm2ColTask(INDArray img,
int kernelHeight,
int kernelWidth,
int strideY,
int strideX,
int padHeight,
int padWidth,
boolean coverAll) |
Task<INDArray> |
CPUTaskFactory.getIndexAccumulationTask(IndexAccumulation op,
int... dimension) |
| Modifier and Type | Method and Description |
|---|---|
Task<INDArray> |
CPUTaskFactory.getCol2ImTask(INDArray col,
int strideY,
int strideX,
int padHeight,
int padWidth,
int imgHeight,
int imgWidth) |
Task<INDArray> |
CPUTaskFactory.getIm2ColTask(INDArray img,
int kernelHeight,
int kernelWidth,
int strideY,
int strideX,
int padHeight,
int padWidth,
boolean coverAll) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
CPUAccumulationAlongDimensionTask.blockUntilComplete() |
INDArray |
CPUAccumulationAlongDimensionTask.call() |
INDArray |
CPUAccumulationAlongDimensionTask.compute() |
| Constructor and Description |
|---|
CPUAccumulations1dAction(Accumulation op,
int threshold,
TensorCalculator tCalcx,
TensorCalculator tCalcy,
int firstTensor,
int lastTensor,
INDArray output) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
CPUIndexAccumulationAlongDimensionTask.blockUntilComplete() |
INDArray |
CPUIndexAccumulationAlongDimensionTask.call() |
protected INDArray |
CPUIndexAccumulationAlongDimensionTask.compute() |
| Constructor and Description |
|---|
CPUIndexAccumulations1dAction(IndexAccumulation op,
int threshold,
TensorCalculator tCalcx,
TensorCalculator tCalcy,
int firstTensor,
int lastTensor,
INDArray output) |
| Modifier and Type | Field and Description |
|---|---|
protected INDArray |
CPUCol2ImTask.col |
protected INDArray |
CPUIm2ColTask.img |
protected INDArray |
CPUCol2ImTask.imgOut |
protected INDArray |
CPUIm2ColTask.out |
| Modifier and Type | Field and Description |
|---|---|
protected Future<INDArray> |
CPUIm2ColTask.future |
protected Future<INDArray> |
CPUCol2ImTask.future |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
CPUIm2ColTask.blockUntilComplete() |
INDArray |
CPUCol2ImTask.blockUntilComplete() |
INDArray |
CPUIm2ColTask.call() |
INDArray |
CPUCol2ImTask.call() |
protected INDArray |
CPUIm2ColTask.compute() |
protected INDArray |
CPUCol2ImTask.compute() |
INDArray |
CPUIm2ColTask.invokeBlocking() |
INDArray |
CPUCol2ImTask.invokeBlocking() |
| Constructor and Description |
|---|
CPUCol2ImTask(INDArray col,
INDArray imgOut,
int strideY,
int strideX,
int padHeight,
int padWidth,
int imgHeight,
int imgWidth,
int exampleFrom,
int exampleTo,
int depthFrom,
int depthTo,
int parallelThreshold) |
CPUCol2ImTask(INDArray col,
int strideY,
int strideX,
int padHeight,
int padWidth,
int imgHeight,
int imgWidth,
int parallelThreshold) |
CPUIm2ColTask(INDArray img,
INDArray out,
int kernelHeight,
int kernelWidth,
int strideY,
int strideX,
int padHeight,
int padWidth,
int exampleFrom,
int exampleTo,
int depthFrom,
int depthTo,
int yOutFrom,
int yOutTo,
int xOutFrom,
int xOutTo,
boolean coverAll,
int parallelThreshold) |
CPUIm2ColTask(INDArray img,
int kernelHeight,
int kernelWidth,
int strideY,
int strideX,
int padHeight,
int padWidth,
boolean coverAll,
int parallelThreshold) |
| 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 |
Distribution.sample(int[] shape)
Sample the given shape
|
INDArray |
BaseDistribution.sample(int[] 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 |
NormalDistribution.sample(int[] shape) |
INDArray |
BinomialDistribution.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) |
| Modifier and Type | Method and Description |
|---|---|
static TensorCalculator |
TensorCalculatorFactory.getTensorCalculator(INDArray array,
int tensorDim)
Tensor calculator: 1d
|
| Constructor and Description |
|---|
TensorCalculator1d(INDArray arr,
int tensorDim) |
| Constructor and Description |
|---|
TimeOperations(INDArray n) |
TimeOperations(INDArray n,
int numTimesRun) |
| 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 |
|---|---|
static INDArray |
Convolution.col2im(INDArray col,
INDArray z,
int sy,
int sx,
int ph,
int pw,
int h,
int w) |
static INDArray |
Convolution.col2im(INDArray col,
int[] stride,
int[] padding,
int height,
int width) |
static INDArray |
OldConvolution.col2im(INDArray col,
int[] stride,
int[] padding,
int height,
int width) |
static INDArray |
Convolution.col2im(INDArray col,
int sy,
int sx,
int ph,
int pw,
int h,
int w)
Rearrange matrix
columns into blocks
|
static INDArray |
OldConvolution.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) |
static INDArray |
Convolution.conv2d(IComplexNDArray input,
IComplexNDArray kernel,
Convolution.Type type) |
INDArray |
BaseConvolution.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
|
static INDArray |
Convolution.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
|
INDArray |
ConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
static INDArray |
Convolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
INDArray |
BaseConvolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
INDArray |
ConvolutionInstance.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
|
INDArray |
DefaultConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
static INDArray |
Convolution.im2col(INDArray img,
int[] kernel,
int[] stride,
int[] padding) |
static INDArray |
OldConvolution.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 |
Convolution.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 |
OldConvolution.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 |
Convolution.col2im(INDArray col,
int[] stride,
int[] padding,
int height,
int width) |
static INDArray |
OldConvolution.col2im(INDArray col,
int[] stride,
int[] padding,
int height,
int width) |
static INDArray |
Convolution.col2im(INDArray col,
int sy,
int sx,
int ph,
int pw,
int h,
int w)
Rearrange matrix
columns into blocks
|
static INDArray |
OldConvolution.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
|
static INDArray |
Convolution.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
|
INDArray |
ConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
static INDArray |
Convolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
INDArray |
BaseConvolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
INDArray |
ConvolutionInstance.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
|
INDArray |
DefaultConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
static INDArray |
Convolution.im2col(INDArray img,
int[] kernel,
int[] stride,
int[] padding) |
static INDArray |
OldConvolution.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 |
Convolution.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 |
OldConvolution.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
|
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() |
INDArray |
DataSet.getFeatures() |
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) |
void |
DataSet.setFeatures(INDArray features) |
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) |
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) |
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() |
INDArray |
StandardScaler.getStd() |
| 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 |
|---|---|
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
|
static INDArray |
Nd4j.appendBias(INDArray... vectors) |
INDArray |
NDArrayFactory.appendBias(INDArray... vectors) |
INDArray |
BaseNDArrayFactory.appendBias(INDArray... vectors)
Merge the vectors and append a bias.
|
static INDArray |
Nd4j.arange(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.
|
INDArray |
BaseNDArrayFactory.arange(double begin,
double end)
Array of evenly spaced values.
|
static INDArray |
Nd4j.argMax(INDArray arr,
int... dimension) |
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) |
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.
|
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.complexZeros(int rows,
int columns)
Creates a matrix of zeros
|
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 |
BaseNDArrayFactory.concat(int dimension,
INDArray... toConcat)
concatenate ndarrays along a dimension
|
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 |
NDArrayFactory.create(DataBuffer buffer,
int[] shape,
int[] stride,
char order,
int offset) |
INDArray |
BaseNDArrayFactory.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
|
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
|
INDArray |
BaseNDArrayFactory.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) |
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,
char order) |
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
|
INDArray |
BaseNDArrayFactory.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 |
NDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
char order,
int offset) |
INDArray |
BaseNDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
char order,
int offset) |
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
|
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,
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
|
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
|
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,
char ordering)
Creates an ndarray with the specified shape
|
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
|
INDArray |
BaseNDArrayFactory.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) |
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,
char order) |
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)
Create an ndrray with the specified shape
|
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) |
INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape,
char ordering) |
static INDArray |
Nd4j.create(float[] data,
int[] shape,
char ordering,
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 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) |
INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
char order,
int offset) |
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
|
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,
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) |
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) |
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,
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
|
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 columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.create(int[] shape)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.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) |
static INDArray |
Nd4j.create(int[] shape,
DataBuffer.Type dataType) |
INDArray |
NDArrayFactory.create(int[] shape,
DataBuffer.Type dataType) |
INDArray |
BaseNDArrayFactory.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
|
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
|
INDArray |
BaseNDArrayFactory.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
|
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[] shape,
int[] stride,
int offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int[] shape,
int[] ints1,
int[] stride,
char order,
int offset) |
INDArray |
BaseNDArrayFactory.create(int[] data,
int[] shape,
int[] stride,
char order,
int offset) |
INDArray |
NDArrayFactory.create(int[] ints,
int[] ints1,
int[] stride,
int offset) |
INDArray |
BaseNDArrayFactory.create(int[] ints,
int[] ints1,
int[] stride,
int offset) |
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) |
INDArray |
BaseNDArrayFactory.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
|
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)
Creates an ndarray with the specified shape
|
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,
char ordering) |
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
|
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,
char ordering)
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
|
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,
char ordering)
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
|
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,
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.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
|
static INDArray |
Nd4j.eye(int n)
Create the identity ndarray
|
INDArray |
NDArrayFactory.eye(int n)
Create the identity ndarray
|
INDArray |
BaseNDArrayFactory.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(INDArray... arrs)
Concatenates two matrices horizontally.
|
INDArray |
NDArrayFactory.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
INDArray |
BaseNDArrayFactory.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
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
|
INDArray |
BaseNDArrayFactory.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
|
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 columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.ones(int[] shape)
Create an ndarray of ones
|
INDArray |
BaseNDArrayFactory.ones(int[] shape)
Create an ndarray of ones
|
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
|
INDArray |
BaseNDArrayFactory.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) |
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[] shape)
Create a random ndarray with the given 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(char order,
int rows,
int columns)
Create a random (uniform 0-1) NDArray with the specified shape and order
|
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)
Create a random ndarray with the given shape using
the current time as the seed
|
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,
Distribution r)
Create a random ndarray with the given shape using the given 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,
double min,
double max,
Random rng) |
INDArray |
NDArrayFactory.rand(int[] shape,
float min,
float max,
Random rng)
Generates a random matrix between min and max
|
INDArray |
BaseNDArrayFactory.rand(int[] shape,
float min,
float max,
Random rng)
Generates a random matrix between min and max
|
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,
long seed)
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[] shape,
Random r)
Create a random ndarray with the given shape using the given rng
|
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)
Create a random ndarray with the given shape using
the current time as the seed
|
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,
double min,
double max,
Random rng) |
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,
float min,
float max,
Random rng)
Generates a random matrix between min and max
|
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,
long seed)
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
|
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(long seed,
int... shape)
Create a random ndarray with the given shape using the given 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[] shape)
Random normal using the current time stamp
as the seed
|
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(char order,
int rows,
int columns)
Generate a random normal N(0,1) with the specified order and shape
|
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)
Random normal N(0,1) with the specified shape and
|
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,
long seed)
Random normal using the specified seed
|
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[] shape,
Random r)
Random normal using the given rng
|
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)
Random normal using the current time stamp
as the 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,
long seed)
Random normal using the specified seed
|
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
|
INDArray |
BaseNDArrayFactory.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 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
|
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
|
INDArray |
BaseNDArrayFactory.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.
|
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 |
BaseNDArrayFactory.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) |
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)
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(double value,
int offset)
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)
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(float value,
int offset)
Create a scalar nd array with the specified value and offset
|
INDArray |
NDArrayFactory.scalar(int value,
int offset) |
INDArray |
BaseNDArrayFactory.scalar(int value,
int offset)
Create a scalar nd array with the specified value and 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)
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
|
INDArray |
BaseNDArrayFactory.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.
|
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(char order,
INDArray... matrices) |
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(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(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(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
|
INDArray |
BaseNDArrayFactory.toFlattened(int length,
Iterator<? extends INDArray>... matrices) |
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
|
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 num,
double value)
Creates an ndarray with the specified value
as the only value in the ndarray
|
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
|
INDArray |
BaseNDArrayFactory.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(INDArray... arrs)
Concatenates two matrices vertically.
|
INDArray |
NDArrayFactory.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
INDArray |
BaseNDArrayFactory.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
static INDArray |
Nd4j.zeros(int... shape)
Create an ndarray of zeros
|
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 columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.zeros(int[] shape)
Create an ndarray of zeros
|
INDArray |
BaseNDArrayFactory.zeros(int[] shape)
Create an ndarray of zeros
|
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
|
INDArray |
BaseNDArrayFactory.zeros(int rows,
int columns)
Creates a row vector with the specified number of columns
|
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
|
static INDArray |
Nd4j.appendBias(INDArray... vectors) |
INDArray |
NDArrayFactory.appendBias(INDArray... vectors) |
INDArray |
BaseNDArrayFactory.appendBias(INDArray... vectors)
Merge the vectors and append a bias.
|
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 |
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) |
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.
|
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 void |
Nd4j.clearNans(INDArray arr)
Clear nans from an ndarray
|
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 |
BaseNDArrayFactory.concat(int dimension,
INDArray... toConcat)
concatenate ndarrays along a dimension
|
static void |
Nd4j.copy(INDArray a,
INDArray b)
Copy a to b
|
INDArray |
BlasWrapper.copy(INDArray x,
INDArray y)
Compute y <- x (copy a matrix)
|
void |
NDArrayFactory.copy(INDArray a,
INDArray b)
Copy a to b
|
void |
BaseNDArrayFactory.copy(INDArray a,
INDArray b)
Copy a to b
|
INDArray |
BaseBlasWrapper.copy(INDArray x,
INDArray y) |
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
|
abstract IComplexNDArray |
BaseNDArrayFactory.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) |
static INDArray |
Nd4j.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
INDArray |
NDArrayFactory.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
INDArray |
BaseNDArrayFactory.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) |
static INDArray |
Nd4j.repeat(INDArray n,
int num)
Create an n x (shape)
ndarray where the ndarray is repeated num times
|
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
|
INDArray |
BaseNDArrayFactory.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.
|
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 |
BaseNDArrayFactory.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
static void |
Nd4j.rot90(INDArray toRotate)
Rotate a matrix 90 degrees
|
void |
NDArrayFactory.rot90(INDArray toRotate)
Rotate a matrix 90 degrees
|
void |
BaseNDArrayFactory.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
|
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
|
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(char order,
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(INDArray... matrices) |
protected static void |
BaseNDArrayFactory.validateConcat(int dimension,
INDArray... arrs) |
static INDArray |
Nd4j.var(INDArray compute) |
static INDArray |
Nd4j.var(INDArray compute,
int dimension) |
static INDArray |
Nd4j.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
INDArray |
NDArrayFactory.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
INDArray |
BaseNDArrayFactory.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,
String split)
Read line via input streams
|
static INDArray |
Nd4j.zerosLike(INDArray arr)
Empty like
|
| Modifier and Type | Method and Description |
|---|---|
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
|
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,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(List<INDArray> list,
int[] shape,
char ordering) |
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.
|
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(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
|
| Modifier and Type | Method and Description |
|---|---|
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.
|
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.
|
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 |
FFTInstance.fft(INDArray transform,
int numElements)
FFT along a particular dimension
|
IComplexNDArray |
BaseFFTInstance.fft(INDArray transform,
int numElements)
FFT along a particular dimension
|
static IComplexNDArray |
FFT.fft(INDArray transform,
int numElements)
FFT along a particular dimension
|
IComplexNDArray |
FFTInstance.fft(INDArray transform,
int numElements,
int dimension)
FFT along a particular dimension
|
IComplexNDArray |
DefaultFFTInstance.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 |
FFTInstance.fftn(INDArray transform)
FFT on the whole array (n is equal the first dimension shape)
|
IComplexNDArray |
BaseFFTInstance.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 |
FFTInstance.fftn(INDArray transform,
int dimension,
int numElements)
Computes the fft along the first non singleton dimension of op
when it is a matrix
|
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
|
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 |
FFTInstance.ifft(INDArray transform,
int numElements)
FFT along a particular dimension
|
IComplexNDArray |
DefaultFFTInstance.ifft(INDArray transform,
int numElements)
FFT along a particular dimension
|
static IComplexNDArray |
FFT.ifft(INDArray transform,
int numElements)
FFT along a particular dimension
|
IComplexNDArray |
FFTInstance.ifft(INDArray transform,
int numElements,
int dimension)
IFFT along a particular dimension
|
IComplexNDArray |
DefaultFFTInstance.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 |
FFTInstance.ifftn(INDArray transform) |
IComplexNDArray |
BaseFFTInstance.ifftn(INDArray transform) |
IComplexNDArray |
FFTInstance.ifftn(INDArray transform,
int dimension,
int numElements)
ND IFFT, computes along the first on singleton dimension of
op
|
IComplexNDArray |
BaseFFTInstance.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 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 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 |
INDArrayIndex.init(INDArray arr,
int dimension)
Init the index wrt
the dimension and the given nd array
|
void |
NDArrayIndex.init(INDArray arr,
int dimension) |
void |
NDArrayIndexEmpty.init(INDArray arr,
int dimension) |
void |
NewAxis.init(INDArray arr,
int dimension) |
void |
IntervalIndex.init(INDArray arr,
int dimension) |
void |
SpecifiedIndex.init(INDArray arr,
int dimension) |
void |
PointIndex.init(INDArray arr,
int dimension) |
void |
INDArrayIndex.init(INDArray arr,
int begin,
int dimension)
Init the index wrt
the dimension and the given nd array
|
void |
NDArrayIndex.init(INDArray arr,
int begin,
int dimension) |
void |
NDArrayIndexEmpty.init(INDArray arr,
int begin,
int dimension) |
void |
NewAxis.init(INDArray arr,
int begin,
int dimension) |
void |
IntervalIndex.init(INDArray arr,
int begin,
int dimension) |
void |
SpecifiedIndex.init(INDArray arr,
int begin,
int dimension) |
void |
NDArrayIndexAll.init(INDArray arr,
int begin,
int dimension) |
void |
PointIndex.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 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 |
Nesterovs.getGradient(INDArray gradient,
int iteration)
Get the nesterov update
|
INDArray |
GradientUpdater.getGradient(INDArray gradient,
int iteration)
Modify the gradient
to be an update
|
INDArray |
RmsProp.getGradient(INDArray gradient,
int iteration) |
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 iteration)
Gets feature specific learning rates
Adagrad keeps a history of gradients being passed in.
|
INDArray |
Sgd.getGradient(INDArray gradient,
int iteration) |
INDArray |
Adam.getGradient(INDArray gradient,
int iteration)
Calculate the update based on the given gradient
|
INDArray |
AdaGrad.getGradient(INDArray gradient,
int slice,
int[] shape) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
Nesterovs.getGradient(INDArray gradient,
int iteration)
Get the nesterov update
|
INDArray |
GradientUpdater.getGradient(INDArray gradient,
int iteration)
Modify the gradient
to be an update
|
INDArray |
RmsProp.getGradient(INDArray gradient,
int iteration) |
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 iteration)
Gets feature specific learning rates
Adagrad keeps a history of gradients being passed in.
|
INDArray |
Sgd.getGradient(INDArray gradient,
int iteration) |
INDArray |
Adam.getGradient(INDArray gradient,
int iteration)
Calculate the update based on the given gradient
|
INDArray |
AdaGrad.getGradient(INDArray gradient,
int slice,
int[] shape) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
LossCalculation.scoreExamples()
Calculate the score for each example individually.
|
| Modifier and Type | Method and Description |
|---|---|
static double |
LossFunctions.score(INDArray labels,
LossFunctions.LossFunction lossFunction,
INDArray z,
double l2,
boolean useRegularization)
Generic scoring function.
|
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 |
|---|---|
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.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.