@Override public double asum(INDArray x) { LinAlgExceptions.assertVector(x); return level1().asum(x); }
@Override public INDArray axpy(Number da, INDArray dx, INDArray dy) { // if(!dx.isVector()) // throw new IllegalArgumentException("Unable to use axpy on a non vector"); LinAlgExceptions.assertSameLength(dx, dy); level1().axpy(dx.length(), da.doubleValue(), dx, dy); return dy; }
@Override public int iamax(INDArray x) { return level1().iamax(x); }
double sum = l1Blas.nrm2(searchDirection); double slope = -1f * Nd4j.getBlasWrapper().dot(searchDirection, gradients); double norm1 = l1Blas.asum(searchDirection); int infNormIdx = l1Blas.iamax(searchDirection); double infNorm = FastMath.max(Float.NEGATIVE_INFINITY, searchDirection.getDouble(infNormIdx)); log.trace("ENTERING BACKTRACK\n"); double norm1 = l1Blas.asum(candidateParameters); log.trace("after step, x.1norm: " + norm1);
@Override public double nrm2(INDArray x) { LinAlgExceptions.assertVector(x); return level1().nrm2(x); }
@Override public IComplexNDArray scal(IComplexNumber alpha, IComplexNDArray x) { LinAlgExceptions.assertVector(x); level1().scal(x.length(), alpha, x); return x; }
@Override public double dot(INDArray x, INDArray y) { return level1().dot(x.length(), 1, x, y); }
@Override public INDArray copy(INDArray x, INDArray y) { LinAlgExceptions.assertVector(x, y); level1().copy(x, y); return y; }
@Override public INDArray swap(INDArray x, INDArray y) { level1().swap(x, y); return y; }
/** * finds the element of a vector that has the minimum absolute value. * * @param arr * @return */ @Override public int iamin(INDArray arr) { if (arr.isSparse()) { return Nd4j.getSparseBlasWrapper().level1().iamin(arr); } else { throw new UnsupportedOperationException(); } }
/** * 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); } }
@Override public IComplexNumber nrm2(IComplexNDArray x) { LinAlgExceptions.assertVector(x); return level1().nrm2(x); }
@Override public INDArray scal(double alpha, INDArray x) { LinAlgExceptions.assertVector(x); if (x.data().dataType() == DataBuffer.Type.FLOAT) return scal((float) alpha, x); level1().scal(x.length(), alpha, x); return x; }
@Override public IComplexNumber dotu(IComplexNDArray x, IComplexNDArray y) { LinAlgExceptions.assertVector(x, y); return level1().dot(x.length(), Nd4j.UNIT, x, y); }
@Override public IComplexNDArray copy(IComplexNDArray x, IComplexNDArray y) { LinAlgExceptions.assertVector(x, y); level1().copy(x, y); return 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 INDArray axpy(double da, INDArray dx, INDArray dy) { LinAlgExceptions.assertVector(dx, dy); if (dx.data().dataType() == DataBuffer.Type.FLOAT) return axpy((float) da, dx, dy); level1().axpy(dx.length(), da, dx, dy); return dy; }
/** * computes the Euclidean norm of a vector. * * @param arr * @return */ @Override public double nrm2(INDArray arr) { if (arr.isSparse()) { return Nd4j.getSparseBlasWrapper().level1().nrm2(arr); } if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL) OpProfiler.getInstance().processBlasCall(false, arr); if (arr.isSparse()) { return Nd4j.getSparseBlasWrapper().level1().nrm2(arr); } if (arr.data().dataType() == DataBuffer.Type.DOUBLE) { DefaultOpExecutioner.validateDataType(DataBuffer.Type.DOUBLE, arr); return dnrm2(arr.length(), arr, BlasBufferUtil.getBlasStride(arr)); } else { DefaultOpExecutioner.validateDataType(DataBuffer.Type.FLOAT, arr); return snrm2(arr.length(), arr, BlasBufferUtil.getBlasStride(arr)); } // TODO: add nrm2 for half, as call to appropriate NativeOp<HALF> }
@Override public IComplexNumber asum(IComplexNDArray x) { LinAlgExceptions.assertVector(x); return level1().asum(x); }
@Override public int iamax(IComplexNDArray x) { LinAlgExceptions.assertVector(x); return level1().iamax(x); }