//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
// PLEASE DO NOT EDIT WITHOUT THE EXPLICIT CONSENT OF THE AUTHOR! \\
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\

namespace Ilog.Language.Util
{
  using IEnumerator = System.Collections.IEnumerator;
  using ICollection = System.Collections.ICollection;
  using StringBuilder = System.Text.StringBuilder;
  using Math = System.Math;

  /**
   * This class implements <tt>java.util.ArrayList</tt> in C# keeping
   * the same API (up to having all method names capitalized, adding an
   * indexer, <tt>Count</tt> and <tt>IsEmpty</tt> properties, and
   * removing the <tt>size()</tt> method. The only reason to have this
   * instead of <tt>System.Collections.ArrayList</tt> is that it is the
   * base class of <tt>Ilog.Language.Util.Stack</tt>, which itself is a
   * reimplementation of <tt>java.util.Stack</tt>. The reason for the
   * reimplementation of <tt>Stack</tt> is because the one in
   * <tt>System.Collections</tt> provides no methods for peeking deep
   * into the stack, which is crucial to its use as a parse stack in
   * <tt>Ilog.Language.Parsing</tt> parsers implementation. This class
   * is <i>not</i> synchronized.
   *
   * @version     Last modified on Sat May 28 16:11:54 2005 by hak
   * @author      <a href="mailto:hak@ilog.fr">Hassan A&iuml;t-Kaci</a>
   * @copyright   &copy; 2002 <a href="http://www.ilog.fr/">ILOG, S.A.</a>
   */
  public class Vector : Listable
    {
      // FIELDS:

      /**
       * The array buffer into which the components of the Vector are
       * stored. The capacity of the Vector is the length of this array
       * buffer, and is at least large enough to contain all the Vector's
       * elements.
       */
      protected object[] elements;

      /**
       * The number of valid components in this Vector object. Components
       * <tt>elements[0]</tt> through <tt>elements[count-1]</tt> are the
       * actual elements.
       */
      protected int count;

      /**
       * The amount by which the capacity of the Vector is automatically
       * incremented when its size becomes greater than its capacity. If the
       * capacity increment is less than or equal to zero, the capacity of
       * the Vector is multiplied by <tt>incFactor</tt> each time it needs
       * to grow. The default value of <tt>incFactor</tt> is 2.0 (so growing
       * objects the capacity). It may be reset with
       * <tt>SetIncrementFactor(float)</tt> to any fractional value between
       * 1.1 and 5.0.
       */
      protected int deltaCap;

      // CONSTRUCTORS:

      /**
       * Constructs an empty Vector with the specified initial capacity
       * and capacity increment.
       *
       * @param     initialCapacity the initial capacity of the Vector.
       * @param     deltaCap amount by which the capacity is increased on overflow.
       * @exception ArgumentOutOfRangeException if the specified initial capacity is negative.
       */
      public Vector (int initialCapacity, int deltaCap)
	: this(initialCapacity)
        {	  
	  this.deltaCap = deltaCap;
	}

      /**
       * Constructs an empty Vector with the specified initial capacity
       * and with its capacity increment equal to zero.
       *
       * @param     initialCapacity the initial capacity of the Vector.
       * @exception ArgumentOutOfRangeException if the specified initial capacity is negative.
       */
      public Vector (int initialCapacity)
        {
	  elements = new object[initialCapacity];
	}

      /**
       * Constructs an empty Vector so that its internal data array has
       * size 10 and its standard capacity increment is zero.
       */
      public Vector ()
	: this(10)
        {
	}

      /**
       * Constructs a Vector containing the objects contained in the
       * specified array, in the same order.
       *
       * @param     a an array of objects.
       */
      public Vector (object[] a)
        {
	  elements = new object[a.Length];

	  for (int i=0; i<a.Length; i++)
	    elements[count++] = a[i];
	}

      /**
       * Constructs a Vector containing the objects in the specified
       * collection, in the order they are returned by the collection's
       * enumerator.
       *
       * @param     c the collection whose elements are to be placed into this Vector.
       */
      public Vector (ICollection c)
        {
	  elements = new object[c.Count];
	  foreach (object elt in c)
	    elements[count++] = elt;
	}

      // METHODS:

