/// <summary>
/// Returns a deep copy of the receiverd
///
/// <summary>
/// <returns> a deep copy of the receiver.</returns>
public override Object Clone()
{
// overridden for performance only.
ShortArrayList clone = new ShortArrayList((short[])_elements.Clone());
clone.SetSizeRaw(Size);
return(clone);
}
/// <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);
}
/// <summary>
/// Returns a new list of the part of the receiver between <code>from</code>, inclusive, and <code>to</code>, inclusive.
/// <summary>
/// <param name="from">the index of the first element (inclusive).</param>
/// <param name="to">the index of the last element (inclusive).</param>
/// <returns>a new list</returns>
/// <exception cref="IndexOutOfRangeException">index is out of range (<i>_size()>0 && (from<0 || from>to || to>=_size())</i>). </exception>
public virtual AbstractShortList PartFromTo(int from, int to)
{
CheckRangeFromTo(from, to, _size);
int Length = to - from + 1;
var part = new ShortArrayList(Length);
part.AddAllOfFromTo(this, from, to);
return(part);
}
/// <summary>
/// Returns a list which is a concatenation of <code>times</code> times the receiver.
/// <summary>
/// <param name="times">the number of times the receiver shall be copied.</param>
public virtual AbstractShortList Times(int times)
{
AbstractShortList newList = new ShortArrayList(times * Size);
for (int i = times; --i >= 0;)
{
newList.AddAllOfFromTo(this, 0, Size - 1);
}
return(newList);
}
/// <summary>
/// Appends all elements of the specified list to the receiver.
/// <summary>
/// <param name="list">the list of which all elements shall be appended.</param>
public virtual void AddAllOf(ShortArrayList other)
{
AddAllOfFromTo(other, 0, other.Size - 1);
}