/** * 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; }