      /**
       * Copies the components of this Vector into the specified
       * array. The element at index k in this Vector is copied into
       * component k of a. The array must be big enough to hold all the
       * elements of this Vector, else an ArgumentOutOfRangeException is
       * thrown.
       *
       * @param     a the array into which the components get copied.
       * @exception ArgumentOutOfRangeException if the array is too small.
       */
      public void CopyInto (object[] a)
        {
	  for (int i=0; i<count; i++)
	    a[i] = elements[i];
	}

      /**
       * Trims the capacity of this Vector to be the Vector's current
       * size. If the capacity of this Vector is larger than its current
       * size, then the capacity is changed to equal the size by replacing
       * its internal data array, kept in the field elements, with a smaller
       * one. An application can use this operation to minimize the storage
       * of a Vector.
       */
      public void TrimToSize ()
        {
	  if (count == elements.Length)
	    return;
	  object[] newArray = newArray = new object[count];
	  for (int i=0; i<count; i++)
	    newArray[i] = elements[i];
	  elements = newArray;
	}

      /**
       * Increases the capacity of this Vector, if necessary, to ensure
       * that it can hold at least the number of components specified by the
       * minimum capacity argument.
       *
       * <p> If the current capacity of this Vector is less than
       * minCapacity, then its capacity is increased by replacing its
       * internal data array, kept in the field elements, with a larger
       * one. The size of the new data array will be the old size plus
       * deltaCap, unless the value of deltaCap is less than or equal to
       * zero, in which case the new capacity will be the old capacity
       * multiplied by incFactor; but if this new size is still smaller than
       * minCapacity, then the new capacity will be minCapacity.
       *
       * @param     minCapacity the desired minimum capacity.
       */
      public void EnsureCapacity (int minCapacity)
        {
	  if (elements.Length >= minCapacity)
	    return;

	  object[] newArray = new object[Math.Max(minCapacity,IncreasedCapacity())];
	  for (int i=0; i<count; i++)
	    newArray[i] = elements[i];
	  elements = newArray;
	}

      /**
       * Sets the size of this Vector. If the new size is greater than the
       * current size, new nulls are added to the end of the Vector. If
       * the new size is less than the current size, all components at index
       * newSize and greater are set to null.
       *
       * @param     newSize the new size of this Vector.
       * @exception ArgumentOutOfRangeException if new size is negative.
       */
      public void SetSize (int newSize)
        {
	  EnsureCapacity(newSize);
	  for (;count>newSize;)
	    elements[--count] = null;
	}

      /**
       * Returns the current capacity of this Vector.
       *
       * @return    the current capacity the length of its internal data array.
       */
      public int Capacity ()
        {
	  return elements.Length;
	}

      /**
       * Denotes the number of components in this Vector.
       *
       * @return    the number of components in this Vector.
       */
      public int Count
        {
	  get { return count; }
	}

      /**
       * True iff this Vector has no components.
       *
       * @return    true if this Vector's size is zero; false otherwise.
       */
      public bool IsEmpty
        {
	  get { return count == 0; }
	}

      /**
       * Tests if the specified object is a component in this Vector.
       *
       * @param     element a object.
       * @return    true if the specified object is in this Vector; false otherwise.
       */
      public bool Contains (object element)
        {
	  for (int i=0; i<count; i++)
	    if (elements[i].Equals(element))
	      return true;
	  
	  return false;
	}

      /**
       * Searches for the first occurrence of the given object; returns -1 if
       * it is not found.
       *
       * @param     element a object.
       * @return    the index of the first occurrence of the argument or -1.
       */
      public int IndexOf (object element)
        {
	  for (int i=0; i<count; i++)
	    if (elements[i].Equals(element))
	      return i;

	  return -1;
	}

      /**
       * Searches for the first occurence of the given object, beginning the
       * search at index; returns -1 if it is not found.
       *
       * @param     element a object.
       * @param     index the non-negative index to start searching from.
       * @exception ArgumentOutOfRangeException if index is negative.
       */
      public int IndexOf (object element, int index)
        {
	  for (int i=index; i<count; i++)
	    if (elements[i].Equals(element))
	      return i;

	  return -1;
	}

      /**
       * Returns the index of the last occurrence of the specified object in
       * this Vector; returns -1 if it is not found.
       *
       * @param     element the desired component.
       * @return    the index of the last occurrence of the specified object, or -1.
       */
      public int LastIndexOf (object element)
        {
	  for (int i=count; i-->0;)
	    if (elements[i].Equals(element))
	      return i;

	  return -1;
	}

