/// <summary> /// Retains (keeps) only the elements in the receiver that are contained in the specified other list. /// In other words, removes from the receiver all of its elements that are not contained in the /// specified other listd /// <summary> /// <param name="other">the other list to test against.</param> /// <returns><code>true</code> if the receiver changed as a result of the call.</returns> public virtual Boolean RetainAll(AbstractShortList other) { if (other.Size == 0) { if (_size == 0) { return(false); } SetSize(0); return(true); } int limit = other.Size - 1; int j = 0; for (int i = 0; i < _size; i++) { if (other.IndexOfFromTo(GetQuick(i), 0, limit) >= 0) { SetQuick(j++, GetQuick(i)); } } Boolean modified = (j != _size); SetSize(j); return(modified); }
/// <summary> /// Retains (keeps) only the elements in the receiver that are contained in the specified other list. /// In other words, removes from the receiver all of its elements that are not contained in the /// specified other listd /// <summary> /// <param name="other">the other list to test against.</param> /// <returns><code>true</code> if the receiver changed as a result of the call.</returns> public override Boolean RetainAll(AbstractShortList other) { // overridden for performance only. if (!(other is ShortArrayList)) { return(base.RetainAll(other)); } /* There are two possibilities to do the thing * a) use other.IndexOf(..d) * b) sort other, then use other.BinarySearch(..d) * * Let's try to figure out which one is fasterd 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). */ int limit = other.Size - 1; int j = 0; var theElements = _elements; int mySize = Size; int N = (int)other.Size; int M = (int)mySize; if ((N + M) * Cern.Jet.Math.Arithmetic.Log2(N) < M * N) { // it is faster to sort other before searching in it ShortArrayList sortedList = (ShortArrayList)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); }