/** * Find the index of the element with maximum absolute value * * @param arr a vector * @return the index of the element with minimum absolute value * */ @Override public int iamin(INDArray arr) { switch (arr.data().dataType()) { case DOUBLE: DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, arr); return idamin(arr.length(), arr, 1); case FLOAT: DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, arr); return isamin(arr.length(), arr, 1); case HALF: DefaultOpExecutioner.validateDataType(DataBuffer.Type.HALF, arr); return ihamin(arr.length(), arr, 1); default: } throw new UnsupportedOperationException(); }
/** * Compute the sum of magnitude of the vector elements * * @param arr a vector * @return the sum of magnitude of the vector elements * */ @Override public double asum(INDArray arr) { switch (arr.data().dataType()) { case DOUBLE: DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, arr); return dasum(arr.length(), arr, 1); case FLOAT: DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, arr); return sasum(arr.length(), arr, 1); case HALF: DefaultOpExecutioner.validateDataType(DataBuffer.Type.HALF, arr); return hasum(arr.length(), arr, 1); default: } throw new UnsupportedOperationException(); }
/** * Find the index of the element with maximum absolute value * * @param arr a vector * @return the index of the element with maximum absolute value * */ @Override public int iamax(INDArray arr) { switch (arr.data().dataType()) { case DOUBLE: DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, arr); return idamax(arr.length(), arr, 1); case FLOAT: DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, arr); return isamax(arr.length(), arr, 1); case HALF: DefaultOpExecutioner.validateDataType(DataBuffer.Type.HALF, arr); return ihamax(arr.length(), arr, 1); default: } throw new UnsupportedOperationException(); }
@Override public int iamax(long n, INDArray arr, int stride) { if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, arr); if (arr.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, arr); return idamax(n, arr, stride); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, arr); return isamax(n, arr, stride); } }
/** * Computes the Euclidean norm of a vector. * * @param arr a vector * @return the Euclidean norm of the vector */ @Override public double nrm2(INDArray arr) { switch (arr.data().dataType()) { case DOUBLE: DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, arr); return dnrm2(arr.length(), arr, 1); case FLOAT: DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, arr); return snrm2(arr.length(), arr, 1); case HALF: return hnrm2(arr.length(), arr, 1); default: } throw new UnsupportedOperationException(); }
/** * tpsv solves a system of linear equations whose coefficients are in a triangular packed matrix. * * @param order * @param Uplo * @param TransA * @param Diag * @param Ap * @param X */ @Override public void tpsv(char order, char Uplo, char TransA, char Diag, INDArray Ap, INDArray X) { if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, Ap, X); // FIXME: int cast if (X.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, X, Ap); dtpsv(order, Uplo, TransA, Diag, (int) X.length(), Ap, X, X.majorStride()); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, Ap, X); stpsv(order, Uplo, TransA, Diag, (int) X.length(), Ap, X, X.majorStride()); } OpExecutionerUtil.checkForAny(X); }
/** * spr performs a rank-1 update of an n-by-n packed symmetric matrix a: * a := alpha*x*x' + a. * * @param order * @param Uplo * @param alpha * @param X * @param Ap */ @Override public void spr(char order, char Uplo, double alpha, INDArray X, INDArray Ap) { if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, Ap, X); // FIXME: int cast if (X.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, X); dspr(order, Uplo, (int) X.length(), alpha, X, X.majorStride(), Ap); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, X); sspr(order, Uplo, (int) X.length(), (float) alpha, X, X.majorStride(), Ap); } OpExecutionerUtil.checkForAny(Ap); }
/** * tpmv computes a matrix-vector product using a triangular packed matrix. * * @param order * @param Uplo * @param TransA * @param Diag * @param Ap * @param X */ @Override public void tpmv(char order, char Uplo, char TransA, char Diag, INDArray Ap, INDArray X) { if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, Ap, X); // FIXME: int cast if (X.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, X); dtpmv(order, Uplo, TransA, Diag, (int) Ap.length(), Ap, X, X.majorStride()); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, X); stpmv(order, Uplo, TransA, Diag, (int) Ap.length(), Ap, X, X.majorStride()); } OpExecutionerUtil.checkForAny(X); }
/** * computes the sum of magnitudes of all vector elements or, for a complex vector x, the sum * * @param arr * @return */ @Override public double asum(INDArray arr) { if (arr.isSparse()) { return Nd4j.getSparseBlasWrapper().level1().asum(arr); } if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, arr); if (arr.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, arr); return dasum(arr.length(), arr, BlasBufferUtil.getBlasStride(arr)); } else if (arr.data().dataType() == DataBuffer.Type.FLOAT) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, arr); return sasum(arr.length(), arr, BlasBufferUtil.getBlasStride(arr)); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.HALF, arr); return hasum(arr.length(), arr, BlasBufferUtil.getBlasStride(arr)); } }
/** * @param order * @param Uplo * @param alpha * @param Ap * @param X * @param beta * @param Y */ @Override public void spmv(char order, char Uplo, double alpha, INDArray Ap, INDArray X, double beta, INDArray Y) { if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, Ap, X, Y); // FIXME: int cast if (Ap.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, X, Y); dspmv(order, Uplo, (int) X.length(), alpha, Ap, X, Ap.majorStride(), beta, Y, Y.majorStride()); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, X, Y); sspmv(order, Uplo, (int) X.length(), (float) alpha, Ap, X, Ap.majorStride(), (float) beta, Y, Y.majorStride()); } OpExecutionerUtil.checkForAny(Y); }
/** * ?tbsv solves a system of linear equations whose coefficients are in a triangular band matrix. * * @param order * @param Uplo * @param TransA * @param Diag * @param A * @param X */ @Override public void tbsv(char order, char Uplo, char TransA, char Diag, INDArray A, INDArray X) { if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, A, X); // FIXME: int cast if (X.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, A, X); dtbsv(order, Uplo, TransA, Diag, (int) X.length(), (int) A.columns(), A, (int) A.size(0), X, X.majorStride()); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, A, X); stbsv(order, Uplo, TransA, Diag, (int) X.length(), (int) A.columns(), A, (int) A.size(0), X, X.majorStride()); } }
/** * trmv computes a matrix-vector product using a triangular matrix. * * @param order * @param Uplo * @param TransA * @param Diag * @param A * @param X */ @Override public void trmv(char order, char Uplo, char TransA, char Diag, INDArray A, INDArray X) { if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, A, X); // FIXME: int cast if (A.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, A, X); dtrmv(order, Uplo, TransA, Diag, (int) X.length(), A, (int) A.size(0), X, X.majorStride()); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, A, X); strmv(order, Uplo, TransA, Diag, (int) X.length(), A, (int) A.size(0), X, X.majorStride()); } OpExecutionerUtil.checkForAny(X); }
/** * trsv solves a system of linear equations whose coefficients are in a triangular matrix. * * @param order * @param Uplo * @param TransA * @param Diag * @param A * @param X */ @Override public void trsv(char order, char Uplo, char TransA, char Diag, INDArray A, INDArray X) { if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, A, X); // FIXME: int cast if (X.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, A, X); dtrsv(order, Uplo, TransA, Diag, (int) A.length(), A, (int) A.size(0), X, X.majorStride()); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, A, X); strsv(order, Uplo, TransA, Diag, (int) A.length(), A, (int) A.size(0), X, X.majorStride()); } OpExecutionerUtil.checkForAny(X); }
/** * syr performs a rank-1 update of an n-by-n symmetric matrix a: * a := alpha*x*x' + a. * * @param order * @param Uplo * @param N * @param alpha * @param X * @param A */ @Override public void syr(char order, char Uplo, int N, double alpha, INDArray X, INDArray A) { if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, A, X); // FIXME: int cast if (X.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, A, X); dsyr(order, Uplo, (int) X.length(), alpha, X, X.majorStride(), A, (int) A.size(0)); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, A, X); ssyr(order, Uplo, (int) X.length(), (float) alpha, X, X.majorStride(), A, (int) A.size(0)); } OpExecutionerUtil.checkForAny(A); }
/** * finds the element of a * vector that has the largest absolute value. * * @param arr * @return */ @Override public int iamax(INDArray arr) { if (arr.isSparse()) { return Nd4j.getSparseBlasWrapper().level1().iamax(arr); } if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, arr); if (arr.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, arr); return idamax(arr.length(), arr, BlasBufferUtil.getBlasStride(arr)); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, arr); return isamax(arr.length(), arr, BlasBufferUtil.getBlasStride(arr)); } }
/** * performs rotation of points in the plane. * * @param N * @param X * @param Y * @param c * @param s */ @Override public void rot(long N, INDArray X, INDArray Y, double c, double s) { if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, X, Y); if (X.isSparse() && !Y.isSparse()) { Nd4j.getSparseBlasWrapper().level1().rot(N, X, Y, c, s); } else if (X.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, X, Y); drot(N, X, BlasBufferUtil.getBlasStride(X), Y, BlasBufferUtil.getBlasStride(X), c, s); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, X, Y); srot(N, X, BlasBufferUtil.getBlasStride(X), Y, BlasBufferUtil.getBlasStride(X), (float) c, (float) s); } }
/** * @param order * @param Uplo * @param alpha * @param X * @param Y * @param A */ @Override public void syr2(char order, char Uplo, double alpha, INDArray X, INDArray Y, INDArray A) { if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, A, X, Y); // FIXME: int cast if (X.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, A, X, Y); dsyr2(order, Uplo, (int) X.length(), alpha, X, X.majorStride(), Y, Y.majorStride(), A, (int) A.size(0)); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, A, X, Y); ssyr2(order, Uplo, (int) X.length(), (float) alpha, X, X.majorStride(), Y, Y.majorStride(), A, (int) A.size(0)); } OpExecutionerUtil.checkForAny(A); }
/** * swaps a vector with another vector. * * @param x * @param y */ @Override public void copy(INDArray x, INDArray y) { if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, x, y); if (x.isSparse() || y.isSparse()) { Nd4j.getSparseBlasWrapper().level1().copy(x, y); return; } if (x.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, x, y); dcopy(x.length(), x, BlasBufferUtil.getBlasStride(x), y, BlasBufferUtil.getBlasStride(y)); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, x, y); scopy(x.length(), x, BlasBufferUtil.getBlasStride(x), y, BlasBufferUtil.getBlasStride(y)); } }
/** * swaps a vector with another vector. * * @param x * @param y */ @Override public void swap(INDArray x, INDArray y) { if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, x, y); if (x.isSparse() || y.isSparse()) { Nd4j.getSparseBlasWrapper().level1().swap(x, y); return; } if (x.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, x, y); dswap(x.length(), x, BlasBufferUtil.getBlasStride(x), y, BlasBufferUtil.getBlasStride(y)); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, x, y); sswap(x.length(), x, BlasBufferUtil.getBlasStride(x), y, BlasBufferUtil.getBlasStride(y)); } }
@Override public void gemv(char order, char transA, double alpha, INDArray A, INDArray X, double beta, INDArray Y) { checkArgument(A.isMatrix(), "A must be a matrix"); checkArgument(X.isVector(), "X must be a vector"); checkArgument(Y.isVector(), "Y must be a vector"); SparseCOOGemvParameters parameters = new SparseCOOGemvParameters(A, X, Y); switch (A.data().dataType()) { case DOUBLE: DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, parameters.getA(), parameters.getX(), parameters.getY()); dcoomv(parameters.getAOrdering(), parameters.getM(), parameters.getVal(), parameters.getRowInd(), parameters.getColInd(), parameters.getNnz(), parameters.getX(), parameters.getY()); break; case FLOAT: DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, parameters.getA(), parameters.getX(), parameters.getY()); scoomv(parameters.getAOrdering(), parameters.getM(), parameters.getVal(), parameters.getRowInd(), parameters.getColInd(), parameters.getNnz(), parameters.getX(), parameters.getY()); break; default: throw new UnsupportedOperationException(); } }