      /**
       * Searches backwards for the specified object, starting from the
       * specified index, and returns its index, or -1 if not found.
       *
       * @param     element a object.
       * @param     index the non-negative index to start searching from.
       * @exception ArgumentOutOfRangeException if index is invalid.
       */
      public int LastIndexOf (object element, int index)
        {
	  for (int i=index; i>=0; i--)
	    if (elements[i].Equals(element))
	      return i;

	  return -1;
	}

      /**
       * Returns the component at the specified index. This method is
       * identical in functionality to the Get method.
       *
       * @param     index an index into this Vector.
       * @exception ArgumentOutOfRangeException if the index is invalid.
       */
      public object ElementAt (int index)
        {
	  return elements[index];
	}

      /**
       * Returns the first component (the element at index 0) of this Vector.
       *
       * @return    the first component of this Vector.
       * @exception ArgumentOutOfRangeException if this Vector is empty.
       */
      public object FirstElement ()
        {
	  return elements[0];
	}

      /**
       * Returns the last component of the Vector.
       *
       * @return    the last component of the Vector, i.e., the component at size() - 1.
       * @exception ArgumentOutOfRangeException if this Vector is empty.
       */
      public object LastElement ()
        {
	  return elements[count-1];
	}

      /**
       * Sets the component at the specified index of this Vector to be the
       * specified object. The previous component at that position is lost.
       * <p>
       * The index must be a value greater than or equal to 0 and less than
       * the current size of the Vector.
       * <p>
       * This method is identical in functionality to the set method except
       * that the latter returns the old object that was stored at the specified
       * position and it has its argument in a different order.
       *
       * @param     element what the component is to be set to.
       * @param     index the specified index.
       * @exception ArgumentOutOfRangeException if the index was invalid.
       */
      public void SetElementAt (object element, int index)
        {
	  Set(index,element);
	}

      /**
       * Deletes the component at the specified index. Each component in
       * this Vector with an index greater or equal to the specified index
       * is shifted downward to have an index one smaller than the value it
       * had previously. The size of this Vector is decreased by 1.
       * <p>
       * The index must be a value greater than or equal to 0 and less than
       * the current size of the Vector.
       * <p>
       * This method is identical in functionality to the remove(int) method
       * except that the remove(int) method returns the old value that was
       * stored at the specified position.
       *
       * @param     index the index of the object to remove.
       * @exception ArgumentOutOfRangeException if the index was invalid.
       */
      public void RemoveElementAt (int index)
        {
	  Remove(index);
	}

      /**
       * Inserts the specified object as a component in this Vector at the
       * specified index. Each component in this Vector with an index
       * greater or equal to the specified index is shifted upward to have
       * an index one greater than the value it had previously.
       * <p>
       * The index must be a value greater than or equal to 0 and less than
       * or equal to the current size of the Vector. (If the index is equal
       * to the current size of the Vector, the new element is appended to
       * the Vector.)
       * <p>
       * This method is identical in functionality to the add(int, object)
       * method except that the latter method reverses the order of the
       * arguments, to match array usage  more closely.
       *
       * @param     element the element to insert.
       * @param     index where to insert the new component.
       * @exception ArgumentOutOfRangeException if the index was invalid.
       */
      public void InsertElementAt (object element, int index)
        {
	  Add(index,element);
	}

      /**
       * Adds the specified component to the end of this Vector, increasing
       * its size by one. The capacity of this Vector is increased if its
       * size becomes greater than its capacity.
       * <p>
       * This method is identical in functionality to the Add(object) method
       * except that the latter returns a bool.
       *
       * @param     element the component to be added.
       */
      public void AddElement (object element)
        {
	  Add(element);
	}

      /**
       * Removes all components from this Vector.
       * This method is identical in functionality to the Clear method.
       *
       */
      public void RemoveAllElements ()
        {
	  count = 0;
	}

      /**
       * Returns a clone of this Vector. The copy will contain a reference
       * to a clone of the internal data array, not a reference to the
       * original internal data array of this Vector object.
       *
       * @return    a clone of this Vector.
       */
      public object Clone ()
        {
	  object[] newArray = new object[elements.Length];

	  for (int i=0; i<elements.Length; i++)
	    newArray[i] = elements[i];

