/** * Creates one by one a new {@link FloatPointer} for each {@code float[]}, * and writes them into the native {@code void*} array. * * @param array the array of {@code float[]} to read from * @return this */ public PointerPointer<P> put(float[] ... array) { pointerArray = (P[])new FloatPointer[array.length]; for (int i = 0; i < array.length; i++) { pointerArray[i] = array[i] != null ? (P)new FloatPointer(array[i]) : null; } return put(pointerArray); } /**
/** * * @param data * @param copy */ public BaseDataBuffer(float[] data, boolean copy) { allocationMode = AllocUtil.getAllocationModeFromContext(); initTypeAndSize(); pointer = new FloatPointer(data); setIndexer(FloatIndexer.create((FloatPointer) pointer)); //wrappedBuffer = pointer.asByteBuffer(); length = data.length; underlyingLength = data.length; }
/** * This method creates compressed INDArray from Java float array, skipping usual INDArray instantiation routines * * @param data * @param shape * @param order * @return */ @Override public INDArray compress(float[] data, int[] shape, char order) { FloatPointer pointer = new FloatPointer(data); DataBuffer shapeInfo = Nd4j.getShapeInfoProvider().createShapeInformation(shape, order).getFirst(); DataBuffer buffer = compressPointer(DataBuffer.TypeEx.FLOAT, pointer, data.length, 4); return Nd4j.createArrayFromShapeBuffer(buffer, shapeInfo); }
/** * Create a data buffer from * the given length * * @param buffer * @param length */ public BaseDataBuffer(ByteBuffer buffer, long length) { if (length < 1) throw new IllegalArgumentException("Length must be >= 1"); initTypeAndSize(); this.length = length; allocationMode = AllocUtil.getAllocationModeFromContext(); if (dataType() == Type.DOUBLE) { pointer = new DoublePointer(buffer.asDoubleBuffer()); setIndexer(DoubleIndexer.create((DoublePointer) pointer)); } else if (dataType() == Type.FLOAT) { pointer = new FloatPointer(buffer.asFloatBuffer()); setIndexer(FloatIndexer.create((FloatPointer) pointer)); } else if (dataType() == Type.INT) { pointer = new IntPointer(buffer.asIntBuffer()); setIndexer(IntIndexer.create((IntPointer) pointer)); } else if (dataType() == Type.LONG) { pointer = new LongPointer(buffer.asLongBuffer()); setIndexer(LongIndexer.create((LongPointer) pointer)); } // log.info("Creating new buffer of size: {}; dtype: {}; D", length, dataType()); }
/** * * @param length * @param elementSize */ public BaseDataBuffer(long length, int elementSize) { if (length < 1) throw new IllegalArgumentException("Length must be >= 1"); initTypeAndSize(); allocationMode = AllocUtil.getAllocationModeFromContext(); this.length = length; this.underlyingLength = length; this.elementSize = (byte) elementSize; if (dataType() == Type.DOUBLE) { pointer = new DoublePointer(length); indexer = DoubleIndexer.create((DoublePointer) pointer); } else if (dataType() == Type.FLOAT) { pointer = new FloatPointer(length); setIndexer(FloatIndexer.create((FloatPointer) pointer)); } else if (dataType() == Type.INT) { pointer = new IntPointer(length); setIndexer(IntIndexer.create((IntPointer) pointer)); } else if (dataType() == Type.LONG) { pointer = new LongPointer(length); setIndexer(LongIndexer.create((LongPointer) pointer)); } // log.info("Creating new buffer of size: {}; dtype: {}; C", length, dataType()); }
fillPointerWithZero(); } else if (dataType() == Type.FLOAT) { pointer = new FloatPointer(length()); setIndexer(FloatIndexer.create((FloatPointer) pointer));
public void pointerIndexerByGlobalType(Type currentType) { if (currentType == Type.LONG) { pointer = new LongPointer(length()); setIndexer(LongRawIndexer.create((LongPointer) pointer)); type = Type.LONG; } else if (currentType == Type.INT) { pointer = new IntPointer(length()); setIndexer(IntIndexer.create((IntPointer) pointer)); type = Type.INT; } else { if (DataTypeUtil.getDtypeFromContext() == Type.DOUBLE) { pointer = new DoublePointer(length()); indexer = DoubleIndexer.create((DoublePointer) pointer); } else if (DataTypeUtil.getDtypeFromContext() == Type.FLOAT) { pointer = new FloatPointer(length()); setIndexer(FloatIndexer.create((FloatPointer) pointer)); } else if (DataTypeUtil.getDtypeFromContext() == Type.LONG) { pointer = new LongPointer(length()); setIndexer(LongIndexer.create((LongPointer) pointer)); } } }
break; case FLOAT: pointer = new FloatPointer(length); indexer = FloatIndexer.create((FloatPointer) pointer); break;
public FloatPointer asFloatPointer() { return new FloatPointer(this); }
public FloatPointer asFloatPointer() { return new FloatPointer(this); }
//6 2D-points stored in a 1-dimensional float array float points[] = { 1.0f, 1.1f, 1.0f, 3.0f, 3.0f, 7.0f, 7.0f, 3.0f, 3.0f, 0.0f, 2.0f, 1.0f,1.0f, 0.0f}; //1 row matrix with 6 2-D points of type CV_32FC2 and a FloatPointer to the points array. CvMat mat = cvMat(1, 6, CV_32FC2, new FloatPointer(points)); CvBox2D result = cvFitEllipse2(mat); System.out.println(result);
private DataBuffer readFromDataSet(hdf5.DataSet dataSet, int total) { float[] dataBuffer = new float[total]; FloatPointer fp = new FloatPointer(dataBuffer); dataSet.read(fp, dataType); fp.get(dataBuffer); return Nd4j.createBuffer(dataBuffer); }
/** * Creates a new NativeFloatArray of specified length. * Throws an {@link IllegalArgumentException} when length is not * positive (length zero is not allowed as well). * @param length number of elements in array * @throws IllegalArgumentException when length is not positive */ @FloatPrecisionVersion public NativeRealArray(long length) { FFTW_Initializer.initFFTW(); GeneralUtils.requirePositive(length, ()->"Provided length is not positive"); this.pointer = new FloatPointer(length); this.length = length; }
@Override public FloatIndexer createIndexer(boolean direct) { int[] w = {0}, h = {0}; fpixGetDimensions((FPIX)this, w, h); int wpl = fpixGetWpl((FPIX)this); long[] sizes = {h[0], w[0], wpl / w[0]}; long[] strides = {wpl, wpl / w[0], 1}; FloatPointer data = new FloatPointer(fpixGetData((FPIX)this)).capacity(h[0] * wpl); return FloatIndexer.create(data, sizes, strides, direct); }
private Indexer indexerForType(DataBuffer.Type type,Pointer pointer) { switch(type) { case DOUBLE: return DoubleIndexer.create(new DoublePointer(pointer)); case FLOAT: return FloatIndexer.create(new FloatPointer(pointer)); case INT: return IntIndexer.create(new IntPointer(pointer)); case LONG: return LongIndexer.create(new LongPointer(pointer)); default: throw new IllegalArgumentException("Illegal type " + type); } }
/** * This method creates compressed INDArray from Java float array, skipping usual INDArray instantiation routines * * @param data * @param shape * @param order * @return */ @Override public INDArray compress(float[] data, int[] shape, char order) { FloatPointer pointer = new FloatPointer(data); DataBuffer shapeInfo = Nd4j.getShapeInfoProvider().createShapeInformation(shape, order).getFirst(); DataBuffer buffer = compressPointer(DataBuffer.TypeEx.FLOAT, pointer, data.length, 4); return Nd4j.createArrayFromShapeBuffer(buffer, shapeInfo); }
/** @return {@link FPIX#data()} wrapped in a {@link FloatBuffer} starting at given byte index. */ public FloatBuffer createBuffer(int index) { int[] w = {0}, h = {0}; fpixGetDimensions((FPIX)this, w, h); int wpl = fpixGetWpl((FPIX)this); FloatPointer data = new FloatPointer(fpixGetData((FPIX)this)).position(index).capacity(h[0] * wpl); return data.asBuffer(); }
@Override protected void sscal(long N, float alpha, INDArray X, int incX) { if (Nd4j.dataType() != DataBuffer.Type.FLOAT) logger.warn("FLOAT scal called"); Nd4j.getExecutioner().push(); CudaContext ctx = allocator.getFlowController().prepareAction(X); CublasPointer xCPointer = new CublasPointer(X, ctx); cublasHandle_t handle = ctx.getHandle(); synchronized (handle) { cublasSetStream_v2(new cublasContext(handle), new CUstream_st(ctx.getOldStream())); cublasSscal_v2(new cublasContext(handle),(int) N, new FloatPointer(alpha), (FloatPointer) xCPointer.getDevicePointer(), incX); } allocator.registerAction(ctx, X); OpExecutionerUtil.checkForAny(X); }
@Override protected void sscal(int N, float alpha, INDArray X, int incX) { if (Nd4j.dataType() != DataBuffer.Type.FLOAT) logger.warn("FLOAT scal called"); Nd4j.getExecutioner().push(); CudaContext ctx = allocator.getFlowController().prepareAction(X); CublasPointer xCPointer = new CublasPointer(X, ctx); cublasHandle_t handle = ctx.getHandle(); synchronized (handle) { cublasSetStream_v2(new cublasContext(handle), new CUstream_st(ctx.getOldStream())); cublasSscal_v2(new cublasContext(handle), N, new FloatPointer(alpha), (FloatPointer) xCPointer.getDevicePointer(), incX); } allocator.registerAction(ctx, X); OpExecutionerUtil.checkForAny(X); }
@Override protected float snrm2(long N, INDArray X, int incX) { if (Nd4j.dataType() != DataBuffer.Type.FLOAT) logger.warn("FLOAT nrm2 called"); Nd4j.getExecutioner().push(); CudaContext ctx = allocator.getFlowController().prepareAction(null, X); float ret; CublasPointer cAPointer = new CublasPointer(X, ctx); cublasHandle_t handle = ctx.getHandle(); synchronized (handle) { cublasSetStream_v2(new cublasContext(handle), new CUstream_st(ctx.getOldStream())); FloatPointer resultPointer = new FloatPointer(0.0f); cublasSnrm2_v2(new cublasContext(handle), (int) N, (FloatPointer) cAPointer.getDevicePointer(), incX, resultPointer); ret = resultPointer.get(); } allocator.registerAction(ctx, null, X); return ret; }