docs: public boolean removeAll(AbstractBooleanList other) {
  	// overridden for performance only.
  	if (! (other instanceof BooleanArrayList))	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.size()==0) {return false;} //nothing to do
  	int limit = other.size()-1;
  	int j=0;
  	boolean[] theElements = elements;
  	int mySize = size();
  
  	double N=(double) other.size();
  	double M=(double) mySize;
  	if ( (N+M)*cern.colt.Math.log2(N) < M*N ) {
  		// it is faster to sort other before searching in it
  		BooleanArrayList sortedList = (BooleanArrayList) 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;
  }