	  return new Vector(newArray,count,deltaCap,incFactor);
	}

      /**
       * Returns an array containing all of the elements in this Vector in
       * the correct order.
       */
      public object[] ToArray ()
        {
	  object[] a = new object[count];

	  for (int i=0; i<count; i++)
	    a[i] = elements[i];

	  return a;
	}

      /**
       * Returns the element at the specified position in this Vector.
       *
       * @exception ArgumentOutOfRangeException if the index is invalid.
       */
      public object Get (int index)
        {
	  return elements[index];
	}

      /**
       * Replaces the element at the specified position in this Vector
       * with the specified element.
       *
       * @param     index index of element to replace.
       * @param     element element to be stored at the specified position.
       * @return    the element previously at the specified position.
       * @exception ArgumentOutOfRangeException if index is out of range.
       */
      public object Set (int index, object element)
        {
	  object old = elements[index];
	  elements[index] = element;
	  return old;
	}

      /**
       * An array-style indexer for getting and setting an element of this
       * Vector at the specified index.
       */
      public object this [int index]
        {
	  get { return elements[index]; }
	  set { elements[index] = value; }
	}

      /**
       * Replaces the element at the last position in this Vector with
       * the specified element.
       *
       * @param     element element to be stored at the last position.
       * @exception ArgumentOutOfRangeException if index is out of range.
       */
      public void SetLast (object element)
        {
	  elements[count-1] = element;
	}

      /**
       * Appends the specified element to the end of this Vector.
       *
       * @param     element element to be appended to this Vector.
       * @return    true (following the <tt>java.util.Vector</tt> API).
       */
      public bool Add (object element)
        {
	  if (count == elements.Length)
	    Grow();
	  elements[count++] = element;
	  return true;
	}

      /**
       * Removes the first occurrence of the specified element. If this Vector
       * does not contain the element, it is left unchanged.
       * <p>
       * <b>N.B.</b>Because <tt>remove(object)</tt> is ambiguous, it is not
       * supported for Vectors; its functionality is provided by
       * <tt>removeIndex(int)</tt> and <tt>removeElement(object)</tt>.
       *
       * @param     element element to be removed from this Vector, if present.
       * @return    true if this Vector contained the specified element.
       */
      public bool Remove (object element)
        {
	  int i = 0;

	  for (i=0; i<count; i++)
	    if (elements[i].Equals(element))
	      break;

	  if (i == count)
	    return false;

	  for (;i<count-1;i++)
	    elements[i] = elements[i+1];

	  count--;

	  return true;
	}

      /**
       * Removes the first occurrence of the specified element. If this
       * Vector does not contain the element, it is left unchanged. Note
       * that this method is identical to Remove(object).
       *
       * @param     element element to be removed from this Vector, if present.
       * @return    true if this Vector contained the specified element.
       */
      public bool RemoveElement (object element)
        {
	  return Remove(element);
	}

      /**
       * Inserts the specified element at the specified position in this
       * Vector. Shifts the element currently at that position (if any)
       * and any subsequent elements to the right (adds one to their
       * indices).
       *
       * @param     index index at which the specified element is to be inserted.
       * @param     element element to be inserted.
       * @exception ArgumentOutOfRangeException if index is out of range.
       */
      public void Add (int index, object element)
        {
	  EnsureCapacity(count++);

	  for (int i=count-1; i>index; i--)
	    elements[i] = elements[i-1];

	  elements[index] = element;
	}

      /**
       * Removes the element at the specified position and shifts any
       * subsequent elements to the left (subtracts one from their
       * indices). Returns the element that was removed.
       *
       * @param     index the index of the element to removed.
       * @return    the element that was at this index position.
       * @exception ArgumentOutOfRangeException if index is out of range.
       */
      public object Remove (int index)
        {
	  object old = elements[index];

	  for (int i=index; i<count-1; i++)
	    elements[i] = elements[i+1];

	  count--;

	  return old;
	}

      /**
       * Removes all of the elements from this Vector.
       */
      public void Clear ()
        {
	  count = 0;
	}

      /**
       * Returns true if this Vector contains all of the elements in the
       * specified array.
       *
       * @param     a array containing the elements to be tested for membership.
       * @return    true if all of the elements of the specified array belong in this.
       */
      public bool ContainsAll (object[] a)
        {
	  for (int i=a.Length; i-->0;)
	    if (!Contains(a[i]))
	      return false;

	  return true;
	}

