//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
// PLEASE DO NOT EDIT WITHOUT THE EXPLICIT CONSENT OF THE AUTHOR! \\
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
package hlt.language.util;
import java.util.Iterator;
import java.util.Collection;
/**
* This class implements a vector of primitive double elements
* to alleviate the need to use an ArrayList of Double
* wrappers. It implements all public members items of the
* java.util.ArrayList API that make sense when dealing with
* primitive double elements rather than Objects.
*
*
*
* Like java.util.ArrayList, its underlying representation can
* grow dynamically. As well, it is not synchronized.
*
* @version Last modified on Tue Apr 30 07:02:11 2019 by hak
* @author Hassan Aït-Kaci
* @copyright © Hassan Aït-Kaci
*/
public class DoubleArrayList
{
// FIELDS:
/**
* The array buffer into which the components of the DoubleArrayList
* are stored. The capacity of the DoubleArrayList is the length of
* this array buffer, and is at least large enough to contain all the
* DoubleArrayList's elements.
*/
protected double[] elementData;
/**
* The number of valid components in this DoubleArrayList
* object. Components elementData[0] through
* elementData[elementCount-1] are the actual items.
*/
protected int elementCount;
/**
* The amount by which the capacity of the DoubleArrayList 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 DoubleArrayList is multiplied by
* incrementFactor each time it needs to grow. The default value of
* incrementFactor is 2.0 (so growing doubles the
* capacity). It may be reset with setIncrementFactor(float) to any
* decimal value between 1.1 and 5.0.
*/
protected int capacityIncrement;
// CONSTRUCTORS:
/**
* Constructs an empty DoubleArrayList with the specified initial
* capacity and capacity increment.
*
* @param initialCapacity the initial capacity of the DoubleArrayList.
* @param capacityIncrement amount by which the capacity is increased on overflow.
* @exception NegativeArraySizeException if the specified initial capacity is negative.
*/
public DoubleArrayList (int initialCapacity, int capacityIncrement)
{
this(initialCapacity);
this.capacityIncrement = capacityIncrement;
}
/**
* Constructs an empty DoubleArrayList with the specified initial capacity and
* with its capacity increment equal to zero.
*
* @param initialCapacity the initial capacity of the DoubleArrayList.
* @exception NegativeArraySizeException if the specified initial capacity is negative.
*/
public DoubleArrayList (int initialCapacity)
{
elementData = new double[initialCapacity];
}
/**
* Constructs an empty DoubleArrayList so that its internal data
* array has size 10 and its standard capacity increment is zero.
*/
public DoubleArrayList ()
{
this(10);
}
/**
* Constructs a doubleArrayList containing the values contained in the
* specified array, in the same order.
*
* @param a an array of doubles.
*/
public DoubleArrayList (double[] a)
{
elementData = new double[a.length];
for (int i=0; iDoubleArrayList containing the doubleValue() values of the
* java.lang.Number objects in the specified collection, in the
* order they are returned by the collection's iterator. If any
* object in the collection is not an instance of java.lang.Number,
* a ClassCastException exception is thrown.
*
* @param c the collection whose elements are to be placed into this DoubleArrayList.
* @exception ClassCastException if the collection contains a non-number.
*/
public DoubleArrayList (Collection c)
{
elementData = new double[c.size()];
for (Iterator i=c.iterator(); i.hasNext();)
elementData[elementCount++] = ((Number)i.next()).doubleValue();
}
// METHODS:
/**
* Copies the components of this DoubleArrayList into the specified
* array. The item at index k in this DoubleArrayList is copied into
* component k of a. The array must be big enough to hold all the elements of
* this DoubleArrayList, else an IndexOutOfBoundsException
* is thrown.
*
* @param a the array into which the components get copied.
* @exception IndexOutOfBoundsException if the array is too small.
*/
public final void copyInto (double[] a)
{
for (int i=0; iDoubleArrayList to be the
* DoubleArrayList's current size. If the capacity of this
* DoubleArrayList 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 elementData, with a smaller one. An application
* can use this operation to minimize the storage of a
* DoubleArrayList.
*/
public final void trimToSize ()
{
if (elementCount == elementData.length) return;
double[] newArray = newArray = new double[elementCount];
for (int i=0; iDoubleArrayList, if
* necessary, to ensure that it can hold at least the number of
* components specified by the minimum capacity argument. If the
* current capacity of this DoubleArrayList is less than
* minCapacity, then its capacity is increased by replacing its
* internal data array, kept in the field elementData, with a larger
* one. The size of the new data array will be the old size plus
* capacityIncrement, unless the value of
* capacityIncrement is less than or equal to zero, in which
* case the new capacity will be the old capacity multiplied by
* incrementFactor; but if this new size is still smaller
* than minCapacity, then the new capacity will be
* minCapacity.
*
* @param minCapacity the desired minimum capacity.
*/
public final void ensureCapacity (int minCapacity)
{
// System.out.println("+++ ensuring capacity ("+elementData.length+") is more than "+minCapacity);
if (elementData.length > minCapacity+1)
//{
//System.out.println("+++ yes it is");
return;
//}
// System.out.println("+++ no it is not");
// System.out.println("+++ reallocating capaciting of "+(Math.max(minCapacity,_increasedCapacity())));
double[] newArray = new double[Math.max(minCapacity,_increasedCapacity())];
for (int i=0; iDoubleArrayList. If the new size is greater than the
* current size, new zeroes are added to the end of the DoubleArrayList.
*
* @param newSize the new size of this DoubleArrayList.
*/
public final void setSize (int newSize)
{
ensureCapacity(elementCount = newSize);
}
/**
* Returns the current capacity of this DoubleArrayList.
*
* @return the current capacity the length of its internal data array.
*/
public final int capacity ()
{
return elementData.length;
}
/**
* Returns the number of components in this DoubleArrayList.
*
* @return the number of components in this DoubleArrayList.
*/
public final int size ()
{
return elementCount;
}
/**
* Tests if this DoubleArrayList has no components.
*
* @return true if this DoubleArrayList's size is zero; false otherwise.
*/
public final boolean isEmpty ()
{
return elementCount == 0;
}
/**
* Tests if the specified double is a component in this DoubleArrayList.
*
* @param element a double.
* @return true if the specified double is in this DoubleArrayList; false otherwise.
*/
public final boolean contains (double element)
{
for (int i=0; iDoubleArrayList; returns -1 if it is not found.
*
* @param element the desired component.
* @return the index of the last occurrence of the specified double, or -1.
*/
public final int lastIndexOf (double element)
{
for (int i=elementCount; i-->0;)
if (elementData[i] == element) return i;
return -1;
}
/**
* Searches backwards for the specified double, starting from the
* specified index, and returns its index, or -1 if not found.
*
* @param element a double.
* @param index the non-negative index to start searching from.
* @return the index of the last occurrence before the specified index of the specified double, or -1 if not found
* @exception IndexOutOfBoundsException if index is invalid.
*/
public final int lastIndexOf (double element, int index)
{
for (int i=index; i>=0; i--)
if (elementData[i] == 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 DoubleArrayList.
* @return the double at given index
* @exception ArrayIndexOutOfBoundsException if the index is invalid.
*/
public final double elementAt (int index)
{
return get(index);
}
/**
* Returns the first component (the item at index 0) of this DoubleArrayList.
*
* @return the first component of this DoubleArrayList.
* @exception ArrayIndexOutOfBoundsException if this DoubleArrayList is empty.
*/
public final double firstElement ()
{
return elementData[0];
}
/**
* Returns the last component of the DoubleArrayList.
*
* @return the last component of the DoubleArrayList, i.e., the component at size() - 1.
* @exception ArrayIndexOutOfBoundsException if this DoubleArrayList is empty.
*/
public final double lastElement ()
{
return elementData[elementCount-1];
}
/**
* Sets the component at the specified index of this DoubleArrayList to be the
* specified double. The previous component at that position is lost.
*
* The index must be a value greater than or equal to 0 and less than
* the current size of the DoubleArrayList.
*
* This method is identical in functionality to the set method except
* that the latter returns the old value 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 ArrayIndexOutOfBoundsException if the index was invalid.
*/
public final void setElementAt (double element, int index)
{
set(index,element);
}
/**
* Deletes the component at the specified index. Each component in
* this DoubleArrayList 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 DoubleArrayList is decreased by 1.
*
* The index must be a value greater than or equal to 0 and less than
* the current size of the DoubleArrayList.
*
* 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 double to remove.
* @exception ArrayIndexOutOfBoundsException if the index was invalid.
*/
public final void removeElementAt (int index)
{
remove(index);
}
/**
* Inserts the specified double as a component in this DoubleArrayList at the
* specified index. Each component in this DoubleArrayList 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.
*
* The index must be a value greater than or equal to 0 and less than
* or equal to the current size of the DoubleArrayList. (If the index is equal
* to the current size of the DoubleArrayList, the new element is appended to
* the DoubleArrayList.)
*
* This method is identical in functionality to the add(int, double)
* 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 ArrayIndexOutOfBoundsException if the index was invalid.
*/
public final void insertElementAt (double element, int index)
{
add(index,element);
}
/**
* Adds the specified component to the end of this DoubleArrayList, increasing
* its size by one. The capacity of this DoubleArrayList is increased if its
* size becomes greater than its capacity.
*
* This method is identical in functionality to the add(double) method
* except that the latter returns a boolean.
*
* @param element the component to be added.
*/
public final void addElement (double element)
{
add(element);
}
/**
* Removes all components from this DoubleArrayList.
* This method is identical in functionality to the clear method.
*
*/
public final void removeAllElements ()
{
elementCount = 0;
}
/**
* Returns a clone of this DoubleArrayList. 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 DoubleArrayList object.
*
* @return a clone of this DoubleArrayList.
*/
public final Object clone ()
{
double[] newArray = new double[elementData.length];
for (int i=0; iDoubleArrayList in the correct order
*/
public final double[] toArray ()
{
double[] a = new double[elementCount];
for (int i=0; iDoubleArrayList.
* @exception ArrayIndexOutOfBoundsException if the index is invalid.
*/
public final double get (int index)
{
return elementData[index];
}
/**
* Replaces the element at the specified position in this DoubleArrayList 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 ArrayIndexOutOfBoundsException if index is out of range.
*/
public final double set (int index, double element)
{
double old = elementData[index];
elementData[index] = element;
return old;
}
/**
* Replaces the element at the last position in this DoubleArrayList with
* the specified element.
*
* @param element element to be stored at the last position.
* @exception ArrayIndexOutOfBoundsException if index is out of range.
*/
public final void setLast (double element)
{
elementData[elementCount-1] = element;
}
/**
* Appends the specified element to the end of this DoubleArrayList.
*
* @param element element to be appended to this DoubleArrayList.
* @return true (following the java.util.ArrayList API).
*/
public final boolean add (double element)
{
if (elementCount == elementData.length) _grow();
elementData[elementCount++] = element;
return true;
}
/**
* Removes the first occurrence of the specified element. If this
* DoubleArrayList does not contain the element, it is left unchanged.
* N.B.Because remove(double) is ambiguous, it is
* not supported for DoubleArrayLists; its functionality is
* provided by removeIndex(int) and
* removeElement(double).
*
* @param element element to be removed from this DoubleArrayList, if present.
* @return true if this DoubleArrayList contained the specified element.
*/
public final boolean remove (double element)
{
int i = 0;
for (i=0; iDoubleArrayList does not contain the element, it is left
* unchanged. Note that this method is identical to remove(double).
*
* @param element element to be removed from this DoubleArrayList, if present.
* @return true if this DoubleArrayList contained the specified element.
*/
public final boolean removeElement (double element)
{
return remove(element);
}
/**
* Inserts the specified element at the specified position in this
* DoubleArrayList. 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 ArrayIndexOutOfBoundsException if index is out of range.
*/
public final void add (int index, double element)
{
ensureCapacity(elementCount++);
// System.out.println("+++ adding element "+element+" at index "+index);
for (int i=elementCount-1; i>index; i--)
elementData[i] = elementData[i-1];
elementData[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 ArrayIndexOutOfBoundsException if index is out of range.
*/
public final double remove (int index)
{
double old = elementData[index];
for (int i=index; iDoubleArrayList.
*/
public final void clear ()
{
elementCount = 0;
}
/**
* Returns true if this DoubleArrayList 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 final boolean containsAll (double[] a)
{
for (int i=0; iDoubleArrayList contains all of the elements in the
* specified DoubleArrayList.
*
* @param v DoubleArrayList of elements to be tested for membership.
* @return true if all of the elements of the specified collection belong in this.
*/
public final boolean containsAll (DoubleArrayList v)
{
for (int i=v.size(); i-->0;)
if (!contains(v.get(i))) return false;
return true;
}
/**
* Appends all of the elements in the specified array to the end
* of this DoubleArrayList, 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 java.util.ArrayList API).
*/
public final boolean addAll (double[] a)
{
ensureCapacity(elementCount+a.length);
for (int i=0; iDoubleArrayList to the end
* of this DoubleArrayList.
*
* @param v the DoubleArrayList of elements to be added.
* @return true (following the java.util.ArrayList API).
*/
public final boolean addAll (DoubleArrayList v)
{
int size = v.size();
ensureCapacity(elementCount+size);
for (int i=0; iDoubleArrayList 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 DoubleArrayList changed as a result of the call.
*/
public final boolean removeAll (double[] a)
{
IntArrayList indices = new IntArrayList();
for (int i=0; iDoubleArrayList all of its elements that are contained
* in the specified DoubleArrayList. Note that all occurrences of such elemeents
* are removed - not just the first.
*
* @param v the DoubleArrayList of elements to be removed.
* @return true if this DoubleArrayList changed as a result of the call.
*/
public final boolean removeAll (DoubleArrayList v)
{
IntArrayList indices = new IntArrayList();
for (int i=v.size(); i-->0;)
for (int j=elementCount; j-->0;)
if (v.get(i) == elementData[j]) indices.add(j);
removeAllIndices(indices);
return !indices.isEmpty();
}
/**
* Removes from this DoubleArrayList 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 DoubleArrayList changed as a result of the call.
*/
public final boolean removeAllFirst (double[] a)
{
IntArrayList indices = new IntArrayList();
for (int i=0; iDoubleArrayList the first occurrence of the elements
* that are contained in the specified DoubleArrayList.
*
* @param v the DoubleArrayList of elements to be removed.
* @return true if this DoubleArrayList changed as a result of the call.
*/
public final boolean removeAllFirst (DoubleArrayList v)
{
IntArrayList indices = new IntArrayList();
int size = v.size();
for (int i=0; iDoubleArrayList whose elements are
* contained in the specified DoubleArrayList. In other words, removes from
* this DoubleArrayList all of its elements that are not contained in the
* specified DoubleArrayList.
*
* @param v DoubleArrayList of elements to be retained.
* @return true if this DoubleArrayList changed as a result of the call.
*/
public final boolean retainAll (DoubleArrayList v)
{
IntArrayList indices = new IntArrayList();
for (int i=0; iDoubleArrayList. 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 array of elements to be inserted.
* @exception ArrayIndexOutOfBoundsException if index is out of range.
*/
public final void addAll (int index, double[] a)
{
if (elementCount+a.length < elementData.length)
{
for (int i=index; iDoubleArrayList into this
* DoubleArrayList 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
* DoubleArrayList in their order in the specified DoubleArrayList.
*
* @param index index where to insert the first element
* @param v DoubleArrayList to be inserted into this DoubleArrayList.
* @exception ArrayIndexOutOfBoundsException if index is invalid.
*/
public final void addAll (int index, DoubleArrayList v)
{
int size = v.size();
if (elementCount+size < elementData.length)
{
for (int i=index; iDoubleArrayList for equality.
* Returns true if and only if the specified object is also an
* DoubleArrayList, both have the same size, and all corresponding pairs of
* elements are equal. In other words, two DoubleArrayLists are defined to
* be equal if they contain the same elements in the same order.
*
* @param o the object to be compared for equality with this DoubleArrayList.
* @return true if the specified object is equal to this DoubleArrayList
*/
public final boolean equals (Object o)
{
if (o == this)
return true;
if (!(o instanceof DoubleArrayList))
return false;
DoubleArrayList other = (DoubleArrayList)o;
if (other.size() != elementCount)
return false;
for (int i=0; iDoubleArrayList.
*/
public int hashCode ()
{
long code = elementCount;
int shift = 1;
for (int i=0; i 0)
code <<= 1;
else
code >>= 1;
code ^= Double.doubleToLongBits(elementData[i]);
shift = -shift;
}
return (int)code;
}
/**
* Returns a string representation of this DoubleArrayList
*
* @return a string representation of this collection.
*/
public String toString ()
{
StringBuilder buf = new StringBuilder("[");
for (int i=0; i
* N.B. Note that this method is public, whereas - strangely
* enough, it is protected in the java.util.ArrayList 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, elementCount);
int gap = toIndex - fromIndex;
for (int i=fromIndex; i 5.0)
throw new IllegalArgumentException("Increment factor "+incrementFactor
+" must be in [1.1,5.0] range");
this.incrementFactor = incrementFactor;
}
/**
* Clears all elements of this DoubleArraylist at index equal to or
* greater than the specified index. If this index value is out range,
* this clears all the DoubleArraylist.
*
* @param index the index above which clearing takes effect
*/
public final void clear (int index)
{
elementCount = (index < 0 || index >= elementCount) ? 0 : index;
}
// PRIVATES:
/**
* A constructor used privately for cloning only...
*/
private DoubleArrayList (double[] elementData, int elementCount,
int capacityIncrement, float incrementFactor)
{
this.elementData = elementData;
this.elementCount = elementCount;
this.capacityIncrement = capacityIncrement;
this.incrementFactor = incrementFactor;
}
/**
* Grows the size of the internal array.
*/
private final void _grow ()
{
double[] newArray = new double[_increasedCapacity()];
for (int i=0; iDoubleArrayList.
*
* @return the increased capacity
*/
private final int _increasedCapacity ()
{
if (capacityIncrement <= 0)
{
int capacity = elementData.length == 0 ? 1 : elementData.length;
// System.out.println("+++ new capacity: "+((int)Math.floor(capacity*incrementFactor+1)));
return (int)Math.floor(capacity*incrementFactor+1);
}
// System.out.println("+++ new capacity: "+(elementData.length+capacityIncrement));
return elementData.length+capacityIncrement;
}
/**
* Computes a greater capacity for this DoubleArrayList that
* is at least the specified capacity.
*
* @param minCapacity the minimum necessary capacity.
* @return the increased capacity
*/
private final int _increasedCapacity (int minCapacity)
{
if (capacityIncrement <= 0)
{
int capacity = elementData.length == 0 ? 1 : elementData.length;
return Math.max(minCapacity,
(int)Math.floor(capacity*incrementFactor));
}
return Math.max(minCapacity,elementData.length+capacityIncrement);
}
/**
* Removes from this DoubleArrayList all of its elements that are located at
* the indices in the specified DoubleArrayList. This assumes that the indices
* appear sorted in increasing order.
*
* @param indices indices of elements to be removed.
*/
private final void removeAllIndices (IntArrayList indices)
{
int size = indices.size();
for (int i=1; i<=size; i++)
{
int lo = indices.get(i-1);
int hi = (i < size) ? indices.get(i) : elementCount;
for (int j=lo+1; j