@Override public LongIndexer get(long i, long[] l, int offset, int length) { for (int n = 0; n < length; n++) { l[offset + n] = get(i * strides[0] + n); } return this; } @Override public long get(long i, long j) {
@Override public LongIndexer put(long i, long j, long k, long l) { put(i * strides[0] + j * strides[1] + k, l); return this; } @Override public LongIndexer put(long[] indices, long l) {
@Override public LongIndexer put(long i, long l) { RAW.putLong(base + checkIndex(i, size) * VALUE_BYTES, l); return this; } @Override public LongIndexer put(long i, long[] l, int offset, int length) {
/** * Creates a long indexer to access efficiently the data of a pointer. * * @param pointer data to access via a buffer or to copy to an array * @param direct {@code true} to use a direct buffer, see {@link Indexer} for details * @return the new long indexer backed by the raw memory interface, a buffer, or an array */ public static LongIndexer create(final LongPointer pointer, long[] sizes, long[] strides, boolean direct) { if (direct) { return Raw.getInstance() != null ? new LongRawIndexer(pointer, sizes, strides) : new LongBufferIndexer(pointer.asBuffer(), sizes, strides); } else { final long position = pointer.position(); long[] array = new long[(int)Math.min(pointer.limit() - position, Integer.MAX_VALUE)]; pointer.get(array); return new LongArrayIndexer(array, sizes, strides) { @Override public void release() { pointer.position(position).put(array); super.release(); } }; } }
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)); } } }
@Override public long get(long i) { return RAW.getLong(base + checkIndex(i, size) * VALUE_BYTES); } @Override public LongIndexer get(long i, long[] l, int offset, int length) {
@Override public LongIndexer put(long i, long j, long[] l, int offset, int length) { for (int n = 0; n < length; n++) { put(i * strides[0] + j * strides[1] + n, l[offset + n]); } return this; } @Override public LongIndexer put(long i, long j, long k, long l) {
@Override public LongIndexer get(long i, long j, long[] l, int offset, int length) { for (int n = 0; n < length; n++) { l[offset + n] = get(i * strides[0] + j * strides[1] + n); } return this; } @Override public long get(long i, long j, long k) {
@Override public LongIndexer put(long i, long j, long l) { put(i * strides[0] + j, l); return this; } @Override public LongIndexer put(long i, long j, long[] l, int offset, int length) {
@Override public long get(long i, long j) { return get(i * strides[0] + j); } @Override public LongIndexer get(long i, long j, long[] l, int offset, int length) {
@Override public LongIndexer put(long i, long[] l, int offset, int length) { for (int n = 0; n < length; n++) { put(i * strides[0] + n, l[offset + n]); } return this; } @Override public LongIndexer put(long i, long j, long l) {
@Override public long get(long i, long j, long k) { return get(i * strides[0] + j * strides[1] + k); } @Override public long get(long... indices) {
@Override public void put(long i, long element) { if (dataType() == Type.DOUBLE) { ((DoubleIndexer) indexer).put(offset() + i, (double) element); } else if (dataType() == Type.INT) { ((IntIndexer) indexer).put(offset() + i, (int) element); } else if (dataType() == Type.LONG) { ((LongRawIndexer) indexer).put(offset() + i, element); } else { ((FloatIndexer) indexer).put(offset() + i, (float) element); } if (i == length) { length++; } }
@Override public double getDouble(long i) { if (indexer == null) { throw new IllegalStateException("Indexer must never be null"); } if (dataType() == Type.FLOAT) { return ((FloatIndexer) indexer).get(offset() + i); } else if (dataType() == Type.INT) { return ((IntIndexer) indexer).get(offset() + i); } else if (dataType() == Type.LONG) { return ((LongRawIndexer) indexer).get(offset() + i); } else { return ((DoubleIndexer) indexer).get(offset() + i); } }
@Override public void put(long i, int element) { if (dataType() == Type.DOUBLE) { ((DoubleIndexer) indexer).put(offset() + i, element); } else if (dataType() == Type.INT) { ((IntIndexer) indexer).put(offset() + i, element); } else if (dataType() == Type.LONG) { ((LongRawIndexer) indexer).put(offset() + i, element); } else { ((FloatIndexer) indexer).put(offset() + i, element); } if (i == length) { length++; } }
@Override public float getFloat(long i) { if (dataType() == Type.DOUBLE) { return (float) ((DoubleIndexer) indexer).get(offset() + i); } else if (dataType() == Type.INT) { return ((IntIndexer) indexer).get(offset() + i); } else if (dataType() == Type.LONG) { return ((LongRawIndexer) indexer).get(offset() + i); } else if (dataType() == Type.HALF) { return ((HalfIndexer) indexer).get(offset() + i); } else { return ((FloatIndexer) indexer).get(offset() + i); } }