diff options
Diffstat (limited to 'src/main/java/org/apache/commons/math/util/ResizableDoubleArray.java')
| -rw-r--r-- | src/main/java/org/apache/commons/math/util/ResizableDoubleArray.java | 936 |
1 files changed, 936 insertions, 0 deletions
diff --git a/src/main/java/org/apache/commons/math/util/ResizableDoubleArray.java b/src/main/java/org/apache/commons/math/util/ResizableDoubleArray.java new file mode 100644 index 0000000..b33f288 --- /dev/null +++ b/src/main/java/org/apache/commons/math/util/ResizableDoubleArray.java @@ -0,0 +1,936 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.commons.math.util; + +import java.io.Serializable; +import java.util.Arrays; + +import org.apache.commons.math.MathRuntimeException; +import org.apache.commons.math.exception.util.LocalizedFormats; + +/** + * <p> + * A variable length {@link DoubleArray} implementation that automatically + * handles expanding and contracting its internal storage array as elements + * are added and removed. + * </p> + * <p> + * The internal storage array starts with capacity determined by the + * <code>initialCapacity</code> property, which can be set by the constructor. + * The default initial capacity is 16. Adding elements using + * {@link #addElement(double)} appends elements to the end of the array. When + * there are no open entries at the end of the internal storage array, the + * array is expanded. The size of the expanded array depends on the + * <code>expansionMode</code> and <code>expansionFactor</code> properties. + * The <code>expansionMode</code> determines whether the size of the array is + * multiplied by the <code>expansionFactor</code> (MULTIPLICATIVE_MODE) or if + * the expansion is additive (ADDITIVE_MODE -- <code>expansionFactor</code> + * storage locations added). The default <code>expansionMode</code> is + * MULTIPLICATIVE_MODE and the default <code>expansionFactor</code> + * is 2.0. + * </p> + * <p> + * The {@link #addElementRolling(double)} method adds a new element to the end + * of the internal storage array and adjusts the "usable window" of the + * internal array forward by one position (effectively making what was the + * second element the first, and so on). Repeated activations of this method + * (or activation of {@link #discardFrontElements(int)}) will effectively orphan + * the storage locations at the beginning of the internal storage array. To + * reclaim this storage, each time one of these methods is activated, the size + * of the internal storage array is compared to the number of addressable + * elements (the <code>numElements</code> property) and if the difference + * is too large, the internal array is contracted to size + * <code>numElements + 1.</code> The determination of when the internal + * storage array is "too large" depends on the <code>expansionMode</code> and + * <code>contractionFactor</code> properties. If the <code>expansionMode</code> + * is <code>MULTIPLICATIVE_MODE</code>, contraction is triggered when the + * ratio between storage array length and <code>numElements</code> exceeds + * <code>contractionFactor.</code> If the <code>expansionMode</code> + * is <code>ADDITIVE_MODE,</code> the number of excess storage locations + * is compared to <code>contractionFactor.</code> + * </p> + * <p> + * To avoid cycles of expansions and contractions, the + * <code>expansionFactor</code> must not exceed the + * <code>contractionFactor.</code> Constructors and mutators for both of these + * properties enforce this requirement, throwing IllegalArgumentException if it + * is violated. + * </p> + * @version $Revision: 1073474 $ $Date: 2011-02-22 20:52:17 +0100 (mar. 22 févr. 2011) $ + */ +public class ResizableDoubleArray implements DoubleArray, Serializable { + + /** additive expansion mode */ + public static final int ADDITIVE_MODE = 1; + + /** multiplicative expansion mode */ + public static final int MULTIPLICATIVE_MODE = 0; + + /** Serializable version identifier */ + private static final long serialVersionUID = -3485529955529426875L; + + /** + * The contraction criteria determines when the internal array will be + * contracted to fit the number of elements contained in the element + * array + 1. + */ + protected float contractionCriteria = 2.5f; + + /** + * The expansion factor of the array. When the array needs to be expanded, + * the new array size will be + * <code>internalArray.length * expansionFactor</code> + * if <code>expansionMode</code> is set to MULTIPLICATIVE_MODE, or + * <code>internalArray.length + expansionFactor</code> if + * <code>expansionMode</code> is set to ADDITIVE_MODE. + */ + protected float expansionFactor = 2.0f; + + /** + * Determines whether array expansion by <code>expansionFactor</code> + * is additive or multiplicative. + */ + protected int expansionMode = MULTIPLICATIVE_MODE; + + /** + * The initial capacity of the array. Initial capacity is not exposed as a + * property as it is only meaningful when passed to a constructor. + */ + protected int initialCapacity = 16; + + /** + * The internal storage array. + */ + protected double[] internalArray; + + /** + * The number of addressable elements in the array. Note that this + * has nothing to do with the length of the internal storage array. + */ + protected int numElements = 0; + + /** + * The position of the first addressable element in the internal storage + * array. The addressable elements in the array are <code> + * internalArray[startIndex],...,internalArray[startIndex + numElements -1] + * </code> + */ + protected int startIndex = 0; + + /** + * Create a ResizableArray with default properties. + * <ul> + * <li><code>initialCapacity = 16</code></li> + * <li><code>expansionMode = MULTIPLICATIVE_MODE</code></li> + * <li><code>expansionFactor = 2.5</code></li> + * <li><code>contractionFactor = 2.0</code></li> + * </ul> + */ + public ResizableDoubleArray() { + internalArray = new double[initialCapacity]; + } + + /** + * Create a ResizableArray with the specified initial capacity. Other + * properties take default values: + * <ul> + * <li><code>expansionMode = MULTIPLICATIVE_MODE</code></li> + * <li><code>expansionFactor = 2.5</code></li> + * <li><code>contractionFactor = 2.0</code></li> + * </ul> + * @param initialCapacity The initial size of the internal storage array + * @throws IllegalArgumentException if initialCapacity is not > 0 + */ + public ResizableDoubleArray(int initialCapacity) { + setInitialCapacity(initialCapacity); + internalArray = new double[this.initialCapacity]; + } + + /** + * Create a ResizableArray from an existing double[] with the + * initial capacity and numElements corresponding to the size of + * the supplied double[] array. If the supplied array is null, a + * new empty array with the default initial capacity will be created. + * The input array is copied, not referenced. + * Other properties take default values: + * <ul> + * <li><code>initialCapacity = 16</code></li> + * <li><code>expansionMode = MULTIPLICATIVE_MODE</code></li> + * <li><code>expansionFactor = 2.5</code></li> + * <li><code>contractionFactor = 2.0</code></li> + * </ul> + * + * @param initialArray initial array + * @since 2.2 + */ + public ResizableDoubleArray(double[] initialArray) { + if (initialArray == null) { + this.internalArray = new double[initialCapacity]; + } else { + this.internalArray = new double[initialArray.length]; + System.arraycopy(initialArray, 0, this.internalArray, 0, initialArray.length); + initialCapacity = initialArray.length; + numElements = initialArray.length; + } + } + + /** + * <p> + * Create a ResizableArray with the specified initial capacity + * and expansion factor. The remaining properties take default + * values: + * <ul> + * <li><code>expansionMode = MULTIPLICATIVE_MODE</code></li> + * <li><code>contractionFactor = 0.5 + expansionFactor</code></li> + * </ul></p> + * <p> + * Throws IllegalArgumentException if the following conditions are + * not met: + * <ul> + * <li><code>initialCapacity > 0</code></li> + * <li><code>expansionFactor > 1</code></li> + * </ul></p> + * + * @param initialCapacity The initial size of the internal storage array + * @param expansionFactor the array will be expanded based on this + * parameter + * @throws IllegalArgumentException if parameters are not valid + */ + public ResizableDoubleArray(int initialCapacity, float expansionFactor) { + this.expansionFactor = expansionFactor; + setInitialCapacity(initialCapacity); + internalArray = new double[initialCapacity]; + setContractionCriteria(expansionFactor +0.5f); + } + + /** + * <p> + * Create a ResizableArray with the specified initialCapacity, + * expansionFactor, and contractionCriteria. The <code>expansionMode</code> + * will default to <code>MULTIPLICATIVE_MODE.</code></p> + * <p> + * Throws IllegalArgumentException if the following conditions are + * not met: + * <ul> + * <li><code>initialCapacity > 0</code></li> + * <li><code>expansionFactor > 1</code></li> + * <li><code>contractionFactor >= expansionFactor</code></li> + * </ul></p> + * @param initialCapacity The initial size of the internal storage array + * @param expansionFactor the array will be expanded based on this + * parameter + * @param contractionCriteria The contraction Criteria. + * @throws IllegalArgumentException if parameters are not valid + */ + public ResizableDoubleArray(int initialCapacity, float expansionFactor, + float contractionCriteria) { + this.expansionFactor = expansionFactor; + setContractionCriteria(contractionCriteria); + setInitialCapacity(initialCapacity); + internalArray = new double[initialCapacity]; + } + + /** + * <p> + * Create a ResizableArray with the specified properties.</p> + * <p> + * Throws IllegalArgumentException if the following conditions are + * not met: + * <ul> + * <li><code>initialCapacity > 0</code></li> + * <li><code>expansionFactor > 1</code></li> + * <li><code>contractionFactor >= expansionFactor</code></li> + * <li><code>expansionMode in {MULTIPLICATIVE_MODE, ADDITIVE_MODE}</code> + * </li> + * </ul></p> + * + * @param initialCapacity the initial size of the internal storage array + * @param expansionFactor the array will be expanded based on this + * parameter + * @param contractionCriteria the contraction Criteria + * @param expansionMode the expansion mode + * @throws IllegalArgumentException if parameters are not valid + */ + public ResizableDoubleArray(int initialCapacity, float expansionFactor, + float contractionCriteria, int expansionMode) { + this.expansionFactor = expansionFactor; + setContractionCriteria(contractionCriteria); + setInitialCapacity(initialCapacity); + setExpansionMode(expansionMode); + internalArray = new double[initialCapacity]; + } + + /** + * Copy constructor. Creates a new ResizableDoubleArray that is a deep, + * fresh copy of the original. Needs to acquire synchronization lock + * on original. Original may not be null; otherwise a NullPointerException + * is thrown. + * + * @param original array to copy + * @since 2.0 + */ + public ResizableDoubleArray(ResizableDoubleArray original) { + copy(original, this); + } + + /** + * Adds an element to the end of this expandable array. + * + * @param value to be added to end of array + */ + public synchronized void addElement(double value) { + numElements++; + if ((startIndex + numElements) > internalArray.length) { + expand(); + } + internalArray[startIndex + (numElements - 1)] = value; + if (shouldContract()) { + contract(); + } + } + + /** + * Adds several element to the end of this expandable array. + * + * @param values to be added to end of array + * @since 2.2 + */ + public synchronized void addElements(double[] values) { + final double[] tempArray = new double[numElements + values.length + 1]; + System.arraycopy(internalArray, startIndex, tempArray, 0, numElements); + System.arraycopy(values, 0, tempArray, numElements, values.length); + internalArray = tempArray; + startIndex = 0; + numElements += values.length; + } + + /** + * <p> + * Adds an element to the end of the array and removes the first + * element in the array. Returns the discarded first element. + * The effect is similar to a push operation in a FIFO queue. + * </p> + * <p> + * Example: If the array contains the elements 1, 2, 3, 4 (in that order) + * and addElementRolling(5) is invoked, the result is an array containing + * the entries 2, 3, 4, 5 and the value returned is 1. + * </p> + * + * @param value the value to be added to the array + * @return the value which has been discarded or "pushed" out of the array + * by this rolling insert + */ + public synchronized double addElementRolling(double value) { + double discarded = internalArray[startIndex]; + + if ((startIndex + (numElements + 1)) > internalArray.length) { + expand(); + } + // Increment the start index + startIndex += 1; + + // Add the new value + internalArray[startIndex + (numElements - 1)] = value; + + // Check the contraction criteria + if (shouldContract()) { + contract(); + } + return discarded; + } + + /** + * Substitutes <code>value</code> for the most recently added value. + * Returns the value that has been replaced. If the array is empty (i.e. + * if {@link #numElements} is zero), a MathRuntimeException is thrown. + * + * @param value new value to substitute for the most recently added value + * @return value that has been replaced in the array + * @since 2.0 + */ + public synchronized double substituteMostRecentElement(double value) { + if (numElements < 1) { + throw MathRuntimeException.createArrayIndexOutOfBoundsException( + LocalizedFormats.CANNOT_SUBSTITUTE_ELEMENT_FROM_EMPTY_ARRAY); + } + + double discarded = internalArray[startIndex + (numElements - 1)]; + + internalArray[startIndex + (numElements - 1)] = value; + + return discarded; + } + + + /** + * Checks the expansion factor and the contraction criteria and throws an + * IllegalArgumentException if the contractionCriteria is less than the + * expansionCriteria + * + * @param expansion factor to be checked + * @param contraction criteria to be checked + * @throws IllegalArgumentException if the contractionCriteria is less than + * the expansionCriteria. + */ + protected void checkContractExpand(float contraction, float expansion) { + + if (contraction < expansion) { + throw MathRuntimeException.createIllegalArgumentException( + LocalizedFormats.CONTRACTION_CRITERIA_SMALLER_THAN_EXPANSION_FACTOR, + contraction, expansion); + } + + if (contraction <= 1.0) { + throw MathRuntimeException.createIllegalArgumentException( + LocalizedFormats.CONTRACTION_CRITERIA_SMALLER_THAN_ONE, + contraction); + } + + if (expansion <= 1.0) { + throw MathRuntimeException.createIllegalArgumentException( + LocalizedFormats.EXPANSION_FACTOR_SMALLER_THAN_ONE, + expansion); + } + } + + /** + * Clear the array, reset the size to the initialCapacity and the number + * of elements to zero. + */ + public synchronized void clear() { + numElements = 0; + startIndex = 0; + internalArray = new double[initialCapacity]; + } + + /** + * Contracts the storage array to the (size of the element set) + 1 - to + * avoid a zero length array. This function also resets the startIndex to + * zero. + */ + public synchronized void contract() { + double[] tempArray = new double[numElements + 1]; + + // Copy and swap - copy only the element array from the src array. + System.arraycopy(internalArray, startIndex, tempArray, 0, numElements); + internalArray = tempArray; + + // Reset the start index to zero + startIndex = 0; + } + + /** + * Discards the <code>i<code> initial elements of the array. For example, + * if the array contains the elements 1,2,3,4, invoking + * <code>discardFrontElements(2)</code> will cause the first two elements + * to be discarded, leaving 3,4 in the array. Throws illegalArgumentException + * if i exceeds numElements. + * + * @param i the number of elements to discard from the front of the array + * @throws IllegalArgumentException if i is greater than numElements. + * @since 2.0 + */ + public synchronized void discardFrontElements(int i) { + + discardExtremeElements(i,true); + + } + + /** + * Discards the <code>i<code> last elements of the array. For example, + * if the array contains the elements 1,2,3,4, invoking + * <code>discardMostRecentElements(2)</code> will cause the last two elements + * to be discarded, leaving 1,2 in the array. Throws illegalArgumentException + * if i exceeds numElements. + * + * @param i the number of elements to discard from the end of the array + * @throws IllegalArgumentException if i is greater than numElements. + * @since 2.0 + */ + public synchronized void discardMostRecentElements(int i) { + + discardExtremeElements(i,false); + + } + + /** + * Discards the <code>i<code> first or last elements of the array, + * depending on the value of <code>front</code>. + * For example, if the array contains the elements 1,2,3,4, invoking + * <code>discardExtremeElements(2,false)</code> will cause the last two elements + * to be discarded, leaving 1,2 in the array. + * For example, if the array contains the elements 1,2,3,4, invoking + * <code>discardExtremeElements(2,true)</code> will cause the first two elements + * to be discarded, leaving 3,4 in the array. + * Throws illegalArgumentException + * if i exceeds numElements. + * + * @param i the number of elements to discard from the front/end of the array + * @param front true if elements are to be discarded from the front + * of the array, false if elements are to be discarded from the end + * of the array + * @throws IllegalArgumentException if i is greater than numElements. + * @since 2.0 + */ + private synchronized void discardExtremeElements(int i,boolean front) { + if (i > numElements) { + throw MathRuntimeException.createIllegalArgumentException( + LocalizedFormats.TOO_MANY_ELEMENTS_TO_DISCARD_FROM_ARRAY, + i, numElements); + } else if (i < 0) { + throw MathRuntimeException.createIllegalArgumentException( + LocalizedFormats.CANNOT_DISCARD_NEGATIVE_NUMBER_OF_ELEMENTS, + i); + } else { + // "Subtract" this number of discarded from numElements + numElements -= i; + if (front) startIndex += i; + } + if (shouldContract()) { + contract(); + } + } + + /** + * Expands the internal storage array using the expansion factor. + * <p> + * if <code>expansionMode</code> is set to MULTIPLICATIVE_MODE, + * the new array size will be <code>internalArray.length * expansionFactor.</code> + * If <code>expansionMode</code> is set to ADDITIVE_MODE, the length + * after expansion will be <code>internalArray.length + expansionFactor</code> + * </p> + */ + protected synchronized void expand() { + + // notice the use of FastMath.ceil(), this guarantees that we will always + // have an array of at least currentSize + 1. Assume that the + // current initial capacity is 1 and the expansion factor + // is 1.000000000000000001. The newly calculated size will be + // rounded up to 2 after the multiplication is performed. + int newSize = 0; + if (expansionMode == MULTIPLICATIVE_MODE) { + newSize = (int) FastMath.ceil(internalArray.length * expansionFactor); + } else { + newSize = internalArray.length + FastMath.round(expansionFactor); + } + double[] tempArray = new double[newSize]; + + // Copy and swap + System.arraycopy(internalArray, 0, tempArray, 0, internalArray.length); + internalArray = tempArray; + } + + /** + * Expands the internal storage array to the specified size. + * + * @param size Size of the new internal storage array + */ + private synchronized void expandTo(int size) { + double[] tempArray = new double[size]; + // Copy and swap + System.arraycopy(internalArray, 0, tempArray, 0, internalArray.length); + internalArray = tempArray; + } + + /** + * The contraction criteria defines when the internal array will contract + * to store only the number of elements in the element array. + * If the <code>expansionMode</code> is <code>MULTIPLICATIVE_MODE</code>, + * contraction is triggered when the ratio between storage array length + * and <code>numElements</code> exceeds <code>contractionFactor</code>. + * If the <code>expansionMode</code> is <code>ADDITIVE_MODE</code>, the + * number of excess storage locations is compared to + * <code>contractionFactor.</code> + * + * @return the contraction criteria used to reclaim memory. + */ + public float getContractionCriteria() { + return contractionCriteria; + } + + /** + * Returns the element at the specified index + * + * @param index index to fetch a value from + * @return value stored at the specified index + * @throws ArrayIndexOutOfBoundsException if <code>index</code> is less than + * zero or is greater than <code>getNumElements() - 1</code>. + */ + public synchronized double getElement(int index) { + if (index >= numElements) { + throw MathRuntimeException.createArrayIndexOutOfBoundsException( + LocalizedFormats.INDEX_LARGER_THAN_MAX, + index, numElements - 1); + } else if (index >= 0) { + return internalArray[startIndex + index]; + } else { + throw MathRuntimeException.createArrayIndexOutOfBoundsException( + LocalizedFormats.CANNOT_RETRIEVE_AT_NEGATIVE_INDEX, + index); + } + } + + /** + * Returns a double array containing the elements of this + * <code>ResizableArray</code>. This method returns a copy, not a + * reference to the underlying array, so that changes made to the returned + * array have no effect on this <code>ResizableArray.</code> + * @return the double array. + */ + public synchronized double[] getElements() { + double[] elementArray = new double[numElements]; + System.arraycopy( internalArray, startIndex, elementArray, 0, + numElements); + return elementArray; + } + + /** + * The expansion factor controls the size of a new array when an array + * needs to be expanded. The <code>expansionMode</code> + * determines whether the size of the array is multiplied by the + * <code>expansionFactor</code> (MULTIPLICATIVE_MODE) or if + * the expansion is additive (ADDITIVE_MODE -- <code>expansionFactor</code> + * storage locations added). The default <code>expansionMode</code> is + * MULTIPLICATIVE_MODE and the default <code>expansionFactor</code> + * is 2.0. + * + * @return the expansion factor of this expandable double array + */ + public float getExpansionFactor() { + return expansionFactor; + } + + /** + * The <code>expansionMode</code> determines whether the internal storage + * array grows additively (ADDITIVE_MODE) or multiplicatively + * (MULTIPLICATIVE_MODE) when it is expanded. + * + * @return Returns the expansionMode. + */ + public int getExpansionMode() { + return expansionMode; + } + + /** + * Notice the package scope on this method. This method is simply here + * for the JUnit test, it allows us check if the expansion is working + * properly after a number of expansions. This is not meant to be a part + * of the public interface of this class. + * + * @return the length of the internal storage array. + */ + synchronized int getInternalLength() { + return internalArray.length; + } + + /** + * Returns the number of elements currently in the array. Please note + * that this is different from the length of the internal storage array. + * + * @return number of elements + */ + public synchronized int getNumElements() { + return numElements; + } + + /** + * Returns the internal storage array. Note that this method returns + * a reference to the internal storage array, not a copy, and to correctly + * address elements of the array, the <code>startIndex</code> is + * required (available via the {@link #start} method). This method should + * only be used in cases where copying the internal array is not practical. + * The {@link #getElements} method should be used in all other cases. + * + * + * @return the internal storage array used by this object + * @deprecated replaced by {@link #getInternalValues()} as of 2.0 + */ + @Deprecated + public synchronized double[] getValues() { + return internalArray; + } + + /** + * Returns the internal storage array. Note that this method returns + * a reference to the internal storage array, not a copy, and to correctly + * address elements of the array, the <code>startIndex</code> is + * required (available via the {@link #start} method). This method should + * only be used in cases where copying the internal array is not practical. + * The {@link #getElements} method should be used in all other cases. + * + * + * @return the internal storage array used by this object + * @since 2.0 + */ + public synchronized double[] getInternalValues() { + return internalArray; + } + + /** + * Sets the contraction criteria for this ExpandContractDoubleArray. + * + * @param contractionCriteria contraction criteria + */ + public void setContractionCriteria(float contractionCriteria) { + checkContractExpand(contractionCriteria, getExpansionFactor()); + synchronized(this) { + this.contractionCriteria = contractionCriteria; + } + } + + + /** + * Sets the element at the specified index. If the specified index is greater than + * <code>getNumElements() - 1</code>, the <code>numElements</code> property + * is increased to <code>index +1</code> and additional storage is allocated + * (if necessary) for the new element and all (uninitialized) elements + * between the new element and the previous end of the array). + * + * @param index index to store a value in + * @param value value to store at the specified index + * @throws ArrayIndexOutOfBoundsException if <code>index</code> is less than + * zero. + */ + public synchronized void setElement(int index, double value) { + if (index < 0) { + throw MathRuntimeException.createArrayIndexOutOfBoundsException( + LocalizedFormats.CANNOT_SET_AT_NEGATIVE_INDEX, + index); + } + if (index + 1 > numElements) { + numElements = index + 1; + } + if ((startIndex + index) >= internalArray.length) { + expandTo(startIndex + (index + 1)); + } + internalArray[startIndex + index] = value; + } + + /** + * Sets the expansionFactor. Throws IllegalArgumentException if the + * the following conditions are not met: + * <ul> + * <li><code>expansionFactor > 1</code></li> + * <li><code>contractionFactor >= expansionFactor</code></li> + * </ul> + * @param expansionFactor the new expansion factor value. + * @throws IllegalArgumentException if expansionFactor is <= 1 or greater + * than contractionFactor + */ + public void setExpansionFactor(float expansionFactor) { + checkContractExpand(getContractionCriteria(), expansionFactor); + // The check above verifies that the expansion factor is > 1.0; + synchronized(this) { + this.expansionFactor = expansionFactor; + } + } + + /** + * Sets the <code>expansionMode</code>. The specified value must be one of + * ADDITIVE_MODE, MULTIPLICATIVE_MODE. + * + * @param expansionMode The expansionMode to set. + * @throws IllegalArgumentException if the specified mode value is not valid + */ + public void setExpansionMode(int expansionMode) { + if (expansionMode != MULTIPLICATIVE_MODE && + expansionMode != ADDITIVE_MODE) { + throw MathRuntimeException.createIllegalArgumentException( + LocalizedFormats.UNSUPPORTED_EXPANSION_MODE, + expansionMode, MULTIPLICATIVE_MODE, "MULTIPLICATIVE_MODE", + ADDITIVE_MODE, "ADDITIVE_MODE"); + } + synchronized(this) { + this.expansionMode = expansionMode; + } + } + + /** + * Sets the initial capacity. Should only be invoked by constructors. + * + * @param initialCapacity of the array + * @throws IllegalArgumentException if <code>initialCapacity</code> is not + * positive. + */ + protected void setInitialCapacity(int initialCapacity) { + if (initialCapacity > 0) { + synchronized(this) { + this.initialCapacity = initialCapacity; + } + } else { + throw MathRuntimeException.createIllegalArgumentException( + LocalizedFormats.INITIAL_CAPACITY_NOT_POSITIVE, + initialCapacity); + } + } + + /** + * This function allows you to control the number of elements contained + * in this array, and can be used to "throw out" the last n values in an + * array. This function will also expand the internal array as needed. + * + * @param i a new number of elements + * @throws IllegalArgumentException if <code>i</code> is negative. + */ + public synchronized void setNumElements(int i) { + + // If index is negative thrown an error + if (i < 0) { + throw MathRuntimeException.createIllegalArgumentException( + LocalizedFormats.INDEX_NOT_POSITIVE, + i); + } + + // Test the new num elements, check to see if the array needs to be + // expanded to accommodate this new number of elements + if ((startIndex + i) > internalArray.length) { + expandTo(startIndex + i); + } + + // Set the new number of elements to new value + numElements = i; + } + + /** + * Returns true if the internal storage array has too many unused + * storage positions. + * + * @return true if array satisfies the contraction criteria + */ + private synchronized boolean shouldContract() { + if (expansionMode == MULTIPLICATIVE_MODE) { + return (internalArray.length / ((float) numElements)) > contractionCriteria; + } else { + return (internalArray.length - numElements) > contractionCriteria; + } + } + + /** + * Returns the starting index of the internal array. The starting index is + * the position of the first addressable element in the internal storage + * array. The addressable elements in the array are <code> + * internalArray[startIndex],...,internalArray[startIndex + numElements -1] + * </code> + * + * @return starting index + */ + public synchronized int start() { + return startIndex; + } + + /** + * <p>Copies source to dest, copying the underlying data, so dest is + * a new, independent copy of source. Does not contract before + * the copy.</p> + * + * <p>Obtains synchronization locks on both source and dest + * (in that order) before performing the copy.</p> + * + * <p>Neither source nor dest may be null; otherwise a NullPointerException + * is thrown</p> + * + * @param source ResizableDoubleArray to copy + * @param dest ResizableArray to replace with a copy of the source array + * @since 2.0 + * + */ + public static void copy(ResizableDoubleArray source, ResizableDoubleArray dest) { + synchronized(source) { + synchronized(dest) { + dest.initialCapacity = source.initialCapacity; + dest.contractionCriteria = source.contractionCriteria; + dest.expansionFactor = source.expansionFactor; + dest.expansionMode = source.expansionMode; + dest.internalArray = new double[source.internalArray.length]; + System.arraycopy(source.internalArray, 0, dest.internalArray, + 0, dest.internalArray.length); + dest.numElements = source.numElements; + dest.startIndex = source.startIndex; + } + } + } + + /** + * Returns a copy of the ResizableDoubleArray. Does not contract before + * the copy, so the returned object is an exact copy of this. + * + * @return a new ResizableDoubleArray with the same data and configuration + * properties as this + * @since 2.0 + */ + public synchronized ResizableDoubleArray copy() { + ResizableDoubleArray result = new ResizableDoubleArray(); + copy(this, result); + return result; + } + + /** + * Returns true iff object is a ResizableDoubleArray with the same properties + * as this and an identical internal storage array. + * + * @param object object to be compared for equality with this + * @return true iff object is a ResizableDoubleArray with the same data and + * properties as this + * @since 2.0 + */ + @Override + public boolean equals(Object object) { + if (object == this ) { + return true; + } + if (object instanceof ResizableDoubleArray == false) { + return false; + } + synchronized(this) { + synchronized(object) { + boolean result = true; + ResizableDoubleArray other = (ResizableDoubleArray) object; + result = result && (other.initialCapacity == initialCapacity); + result = result && (other.contractionCriteria == contractionCriteria); + result = result && (other.expansionFactor == expansionFactor); + result = result && (other.expansionMode == expansionMode); + result = result && (other.numElements == numElements); + result = result && (other.startIndex == startIndex); + if (!result) { + return false; + } else { + return Arrays.equals(internalArray, other.internalArray); + } + } + } + } + + /** + * Returns a hash code consistent with equals. + * + * @return hash code representing this ResizableDoubleArray + * @since 2.0 + */ + @Override + public synchronized int hashCode() { + int[] hashData = new int[7]; + hashData[0] = new Float(expansionFactor).hashCode(); + hashData[1] = new Float(contractionCriteria).hashCode(); + hashData[2] = expansionMode; + hashData[3] = Arrays.hashCode(internalArray); + hashData[4] = initialCapacity; + hashData[5] = numElements; + hashData[6] = startIndex; + return Arrays.hashCode(hashData); + } + +} |