package com.carrotsearch.hppc;
import java.util.*;
import com.carrotsearch.hppc.cursors.*;
import com.carrotsearch.hppc.predicates.DoublePredicate;
import com.carrotsearch.hppc.procedures.*;
import static com.carrotsearch.hppc.Containers.*;
@com.carrotsearch.hppc.Generated(
date = "2018-05-21T12:24:05+0200",
value = "KTypeArrayList.java")
public class DoubleArrayList
extends AbstractDoubleCollection
implements DoubleIndexedContainer,
Preallocable,
Cloneable
{
public final static
double []
EMPTY_ARRAY =
new double [0];
;
public
double []
buffer = EMPTY_ARRAY;
public int elementsCount;
protected final ArraySizingStrategy resizer;
public DoubleArrayList() {
this(DEFAULT_EXPECTED_ELEMENTS);
}
public DoubleArrayList(int expectedElements) {
this(expectedElements, new BoundedProportionalArraySizingStrategy());
}
public DoubleArrayList(int expectedElements, ArraySizingStrategy resizer) {
assert resizer != null;
this.resizer = resizer;
ensureCapacity(expectedElements);
}
public DoubleArrayList(DoubleContainer container) {
this(container.size());
addAll(container);
}
@Override
public void add(double e1) {
ensureBufferSpace(1);
buffer[elementsCount++] = e1;
}
public void add(double e1, double e2) {
ensureBufferSpace(2);
buffer[elementsCount++] = e1;
buffer[elementsCount++] = e2;
}
public void add(double[] elements, int start, int length) {
assert length >= 0 : "Length must be >= 0";
ensureBufferSpace(length);
System.arraycopy(elements, start, buffer, elementsCount, length);
elementsCount += length;
}
public final void add(double... elements) {
add(elements, 0, elements.length);
}
public int addAll(DoubleContainer container) {
final int size = container.size();
ensureBufferSpace(size);
for (DoubleCursor cursor : container) {
add(cursor.value);
}
return size;
}
public int addAll(Iterable<? extends DoubleCursor> iterable) {
int size = 0;
for (DoubleCursor cursor : iterable) {
add(cursor.value);
size++;
}
return size;
}
@Override
public void insert(int index, double e1) {
assert (index >= 0 && index <= size()) : "Index " + index + " out of bounds [" + 0 + ", " + size() + "].";
ensureBufferSpace(1);
System.arraycopy(buffer, index, buffer, index + 1, elementsCount - index);
buffer[index] = e1;
elementsCount++;
}
@Override
public double get(int index) {
assert (index >= 0 && index < size()) : "Index " + index + " out of bounds [" + 0 + ", " + size() + ").";
return buffer[index];
}
@Override
public double set(int index, double e1) {
assert (index >= 0 && index < size()) : "Index " + index + " out of bounds [" + 0 + ", " + size() + ").";
final double v = buffer[index];
buffer[index] = e1;
return v;
}
@Override
public double remove(int index) {
assert (index >= 0 && index < size()) : "Index " + index + " out of bounds [" + 0 + ", " + size() + ").";
final double v = buffer[index];
if (index + 1 < elementsCount) {
System.arraycopy(buffer, index + 1, buffer, index, elementsCount - index - 1);
}
elementsCount--;
buffer[elementsCount] = 0d;
return v;
}
@Override
public void removeRange(int fromIndex, int toIndex) {
assert (fromIndex >= 0 && fromIndex <= size())
: "Index " + fromIndex + " out of bounds [" + 0 + ", " + size() + ").";
assert (toIndex >= 0 && toIndex <= size())
: "Index " + toIndex + " out of bounds [" + 0 + ", " + size() + "].";
assert fromIndex <= toIndex
: "fromIndex must be <= toIndex: " + fromIndex + ", " + toIndex;
System.arraycopy(buffer, toIndex, buffer, fromIndex, elementsCount - toIndex);
final int count = toIndex - fromIndex;
elementsCount -= count;
Arrays.fill(buffer, elementsCount, elementsCount + count, 0d);
}
@Override
public int removeFirst(double e1) {
final int index = indexOf(e1);
if (index >= 0)
remove(index);
return index;
}
@Override
public int removeLast(double e1) {
final int index = lastIndexOf(e1);
if (index >= 0)
remove(index);
return index;
}
@Override
public int removeAll(double e1) {
int to = 0;
for (int from = 0; from < elementsCount; from++) {
if ((Double.doubleToLongBits(buffer[from]) == Double.doubleToLongBits( e1))) {
buffer[from] = 0d;
continue;
}
if (to != from) {
buffer[to] = buffer[from];
buffer[from] = 0d;
}
to++;
}
final int deleted = elementsCount - to;
this.elementsCount = to;
return deleted;
}
@Override
public boolean contains(double e1) {
return indexOf(e1) >= 0;
}
@Override
public int indexOf(double e1) {
for (int i = 0; i < elementsCount; i++) {
if ((Double.doubleToLongBits(buffer[i]) == Double.doubleToLongBits( e1))) {
return i;
}
}
return -1;
}
@Override
public int lastIndexOf(double e1) {
for (int i = elementsCount - 1; i >= 0; i--) {
if ((Double.doubleToLongBits(buffer[i]) == Double.doubleToLongBits( e1))) {
return i;
}
}
return -1;
}
@Override
public boolean isEmpty() {
return elementsCount == 0;
}
@Override
public void ensureCapacity(int expectedElements) {
final int bufferLen = (buffer == null ? 0 : buffer.length);
if (expectedElements > bufferLen) {
ensureBufferSpace(expectedElements - size());
}
}
protected void ensureBufferSpace(int expectedAdditions) {
final int bufferLen = (buffer == null ? 0 : buffer.length);
if (elementsCount + expectedAdditions > bufferLen) {
final int newSize = resizer.grow(bufferLen, elementsCount, expectedAdditions);
assert newSize >= elementsCount + expectedAdditions : "Resizer failed to" + " return sensible new size: "
+ newSize + " <= " + (elementsCount + expectedAdditions);
this.buffer = Arrays.copyOf(buffer, newSize);
}
}
public void resize(int newSize) {
if (newSize <= buffer.length) {
if (newSize < elementsCount) {
Arrays.fill(buffer, newSize, elementsCount, 0d);
} else {
Arrays.fill(buffer, elementsCount, newSize, 0d);
}
} else {
ensureCapacity(newSize);
}
this.elementsCount = newSize;
}
@Override
public int size() {
return elementsCount;
}
public void trimToSize() {
if (size() != this.buffer.length) {
this.buffer = toArray();
}
}
@Override
public void clear() {
Arrays.fill(buffer, 0, elementsCount, 0d);
this.elementsCount = 0;
}
@Override
public void release() {
this.buffer = EMPTY_ARRAY;
this.elementsCount = 0;
}
@Override
public double [] toArray()
{
return Arrays.copyOf(buffer, elementsCount);
}
@Override
public DoubleArrayList clone() {
try {
final DoubleArrayList cloned = (DoubleArrayList) super.clone();
cloned.buffer = buffer.clone();
return cloned;
} catch (CloneNotSupportedException e) {
throw new RuntimeException(e);
}
}
@Override
public int hashCode() {
int h = 1, max = elementsCount;
for (int i = 0; i < max; i++) {
h = 31 * h + BitMixer.mix(this.buffer[i]);
}
return h;
}
@Override
public boolean equals(Object obj) {
return obj != null &&
getClass() == obj.getClass() &&
equalElements(getClass().cast(obj));
}
protected boolean equalElements(DoubleArrayList other) {
int max = size();
if (other.size() != max) {
return false;
}
for (int i = 0; i < max; i++) {
if (!(Double.doubleToLongBits(other.get(i)) == Double.doubleToLongBits( get(i)))) {
return false;
}
}
return true;
}
final static class ValueIterator extends AbstractIterator<DoubleCursor> {
private final DoubleCursor cursor;
private final double[] buffer;
private final int size;
public ValueIterator(double[] buffer, int size) {
this.cursor = new DoubleCursor();
this.cursor.index = -1;
this.size = size;
this.buffer = buffer;
}
@Override
protected DoubleCursor fetch() {
if (cursor.index + 1 == size)
return done();
cursor.value = buffer[++cursor.index];
return cursor;
}
}
@Override
public Iterator<DoubleCursor> iterator() {
return new ValueIterator( buffer, size());
}
@Override
public <T extends DoubleProcedure> T forEach(T procedure) {
return forEach(procedure, 0, size());
}
public <T extends DoubleProcedure> T forEach(T procedure, int fromIndex, final int toIndex) {
assert (fromIndex >= 0 && fromIndex <= size()) :
"Index " + fromIndex + " out of bounds [" + 0 + ", " + size() + ").";
assert (toIndex >= 0 && toIndex <= size()) :
"Index " + toIndex + " out of bounds [" + 0 + ", " + size() + "].";
assert fromIndex <= toIndex : "fromIndex must be <= toIndex: "
+ fromIndex + ", " + toIndex;
final double [] buffer = this.buffer;
for (int i = fromIndex; i < toIndex; i++) {
procedure.apply(buffer[i]);
}
return procedure;
}
@Override
public int removeAll(DoublePredicate predicate) {
final double[] buffer = this.buffer;
final int elementsCount = this.elementsCount;
int to = 0;
int from = 0;
try {
for (; from < elementsCount; from++) {
if (predicate.apply(buffer[from])) {
buffer[from] = 0d;
continue;
}
if (to != from) {
buffer[to] = buffer[from];
buffer[from] = 0d;
}
to++;
}
} finally {
for (; from < elementsCount; from++) {
if (to != from) {
buffer[to] = buffer[from];
buffer[from] = 0d;
}
to++;
}
this.elementsCount = to;
}
return elementsCount - to;
}
@Override
public <T extends DoublePredicate> T forEach(T predicate) {
return forEach(predicate, 0, size());
}
public <T extends DoublePredicate> T forEach(T predicate, int fromIndex, final int toIndex) {
assert (fromIndex >= 0 && fromIndex <= size())
: "Index " + fromIndex + " out of bounds [" + 0 + ", " + size() + ").";
assert (toIndex >= 0 && toIndex <= size())
: "Index " + toIndex + " out of bounds [" + 0 + ", " + size() + "].";
assert fromIndex <= toIndex
: "fromIndex must be <= toIndex: " + fromIndex + ", " + toIndex;
final double[] buffer = this.buffer;
for (int i = fromIndex; i < toIndex; i++) {
if (!predicate.apply(buffer[i]))
break;
}
return predicate;
}
public static DoubleArrayList from(double... elements) {
final DoubleArrayList list = new DoubleArrayList(elements.length);
list.add(elements);
return list;
}
}