      /**
       * Returns true if this Vector contains all of the elements in the
       * specified Vector.
       *
       * @param     v Vector of elements to be tested for membership.
       * @return    true if all the elements of the specified collection belong to this.
       */
      public bool ContainsAll (Vector v)
        {
	  foreach (object elt in v)
	    if (!Contains(elt))
	      return false;

	  return true;
	}

      /**
       * Appends all of the elements in the specified array to the end of
       * this Vector, in the order of the array.
       *
       * @param     a array containing the elements to be inserted.
       * @exception ClassCastException if the collection contains a non-number.
       * @return    true (following the <tt>java.util.Vector</tt> API).
       */
      public bool AddAll (object[] a)
        {
	  EnsureCapacity(count+a.Length);
	  for (int i=0; i<a.Length; i++)
	    elements[count++] = a[i];
	  return true;
	}

      /**
       * Appends all of the elements in the specified Vector to the end of
       * this Vector.
       *
       * @param     v the Vector of elements to be added.
       * @return    true (following the <tt>java.util.Vector</tt> API).
       */
      public bool AddAll (Vector v)
        {
	  int size = v.Count;
	  EnsureCapacity(count+size);
	  foreach (object elt in v)
	    elements[count++] = elt;
	  return true;
	}

      /**
       * Removes from this Vector all of its elements that are contained
       * in the specified array. Note that all occurrences of such elemeents
       * are removed - not just the first.
       *
       * @param     a array of elements to be removed.
       * @return    true if this Vector changed as a result of the call.
       */
      public bool RemoveAll (object[] a)
        {
	  Vector indices = new Vector();

	  for (int i=0; i<a.Length; i++)
	    for (int j=0; j<count; j++)
	      if (a[i].Equals(elements[j]))
		indices.Add(j);

	  RemoveAllIndices(indices);
	  return !indices.IsEmpty;
	}

      /**
       * Removes from this Vector all of its elements that are contained
       * in the specified Vector. Note that all occurrences of such
       * elemeents are removed - not just the first.
       *
       * @param     v the Vector of elements to be removed.
       * @return    true if this Vector changed as a result of the call.
       */
      public bool RemoveAll (Vector v)
        {
	  Vector indices = new Vector();

	  foreach (object elt in v)
	    for (int i=count; i-->0;)
	      if (elt.Equals(elements[i]))
		indices.Add(i);

	  RemoveAllIndices(indices);
	  return !indices.IsEmpty;
	}

      /**
       * Removes from this Vector the first occurrence of the elements
       * that are contained in the specified array
       *
       * @param     a array of elements to be removed.
       * @return    true if this Vector changed as a result of the call.
       */
      public bool RemoveAllFirst (object[] a)
        {
	  Vector indices = new Vector();

	  for (int i=0; i<a.Length; i++)
	    for (int j=0; j<count; j++)
	      if (a[i].Equals(elements[j]))
	        {
		  indices.Add(j);
		  break;
		}

	  RemoveAllIndices(indices);
	  return !indices.IsEmpty;
	}

      /**
       * Removes from this Vector the first occurrence of the elements
       * that are contained in the specified Vector.
       *
       * @param     v the Vector of elements to be removed.
       * @return    true if this Vector changed as a result of the call.
       */
      public bool RemoveAllFirst (Vector v)
        {
	  Vector indices = new Vector();

	  foreach (object elt in v)
	    for (int i=0; i<count; i++)
	      if (elt.Equals(elements[i]))
	      {
		indices.Add(i);
		break;
	      }

	  RemoveAllIndices(indices);
	  return !indices.IsEmpty;
	}

      /**
       * Retains only the elements in this Vector whose elements are
       * contained in the specified Vector. In other words, removes from
       * this Vector all of its elements that are not contained in the
       * specified Vector.
       *
       * @param     v the Vector of elements to be retained.
       * @return    true if this Vector changed as a result of the call.
       */
      public bool RetainAll (Vector v)
        {
	  Vector indices = new Vector();

	  for (int i=0; i<count; i++)
	    if (!v.Contains(elements[i]))
	      indices.Add(i);

	  RemoveAllIndices(indices);
	  return !indices.IsEmpty;
	}

