/** * Removes from the receiver all elements that are contained in the specified list. Tests for * identity. * * @param other the other list. * @return <code>true</code> if the receiver changed as a result of the call. */ @Override public boolean removeAll(AbstractFloatList other) { // overridden for performance only. if (!(other instanceof FloatArrayList)) { return super.removeAll(other); } /* There are two possibilities to do the thing a) use other.indexOf(...) b) sort other, then use other.binarySearch(...) Let's try to figure out which one is faster. Let M=size, N=other.size, then a) takes O(M*N) steps b) takes O(N*logN + M*logN) steps (sorting is O(N*logN) and binarySearch is O(logN)) Hence, if N*logN + M*logN < M*N, we use b) otherwise we use a). */ if (other.isEmpty()) { return false; } // nothing to do int limit = other.size() - 1; int j = 0; float[] theElements = elements; int mySize = size(); double N = (double) other.size(); double M = (double) mySize; if ((N + M) * org.apache.mahout.collections.Arithmetic.log2(N) < M * N) { // it is faster to sort other before searching in it FloatArrayList sortedList = (FloatArrayList) other.clone(); sortedList.quickSort(); for (int i = 0; i < mySize; i++) { if (sortedList.binarySearchFromTo(theElements[i], 0, limit) < 0) { theElements[j++] = theElements[i]; } } } else { // it is faster to search in other without sorting for (int i = 0; i < mySize; i++) { if (other.indexOfFromTo(theElements[i], 0, limit) < 0) { theElements[j++] = theElements[i]; } } } boolean modified = (j != mySize); setSize(j); return modified; }