/**
* Relative bulk <i>put</i> method <i>(optional operation)</i>.
*
* <p>This method transfers the doubles remaining in the given source buffer into this buffer. If
* there are more doubles remaining in the source buffer than in this buffer, that is, if
* <tt>src.remaining()</tt> <tt>></tt> <tt>remaining()</tt>, then no doubles are
* transferred and a {@link BufferOverflowException} is thrown.
*
* <p>Otherwise, this method copies <i>n</i> = <tt>src.remaining()</tt> doubles from the
* given buffer into this buffer, starting at each buffer's current position. The positions of
* both buffers are then incremented by <i>n</i>.
*
* <p>In other words, an invocation of this method of the form <tt>dst.put(src)</tt> has exactly
* the same effect as the loop
*
* <pre>
* while (src.hasRemaining())
* dst.put(src.get()); </pre>
*
* except that it first checks that there is sufficient space in this buffer and it is potentially
* much more efficient.
*
* @param src The source buffer from which doubles are to be read; must not be this buffer
* @return This buffer
* @throws BufferOverflowException If there is insufficient space in this buffer for the remaining
* doubles in the source buffer
* @throws IllegalArgumentException If the source buffer is this buffer
* @throws ReadOnlyBufferException If this buffer is read-only
*/
public DoubleBuffer put(DoubleBuffer src) {
if (src == this) throw new IllegalArgumentException();
int n = src.remaining();
if (n > remaining()) throw new BufferOverflowException();
for (int i = 0; i < n; i++) put(src.get());
return this;
}
/** Not yet commented. */
protected void collapse() {
DoubleBuffer[] toCollapse = buffersToCollapse();
DoubleBuffer outputBuffer = bufferSet.collapse(toCollapse);
int minLevel = toCollapse[0].level();
outputBuffer.level(minLevel + 1);
postCollapse(toCollapse);
}
/**
* Compares this buffer to another.
*
* <p>Two double buffers are compared by comparing their sequences of remaining elements
* lexicographically, without regard to the starting position of each sequence within its
* corresponding buffer.
*
* <p>A double buffer is not comparable to any other type of object.
*
* @return A negative integer, zero, or a positive integer as this buffer is less than, equal to,
* or greater than the given buffer
*/
public int compareTo(DoubleBuffer that) {
int n = this.position() + Math.min(this.remaining(), that.remaining());
for (int i = this.position(), j = that.position(); i < n; i++, j++) {
double v1 = this.get(i);
double v2 = that.get(j);
if (v1 == v2) continue;
if ((v1 != v1) && (v2 != v2)) // For float and double
continue;
if (v1 < v2) return -1;
return +1;
}
return this.remaining() - that.remaining();
}
/**
* Adds a value to the receiver.
*
* @param value the value to add.
*/
public void add(double value) {
totalElementsFilled++;
if (!sampleNextElement()) return;
// System.out.println("adding "+value);
if (currentBufferToFill == null) {
if (bufferSet._getFirstEmptyBuffer() == null) collapse();
newBuffer();
}
currentBufferToFill.add(value);
if (currentBufferToFill.isFull()) currentBufferToFill = null;
}
/**
* Tells whether or not this buffer is equal to another object.
*
* <p>Two double buffers are equal if, and only if,
*
* <p>
*
* <ol>
* <li>
* <p>They have the same element type,
* <li>
* <p>They have the same number of remaining elements, and
* <li>
* <p>The two sequences of remaining elements, considered independently of their starting
* positions, are pointwise equal.
* </ol>
*
* <p>A double buffer is not equal to any other type of object.
*
* @param ob The object to which this buffer is to be compared
* @return <tt>true</tt> if, and only if, this buffer is equal to the given object
*/
public boolean equals(Object ob) {
if (!(ob instanceof DoubleBuffer)) return false;
DoubleBuffer that = (DoubleBuffer) ob;
if (this.remaining() != that.remaining()) return false;
int p = this.position();
for (int i = this.limit() - 1, j = that.limit() - 1; i >= p; i--, j--) {
double v1 = this.get(i);
double v2 = that.get(j);
if (v1 != v2) {
if ((v1 != v1) && (v2 != v2)) // For float and double
continue;
return false;
}
}
return true;
}
/**
* Adds the part of the specified list between indexes <tt>from</tt> (inclusive) and <tt>to</tt>
* (inclusive) to the receiver.
*
* @param values the list of which elements shall be added.
* @param from the index of the first element to be added (inclusive).
* @param to the index of the last element to be added (inclusive).
*/
public void addAllOfFromTo(DoubleArrayList values, int from, int to) {
/*
// the obvious version, but we can do quicker...
double[] theValues = values.elements();
int theSize=values.size();
for (int i=0; i<theSize; ) add(theValues[i++]);
*/
double[] valuesToAdd = values.elements();
int k = this.bufferSet.k();
int bufferSize = k;
double[] bufferValues = null;
if (currentBufferToFill != null) {
bufferValues = currentBufferToFill.values.elements();
bufferSize = currentBufferToFill.size();
}
for (int i = from - 1; ++i <= to; ) {
if (sampleNextElement()) {
if (bufferSize == k) { // full
if (bufferSet._getFirstEmptyBuffer() == null) collapse();
newBuffer();
if (!currentBufferToFill.isAllocated) currentBufferToFill.allocate();
currentBufferToFill.isSorted = false;
bufferValues = currentBufferToFill.values.elements();
bufferSize = 0;
}
bufferValues[bufferSize++] = valuesToAdd[i];
if (bufferSize == k) { // full
currentBufferToFill.values.setSize(bufferSize);
currentBufferToFill = null;
}
}
}
if (this.currentBufferToFill != null) {
this.currentBufferToFill.values.setSize(bufferSize);
}
this.totalElementsFilled += to - from + 1;
}