      /**
       * Inserts all the elements in the specified array at the specified
       * index in this Vector. Shifts the element currently at that
       * position (if any) and any subsequent elements to the right (adds the
       * length of the array to their indices).
       *
       * @param     index index at which the specified element is to be inserted.
       * @param     a arrays of element to be inserted.
       * @exception ArgumentOutOfRangeException if index is out of range.
       */
      public void AddAll (int index, object[] a)
        {
	  if (count+a.Length < elements.Length)
	  {
	    for (int i=index; i<count; i++)
	      elements[i+a.Length] = elements[i];

	    for (int i=0; i<a.Length; i++)
	      elements[index+i] = a[i];

	    count += a.Length;
	    return;
	  }

	  object[] newArray = new object[IncreasedCapacity(count+a.Length)];

	  for (int i=0; i<index; i++)
	    newArray[i] = elements[i];

	  for (int i=0; i<a.Length; i++)
	    newArray[index+i] = a[i];

	  for (int i=index+a.Length; i<count+a.Length; i++)
	    newArray[i] = elements[i-a.Length];

	  elements = newArray;
	  count += a.Length;
	}

      /**
       * Inserts all of the elements in the specified Vector into this
       * Vector at the specified position. Shifts the element currently at
       * that position (if any) and any subsequent elements to the right
       * (increases their indices). The new elements will appear in this
       * Vector in their order in the specified Vector.
       *
       * @param     index index where to insert the first element
       * @param     v Vector to be inserted into this Vector.
       * @exception ArgumentOutOfRangeException if index is invalid.
       */
      public void AddAll (int index, Vector v)
        {
	  int size = v.Count;

	  if (count+size < elements.Length)
	    {
	      for (int i=index; i<count; i++)
		elements[i+size] = elements[i];

	      for (int i=0; i<size; i++)
		elements[index+i] = v[i];

	      count += size;
	      return;
	    }

	  object[] newArray = new object[IncreasedCapacity(count+size)];

	  for (int i=0; i<index; i++)
	    newArray[i] = elements[i];

	  for (int i=0; i<size; i++)
	    newArray[index+i] = v[i];

	  for (int i=index+size; i<count+size; i++)
	    newArray[i] = elements[i-size];

	  elements = newArray;
	  count += size;
	}

      /**
       * Compares the specified object with this Vector for equality.
       * Returns true if and only if the specified object is also an
       * Vector, both have the same size, and all corresponding pairs of
       * elements are equal. In other words, two Vectors are defined to be
       * equal if all their elements are equal in the same order.
       *
       * @param     o the object to be compared for equality with this Vector.
       * @return    true if the specified object is equal to this Vector
       */
      public override bool Equals (object o)
        {
	  if (!(o is Vector))
	    return false;

	  Vector other = (Vector)o;

	  if (other.count != count)
	    return false;

	  for (int i=0; i<count; i++)
	    if (!other.elements[i].Equals(elements[i]))
	      return false;

	  return true;
	}

      /**
       * Returns a hash code value for this Vector.
       */
      public override int GetHashCode ()
        {
	  long code = count;
	  int shift = 1;

	  for (int i=0; i<count; i += Math.Max(1,count/4))
	    {
	      if (shift > 0)
		code <<= 1;
	      else
		code >>= 1;

	      code ^= elements[i].GetHashCode();
	      shift = -shift;
	    }

	  return (int)code;
	}

      /**
       * Returns a string representation of this Vector.
       *
       * @return    a string representation of this collection.
       */
      public override string ToString ()
        {
	  StringBuilder buf = new StringBuilder("[");
	  string sep = "";

	  for (int i=0; i<count; i++)
	    {
	      buf.Append(sep).Append(elements[i]);
	      sep = ", ";
	    }

	  return buf.Append("]").ToString();
	}

      /**
       * Removes from this Vector all of the elements whose indices are
       * between fromIndex, inclusive and toIndex, exclusive. Shifts any
       * succeeding elements to the left (reduces their index). This call
       * shortens the Vector by (toIndex - fromIndex) elements. (If
       * toIndex <= fromIndex, this operation has no effect.)
       * <p>
       * <b>N.B.</b> Note that this method is public, whereas - strangely
       * enough, it is protected in the <tt>java.util.Vector</tt> API!
       *
       * @param     fromIndex index of first element to be removed.
       * @param     toIndex index after last element to be removed.
       */
      public void RemoveRange (int fromIndex, int toIndex)
        {
	  if (toIndex <= fromIndex)
	    return;

	  toIndex = Math.Min(toIndex, count);

	  int gap = toIndex - fromIndex;

	  for (int i=fromIndex; i<toIndex; i++)
	    elements[i] = elements[i+gap];

	  count -= gap;
	}

