public static DoubleBuffer newDoubleBuffer (int numDoubles) { ByteBuffer buffer = ByteBuffer.allocateDirect(numDoubles * 8); buffer.order(ByteOrder.nativeOrder()); return buffer.asDoubleBuffer(); }
public static DoubleBuffer newDoubleBuffer (int numDoubles) { ByteBuffer buffer = ByteBuffer.allocateDirect(numDoubles * 8); buffer.order(ByteOrder.nativeOrder()); return buffer.asDoubleBuffer(); }
public EntireLayoutColumnarDoublesSupplier(int totalSize, ByteBuffer fromBuffer, ByteOrder byteOrder) { this.totalSize = totalSize; this.buffer = fromBuffer.asReadOnlyBuffer().order(byteOrder).asDoubleBuffer(); }
/** @return {@code asByteBuffer().asDoubleBuffer()} */ @Override public final DoubleBuffer asBuffer() { return asByteBuffer().asDoubleBuffer(); } }
public TempBuffer() { b16 = BufferUtils.createByteBuffer(16); b16s = b16.asShortBuffer(); b16i = b16.asIntBuffer(); b16l = b16.asLongBuffer(); b16f = b16.asFloatBuffer(); b16d = b16.asDoubleBuffer(); } }
public TempBuffer() { b16 = BufferUtils.createByteBuffer(16); b16s = b16.asShortBuffer(); b16i = b16.asIntBuffer(); b16l = b16.asLongBuffer(); b16f = b16.asFloatBuffer(); b16d = b16.asDoubleBuffer(); } }
public TempBuffer() { b16 = BufferUtils.createByteBuffer(16); b16s = b16.asShortBuffer(); b16i = b16.asIntBuffer(); b16l = b16.asLongBuffer(); b16f = b16.asFloatBuffer(); b16d = b16.asDoubleBuffer(); } }
@MarshalsArray public static DoubleBuffer toDoubleBuffer(Class<?> cls, long handle, long flags, int d1) { return VM.newDirectByteBuffer(handle, d1 << 3).order(ByteOrder.nativeOrder()).asDoubleBuffer(); } @MarshalsArray
/** * Returns a {@link DoubleBuffer} which reads and writes to the same memory * location pointed to by this {@link DoublePtr}. * * @param n the maximum number of doubles the {@link DoubleBuffer} can * read/write. This will be the {@link DoubleBuffer}'s * <code>capacity</code>. * @return the {@link DoubleBuffer}. */ public DoubleBuffer asDoubleBuffer(int n) { return as(BytePtr.class).asByteBuffer(n << 3).order(ByteOrder.nativeOrder()).asDoubleBuffer(); }
protected void loadBuffer(int bufferNum) { CloseQuietly.close(holder); holder = singleThreadedDoubleBuffers.get(bufferNum); // asDoubleBuffer() makes the doubleBuffer's position = 0 doubleBuffer = holder.get().asDoubleBuffer(); currBufferNum = bufferNum; }
/** * Create a new DoubleBuffer of the specified size. * * @param size * required number of double to store. * @return the new DoubleBuffer */ public static DoubleBuffer createDoubleBuffer(int size) { DoubleBuffer buf = allocator.allocate(8 * size).order(ByteOrder.nativeOrder()).asDoubleBuffer(); buf.clear(); onBufferAllocated(buf); return buf; }
DoubleBuffer fromDouble = fromView.asDoubleBuffer(); DoubleBuffer toDouble = toView.asDoubleBuffer(); for (int i = 0; i < n; i++) { toDouble.put(toOffset + i * toStride, fromDouble.get(fromOffset + i * fromStride));
public double[] getA8d( ) { _arys++; int len = getInt(); if( len == -1 ) return null; double[] buf = MemoryManager.malloc8d(len); int sofar = 0; while( sofar < len ) { DoubleBuffer as = _bb.asDoubleBuffer(); int more = Math.min(as.remaining(), len - sofar); as.get(buf, sofar, more); sofar += more; _bb.position(_bb.position() + as.position()*8); if( sofar < len ) getSp(Math.min(_bb.capacity()-7, (len-sofar)*8)); } return buf; } public byte[][] getAA1( ) {
/** * Returns a {@link DoubleBuffer} which reads and writes to the same memory * location pointed to by this {@link MachineSizedFloatPtr}. Must only be * called on 64-bit platforms. * * @param n the maximum number of doubles the {@link DoubleBuffer} can * read/write. This will be the {@link DoubleBuffer}'s * <code>capacity</code>. * @return the {@link DoubleBuffer}. * @throws IllegalStateException if this isn't a 64-bit platform. */ public DoubleBuffer asDoubleBuffer(int n) { if (_sizeOf() != 8) { throw new IllegalStateException("Not a 64-bit platform"); } return VM.newDirectByteBuffer(getHandle(), n << 3) .order(ByteOrder.nativeOrder()).asDoubleBuffer(); }
public void setJoints(SkeletonJoint[] joints) { if(joints == null) return; mJoints = joints; if (mBoneMatrices == null) { mBoneMatrices = ByteBuffer .allocateDirect(joints.length * DOUBLE_SIZE_BYTES * 16) .order(ByteOrder.nativeOrder()).asDoubleBuffer(); } else mBoneMatrices.clear(); mBoneMatrices.put(uBoneMatrix); mBoneMatrices.position(0); mBoneMatricesBufferInfo.buffer = mBoneMatrices; mGeometry.addBuffer(mBoneMatricesBufferInfo, BufferType.FLOAT_BUFFER, GLES20.GL_ARRAY_BUFFER); }
@Override public DoubleBuffer asNioDouble() { if (offset() >= Integer.MAX_VALUE) throw new IllegalStateException("Index out of bounds " + offset()); if (offset() == 0) { return wrappedBuffer().asDoubleBuffer(); } else { return (DoubleBuffer) wrappedBuffer().asDoubleBuffer().position((int) (offset())); } }
public int doubleLimit() { v8.checkThread(); checkReleased(); return byteBuffer.asDoubleBuffer().limit(); }
public AutoBuffer putA8d( double[] ary ) { _arys++; if( ary == null ) return putInt(-1); putInt(ary.length); int sofar = 0; while( sofar < ary.length ) { DoubleBuffer sb = _bb.asDoubleBuffer(); int len = Math.min(ary.length - sofar, sb.remaining()); sb.put(ary, sofar, len); sofar += len; _bb.position(_bb.position() + sb.position()*8); if( sofar < ary.length ) sendPartial(); } return this; }
switch (_dtype) { case DOUBLE: { val db = bb.order(_order).asDoubleBuffer(); for (int e = 0; e < prod; e++) doubles[e] = db.get(e);
/** * 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()); }