      // This part of the API is new w.r.t. the java class.

      protected float incFactor = 2.0f;

      /**
       * @param     incFactor a float that is between 1.1 and 5.0
       * @exception ArgumentException if not between 1.1 and 5.0
       */
      public void SetIncrementFactor (float incFactor)
        {
	  if (incFactor < 1.1 || incFactor > 5.0)
	    throw new System.ArgumentException("Increment factor "+incFactor
					       +" must be in [1.1,5.0] range");
	  this.incFactor = incFactor;
	}

      // PRIVATES:

      /**
       * A constructor used privately for cloning only...
       */
      private Vector (object[] elements, int count, int deltaCap, float incFactor)
        {
	  this.elements = elements;
	  this.count = count;
	  this.deltaCap = deltaCap;
	  this.incFactor = incFactor;
	}

      /**
       * Grows the size of the internal array.
       */
      private void Grow ()
        {
	  object[] newArray = new object[IncreasedCapacity()];

	  for (int i=0; i<count; i++)
	    newArray[i] = elements[i];

	  elements = newArray;
	}

      /**
       * Computes a greater capacity for this Vector.
       *
       * @return    the increased capacity
       */
      private int IncreasedCapacity ()
        {
	  if (deltaCap <= 0)
	    {
	      int capacity = elements.Length == 0 ? 1 : elements.Length;
	      return (int)Math.Floor(capacity*incFactor+1);
	    }

	  return elements.Length+deltaCap;
	}

      /**
       * Computes a greater capacity for this Vector that is at least
       * the specified capacity.
       *
       * @param     minCapacity the minimum necessary capacity.
       * @return    the increased capacity
       */
      private int IncreasedCapacity (int minCapacity)
        {
	  if (deltaCap <= 0)
	    {
	      int capacity = elements.Length == 0 ? 1 : elements.Length;
	      return Math.Max(minCapacity,
			      (int)Math.Floor(capacity*incFactor));
	    }

	  return Math.Max(minCapacity,elements.Length+deltaCap);
	}

      /**
       * Removes from this Vector all of its elements that are located at
       * the indices in the specified IntVector. This assumes that the
       * indices appear sorted in increasing order.
       *
       * @param     indices indices of elements to be removed.
       */
      private void RemoveAllIndices (Vector indices)
        {
	  int size = indices.Count;

	  for (int i=1; i<=size; i++)
	    {
	      int lo = (int)indices[i-1];
	      int hi = i < size ? (int)indices[i] : count;
	      for (int j=lo+1; j<hi; j++)
		elements[j-i] = elements[j];
	    }

	  count -= size;
	}

      /**
       * Returns an enumerator for this Vector.
       */
      public virtual IEnumerator GetEnumerator ()
        {
	  return new VectorEnumerator(elements,count);
	}

      /**
       * This class implements an IEnumerator for a Vector.
       */
      private class VectorEnumerator : IEnumerator
        {
	  /**
	   * Constructs an enumerator from the specified array and count.
	   */
	  public VectorEnumerator (object[] elements, int count)
	    {
	      this.elements = elements;
	      this.count = count;
	      next = 0;
	    }

	  /**
	   * The elements.
	   */
	  private object[] elements;

	  /**
	   * The count.
	   */
	  private int count;

	  /**
	   * The next index to enumerate.
	   */
	  private int next;

	  /**
	   * The current element being enumerated.
	   */
	  private object current = null;
	  public object Current
	    {
	      get { return current; }
	    }

	  /**
	   * Advances to the next element, returning true if there is
	   * one, false otherwise.
	   */
	  public bool MoveNext ()
	    {
	      if (next == count)
		return false;

	      current = elements[next];
	      next++;
	      return true;
	    }

	  /**
	   * Resets this enumerator to its beginning.
	   */
	  public void Reset ()
	    {
	      next = 0;
	      current = null;
	    }
        }
    }
}