You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by tn...@apache.org on 2015/03/10 23:17:48 UTC
[math] [MATH-757] Removed broken and deprecated synchronization
support in ResizableDoubleArray.
Repository: commons-math
Updated Branches:
refs/heads/master fbf5a51ea -> 76b7413d2
[MATH-757] Removed broken and deprecated synchronization support in ResizableDoubleArray.
Project: http://git-wip-us.apache.org/repos/asf/commons-math/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-math/commit/76b7413d
Tree: http://git-wip-us.apache.org/repos/asf/commons-math/tree/76b7413d
Diff: http://git-wip-us.apache.org/repos/asf/commons-math/diff/76b7413d
Branch: refs/heads/master
Commit: 76b7413d2b1eb2dc22f05de5b76f9519be5142e0
Parents: fbf5a51
Author: Thomas Neidhart <th...@gmail.com>
Authored: Tue Mar 10 23:16:03 2015 +0100
Committer: Thomas Neidhart <th...@gmail.com>
Committed: Tue Mar 10 23:16:03 2015 +0100
----------------------------------------------------------------------
src/changes/changes.xml | 4 +
.../math4/util/ResizableDoubleArray.java | 650 ++++---------------
.../math4/util/ResizableDoubleArrayTest.java | 54 +-
3 files changed, 158 insertions(+), 550 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/commons-math/blob/76b7413d/src/changes/changes.xml
----------------------------------------------------------------------
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index 8be9d68..55274f8 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -54,8 +54,12 @@ If the output is not quite correct, check for invisible trailing spaces!
</release>
<release version="4.0" date="XXXX-XX-XX" description="">
+ <action dev="tn" type="add" issue="MATH-757">
+ Removed broken synchronization support in "ResizableDoubleArray".
+ </action>
<action dev="tn" type="add" issue="MATH-945">
Added method "T log10()" to interface "RealFieldElement".
+ </action>
<action dev="psteitz" type="fix" issue="MATH-1208">
EmpiricalDistribution cumulativeProbability can return NaN when evaluated within a constant bin.
</action>
http://git-wip-us.apache.org/repos/asf/commons-math/blob/76b7413d/src/main/java/org/apache/commons/math4/util/ResizableDoubleArray.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/util/ResizableDoubleArray.java b/src/main/java/org/apache/commons/math4/util/ResizableDoubleArray.java
index b0dd132..09fd748 100644
--- a/src/main/java/org/apache/commons/math4/util/ResizableDoubleArray.java
+++ b/src/main/java/org/apache/commons/math4/util/ResizableDoubleArray.java
@@ -21,21 +21,15 @@ import java.util.Arrays;
import org.apache.commons.math4.exception.MathIllegalArgumentException;
import org.apache.commons.math4.exception.MathIllegalStateException;
-import org.apache.commons.math4.exception.MathInternalError;
import org.apache.commons.math4.exception.NotStrictlyPositiveException;
import org.apache.commons.math4.exception.NullArgumentException;
import org.apache.commons.math4.exception.NumberIsTooSmallException;
import org.apache.commons.math4.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>
- * <h3>Important note: Usage should not assume that this class is thread-safe
- * even though some of the methods are {@code synchronized}.
- * This qualifier will be dropped in the next major release (4.0).</h3>
* <p>
* The internal storage array starts with capacity determined by the
* {@code initialCapacity} property, which can be set by the constructor.
@@ -51,7 +45,6 @@ import org.apache.commons.math4.exception.util.LocalizedFormats;
* locations added).
* The default {@code expansionMode} is {@code MULTIPLICATIVE} and the default
* {@code expansionFactor} is 2.
- * </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
@@ -71,26 +64,16 @@ import org.apache.commons.math4.exception.util.LocalizedFormats;
* {@code contractionFactor.} If the {@code expansionMode}
* is {@code ADDITIVE}, the number of excess storage locations
* is compared to {@code contractionFactor}.
- * </p>
* <p>
* To avoid cycles of expansions and contractions, the
* {@code expansionFactor} must not exceed the {@code contractionFactor}.
* Constructors and mutators for both of these properties enforce this
* requirement, throwing a {@code MathIllegalArgumentException} if it is
* violated.
- * </p>
+ * <p>
+ * <b>Note:</b> this class is <b>NOT</b> thread-safe.
*/
public class ResizableDoubleArray implements DoubleArray, Serializable {
- /** Additive expansion mode.
- * @deprecated As of 3.1. Please use {@link ExpansionMode#ADDITIVE} instead.
- */
- @Deprecated
- public static final int ADDITIVE_MODE = 1;
- /** Multiplicative expansion mode.
- * @deprecated As of 3.1. Please use {@link ExpansionMode#MULTIPLICATIVE} instead.
- */
- @Deprecated
- public static final int MULTIPLICATIVE_MODE = 0;
/** Serializable version identifier. */
private static final long serialVersionUID = -3485529955529426875L;
@@ -98,6 +81,8 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
private static final int DEFAULT_INITIAL_CAPACITY = 16;
/** Default value for array size modifier. */
private static final double DEFAULT_EXPANSION_FACTOR = 2.0;
+ /** Default value for expansion mode. */
+ private static final ExpansionMode DEFAULT_EXPANSION_MODE = ExpansionMode.MULTIPLICATIVE;
/**
* Default value for the difference between {@link #contractionCriterion}
* and {@link #expansionFactor}.
@@ -109,23 +94,22 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
* contracted to fit the number of elements contained in the element
* array + 1.
*/
- private double contractionCriterion = 2.5;
+ private final double contractionCriterion;
/**
* The expansion factor of the array. When the array needs to be expanded,
- * the new array size will be
- * {@code internalArray.length * expansionFactor}
- * if {@code expansionMode} is set to MULTIPLICATIVE_MODE, or
+ * the new array size will be {@code internalArray.length * expansionFactor}
+ * if {@code expansionMode} is set to MULTIPLICATIVE, or
* {@code internalArray.length + expansionFactor} if
- * {@code expansionMode} is set to ADDITIVE_MODE.
+ * {@code expansionMode} is set to ADDITIVE.
*/
- private double expansionFactor = 2.0;
+ private final double expansionFactor;
/**
* Determines whether array expansion by {@code expansionFactor}
* is additive or multiplicative.
*/
- private ExpansionMode expansionMode = ExpansionMode.MULTIPLICATIVE;
+ private final ExpansionMode expansionMode;
/**
* The internal storage array.
@@ -171,6 +155,7 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
/**
* Creates an instance with the specified initial capacity.
+ * <p>
* Other properties take default values:
* <ul>
* <li>{@code expansionMode = MULTIPLICATIVE}</li>
@@ -180,8 +165,7 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
* @param initialCapacity Initial size of the internal storage array.
* @throws MathIllegalArgumentException if {@code initialCapacity <= 0}.
*/
- public ResizableDoubleArray(int initialCapacity)
- throws MathIllegalArgumentException {
+ public ResizableDoubleArray(int initialCapacity) throws MathIllegalArgumentException {
this(initialCapacity, DEFAULT_EXPANSION_FACTOR);
}
@@ -189,6 +173,7 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
* Creates an instance from an existing {@code double[]} with the
* initial capacity and numElements corresponding to the size of
* the supplied {@code double[]} array.
+ * <p>
* 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.
@@ -207,177 +192,66 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
this(DEFAULT_INITIAL_CAPACITY,
DEFAULT_EXPANSION_FACTOR,
DEFAULT_CONTRACTION_DELTA + DEFAULT_EXPANSION_FACTOR,
- ExpansionMode.MULTIPLICATIVE,
+ DEFAULT_EXPANSION_MODE,
initialArray);
}
/**
* Creates an instance with the specified initial capacity
* and expansion factor.
+ * <p>
* The remaining properties take default values:
* <ul>
* <li>{@code expansionMode = MULTIPLICATIVE}</li>
* <li>{@code contractionCriterion = 0.5 + expansionFactor}</li>
* </ul>
- * <br/>
- * Throws IllegalArgumentException if the following conditions are
- * not met:
- * <ul>
- * <li>{@code initialCapacity > 0}</li>
- * <li>{@code expansionFactor > 1}</li>
- * </ul>
- *
- * @param initialCapacity Initial size of the internal storage array.
- * @param expansionFactor The array will be expanded based on this
- * parameter.
- * @throws MathIllegalArgumentException if parameters are not valid.
- * @deprecated As of 3.1. Please use
- * {@link #ResizableDoubleArray(int,double)} instead.
- */
- @Deprecated
- public ResizableDoubleArray(int initialCapacity,
- float expansionFactor)
- throws MathIllegalArgumentException {
- this(initialCapacity,
- (double) expansionFactor);
- }
-
- /**
- * Creates an instance with the specified initial capacity
- * and expansion factor.
- * The remaining properties take default values:
- * <ul>
- * <li>{@code expansionMode = MULTIPLICATIVE}</li>
- * <li>{@code contractionCriterion = 0.5 + expansionFactor}</li>
- * </ul>
- * <br/>
- * Throws IllegalArgumentException if the following conditions are
- * not met:
+ * <p>
+ * Throws MathIllegalArgumentException if the following conditions
+ * are not met:
* <ul>
* <li>{@code initialCapacity > 0}</li>
* <li>{@code expansionFactor > 1}</li>
* </ul>
*
* @param initialCapacity Initial size of the internal storage array.
- * @param expansionFactor The array will be expanded based on this
- * parameter.
+ * @param expansionFactor The array will be expanded based on this parameter.
* @throws MathIllegalArgumentException if parameters are not valid.
* @since 3.1
*/
- public ResizableDoubleArray(int initialCapacity,
- double expansionFactor)
- throws MathIllegalArgumentException {
- this(initialCapacity,
- expansionFactor,
- DEFAULT_CONTRACTION_DELTA + expansionFactor);
- }
-
- /**
- * Creates an instance with the specified initialCapacity,
- * expansionFactor, and contractionCriterion.
- * The expansion mode will default to {@code MULTIPLICATIVE}.
- * <br/>
- * Throws IllegalArgumentException if the following conditions are
- * not met:
- * <ul>
- * <li>{@code initialCapacity > 0}</li>
- * <li>{@code expansionFactor > 1}</li>
- * <li>{@code contractionCriterion >= expansionFactor}</li>
- * </ul>
- *
- * @param initialCapacity Initial size of the internal storage array..
- * @param expansionFactor The array will be expanded based on this
- * parameter.
- * @param contractionCriteria Contraction criteria.
- * @throws MathIllegalArgumentException if parameters are not valid.
- * @deprecated As of 3.1. Please use
- * {@link #ResizableDoubleArray(int,double,double)} instead.
- */
- @Deprecated
- public ResizableDoubleArray(int initialCapacity,
- float expansionFactor,
- float contractionCriteria)
- throws MathIllegalArgumentException {
- this(initialCapacity,
- (double) expansionFactor,
- (double) contractionCriteria);
+ public ResizableDoubleArray(int initialCapacity, double expansionFactor) throws MathIllegalArgumentException {
+ this(initialCapacity, expansionFactor, DEFAULT_CONTRACTION_DELTA + expansionFactor);
}
/**
* Creates an instance with the specified initial capacity,
* expansion factor, and contraction criteria.
+ * <p>
* The expansion mode will default to {@code MULTIPLICATIVE}.
- * <br/>
- * Throws IllegalArgumentException if the following conditions are
- * not met:
+ * <p>
+ * Throws MathIllegalArgumentException if the following conditions
+ * are not met:
* <ul>
* <li>{@code initialCapacity > 0}</li>
* <li>{@code expansionFactor > 1}</li>
* <li>{@code contractionCriterion >= expansionFactor}</li>
* </ul>
*
- * @param initialCapacity Initial size of the internal storage array..
- * @param expansionFactor The array will be expanded based on this
- * parameter.
+ * @param initialCapacity Initial size of the internal storage array.
+ * @param expansionFactor The array will be expanded based on this parameter.
* @param contractionCriterion Contraction criterion.
* @throws MathIllegalArgumentException if the parameters are not valid.
* @since 3.1
*/
- public ResizableDoubleArray(int initialCapacity,
- double expansionFactor,
- double contractionCriterion)
+ public ResizableDoubleArray(int initialCapacity, double expansionFactor, double contractionCriterion)
throws MathIllegalArgumentException {
- this(initialCapacity,
- expansionFactor,
- contractionCriterion,
- ExpansionMode.MULTIPLICATIVE,
- null);
- }
-
- /**
- * <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 MathIllegalArgumentException if parameters are not valid
- * @deprecated As of 3.1. Please use
- * {@link #ResizableDoubleArray(int,double,double,ExpansionMode,double[])}
- * instead.
- */
- @Deprecated
- public ResizableDoubleArray(int initialCapacity, float expansionFactor,
- float contractionCriteria, int expansionMode) throws MathIllegalArgumentException {
- this(initialCapacity,
- expansionFactor,
- contractionCriteria,
- expansionMode == ADDITIVE_MODE ?
- ExpansionMode.ADDITIVE :
- ExpansionMode.MULTIPLICATIVE,
- null);
- // XXX Just ot retain the expected failure in a unit test.
- // With the new "enum", that test will become obsolete.
- setExpansionMode(expansionMode);
+ this(initialCapacity, expansionFactor, contractionCriterion, DEFAULT_EXPANSION_MODE, null);
}
/**
* Creates an instance with the specified properties.
* <br/>
- * Throws MathIllegalArgumentException if the following conditions are
- * not met:
+ * Throws MathIllegalArgumentException if the following conditions
+ * are not met:
* <ul>
* <li>{@code initialCapacity > 0}</li>
* <li>{@code expansionFactor > 1}</li>
@@ -385,12 +259,12 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
* </ul>
*
* @param initialCapacity Initial size of the internal storage array.
- * @param expansionFactor The array will be expanded based on this
- * parameter.
+ * @param expansionFactor The array will be expanded based on this parameter.
* @param contractionCriterion Contraction criteria.
* @param expansionMode Expansion mode.
* @param data Initial contents of the array.
* @throws MathIllegalArgumentException if the parameters are not valid.
+ * @throws NullArgumentException if expansionMode is null
*/
public ResizableDoubleArray(int initialCapacity,
double expansionFactor,
@@ -403,6 +277,7 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
initialCapacity);
}
checkContractExpand(contractionCriterion, expansionFactor);
+ MathUtils.checkNotNull(expansionMode);
this.expansionFactor = expansionFactor;
this.contractionCriterion = contractionCriterion;
@@ -417,19 +292,25 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
}
/**
- * 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 {@link NullArgumentException}
- * is thrown.
+ * Copy constructor.
+ * <p>
+ * Creates a new ResizableDoubleArray that is a deep, fresh copy of the original.
+ * Original may not be null; otherwise a {@link NullArgumentException} is thrown.
*
* @param original array to copy
* @exception NullArgumentException if original is null
* @since 2.0
*/
- public ResizableDoubleArray(ResizableDoubleArray original)
+ public ResizableDoubleArray(final ResizableDoubleArray original)
throws NullArgumentException {
MathUtils.checkNotNull(original);
- copy(original, this);
+ this.contractionCriterion = original.contractionCriterion;
+ this.expansionFactor = original.expansionFactor;
+ this.expansionMode = original.expansionMode;
+ this.internalArray = new double[original.internalArray.length];
+ System.arraycopy(original.internalArray, 0, this.internalArray, 0, this.internalArray.length);
+ this.numElements = original.numElements;
+ this.startIndex = original.startIndex;
}
/**
@@ -438,7 +319,7 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
* @param value Value to be added to end of array.
*/
@Override
- public synchronized void addElement(double value) {
+ public void addElement(final double value) {
if (internalArray.length <= startIndex + numElements) {
expand();
}
@@ -452,7 +333,7 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
* @since 2.2
*/
@Override
- public synchronized void addElements(double[] values) {
+ public void addElements(final 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);
@@ -462,23 +343,21 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
}
/**
- * <p>
* Adds an element to the end of the array and removes the first
* element in the array. Returns the discarded first element.
+ * <p>
* 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 Value to be added to the array.
* @return the value which has been discarded or "pushed" out of the array
* by this rolling insert.
*/
@Override
- public synchronized double addElementRolling(double value) {
+ public double addElementRolling(double value) {
double discarded = internalArray[startIndex];
if ((startIndex + (numElements + 1)) > internalArray.length) {
@@ -498,20 +377,19 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
}
/**
- * Substitutes <code>value</code> for the most recently added value.
+ * Substitutes {@code value} for the most recently added value.
+ * <p>
* Returns the value that has been replaced. If the array is empty (i.e.
- * if {@link #numElements} is zero), an IllegalStateException is thrown.
+ * if {@link #numElements} is zero), an MathIllegalStateException is thrown.
*
* @param value New value to substitute for the most recently added value
* @return the value that has been replaced in the array.
* @throws MathIllegalStateException if the array is empty
* @since 2.0
*/
- public synchronized double substituteMostRecentElement(double value)
- throws MathIllegalStateException {
+ public double substituteMostRecentElement(double value) throws MathIllegalStateException {
if (numElements < 1) {
- throw new MathIllegalStateException(
- LocalizedFormats.CANNOT_SUBSTITUTE_ELEMENT_FROM_EMPTY_ARRAY);
+ throw new MathIllegalStateException(LocalizedFormats.CANNOT_SUBSTITUTE_ELEMENT_FROM_EMPTY_ARRAY);
}
final int substIndex = startIndex + (numElements - 1);
@@ -523,25 +401,6 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
}
/**
- * Checks the expansion factor and the contraction criterion 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 MathIllegalArgumentException if the contractionCriteria is less than
- * the expansionCriteria.
- * @deprecated As of 3.1. Please use
- * {@link #checkContractExpand(double,double)} instead.
- */
- @Deprecated
- protected void checkContractExpand(float contraction, float expansion)
- throws MathIllegalArgumentException {
- checkContractExpand((double) contraction,
- (double) expansion);
- }
-
- /**
* Checks the expansion factor and the contraction criterion and raises
* an exception if the contraction criterion is smaller than the
* expansion criterion.
@@ -553,9 +412,7 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
* @throws NumberIsTooSmallException if {@code expansion <= 1 }.
* @since 3.1
*/
- protected void checkContractExpand(double contraction,
- double expansion)
- throws NumberIsTooSmallException {
+ protected void checkContractExpand(double contraction, double expansion) throws NumberIsTooSmallException {
if (contraction < expansion) {
final NumberIsTooSmallException e = new NumberIsTooSmallException(contraction, 1, true);
e.getContext().addMessage(LocalizedFormats.CONTRACTION_CRITERIA_SMALLER_THAN_EXPANSION_FACTOR,
@@ -582,17 +439,16 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
* Clear the array contents, resetting the number of elements to zero.
*/
@Override
- public synchronized void clear() {
+ public void clear() {
numElements = 0;
startIndex = 0;
}
/**
- * 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.
+ * 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() {
+ public void contract() {
final double[] tempArray = new double[numElements + 1];
// Copy and swap - copy only the element array from the src array.
@@ -604,48 +460,45 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
}
/**
- * 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.
+ * Discards the {@code i} initial elements of the array.
+ * <p>
+ * For example, if the array contains the elements 1,2,3,4, invoking
+ * {@code discardFrontElements(2)} will cause the first two elements
+ * to be discarded, leaving 3,4 in the array.
*
* @param i the number of elements to discard from the front of the array
* @throws MathIllegalArgumentException if i is greater than numElements.
* @since 2.0
*/
- public synchronized void discardFrontElements(int i)
- throws MathIllegalArgumentException {
+ public void discardFrontElements(int i) throws MathIllegalArgumentException {
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.
+ * Discards the {@code i} last elements of the array.
+ * <p>
+ * For example, if the array contains the elements 1,2,3,4, invoking
+ * {@code discardMostRecentElements(2)} will cause the last two elements
+ * to be discarded, leaving 1,2 in the array.
*
* @param i the number of elements to discard from the end of the array
* @throws MathIllegalArgumentException if i is greater than numElements.
* @since 2.0
*/
- public synchronized void discardMostRecentElements(int i)
- throws MathIllegalArgumentException {
+ public void discardMostRecentElements(int i) throws MathIllegalArgumentException {
discardExtremeElements(i,false);
}
/**
- * Discards the <code>i</code> first or last elements of the array,
- * depending on the value of <code>front</code>.
+ * Discards the {@code i} first or last elements of the array,
+ * depending on the value of {@code front}.
+ * <p>
* For example, if the array contains the elements 1,2,3,4, invoking
- * <code>discardExtremeElements(2,false)</code> will cause the last two elements
+ * {@code discardExtremeElements(2,false)} 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
+ * {@code discardExtremeElements(2,true)} 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
@@ -654,9 +507,7 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
* @throws MathIllegalArgumentException if i is greater than numElements.
* @since 2.0
*/
- private synchronized void discardExtremeElements(int i,
- boolean front)
- throws MathIllegalArgumentException {
+ private void discardExtremeElements(int i, boolean front) throws MathIllegalArgumentException {
if (i > numElements) {
throw new MathIllegalArgumentException(
LocalizedFormats.TOO_MANY_ELEMENTS_TO_DISCARD_FROM_ARRAY,
@@ -680,13 +531,12 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
/**
* 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>
+ * If {@code expansionMode} is set to MULTIPLICATIVE,
+ * the new array size will be {@code internalArray.length * expansionFactor}.
+ * If {@code expansionMode} is set to ADDITIVE, the length
+ * after expansion will be {@code internalArray.length + expansionFactor}.
*/
- protected synchronized void expand() {
+ protected 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
@@ -710,7 +560,7 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
*
* @param size Size of the new internal storage array.
*/
- private synchronized void expandTo(int size) {
+ private void expandTo(int size) {
final double[] tempArray = new double[size];
// Copy and swap
System.arraycopy(internalArray, 0, tempArray, 0, internalArray.length);
@@ -718,33 +568,14 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
}
/**
- * 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.
- * @deprecated As of 3.1. Please use {@link #getContractionCriterion()}
- * instead.
- */
- @Deprecated
- public float getContractionCriteria() {
- return (float) getContractionCriterion();
- }
-
- /**
* The contraction criterion 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>,
+ * <p>
+ * If the {@code expansionMode} is {@code MULTIPLICATIVE},
* 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>
+ * and {@code numElements} exceeds {@code contractionFactor}.
+ * If the {@code expansionMode} is {@code ADDITIVE}, the
+ * number of excess storage locations is compared to {@code contractionFactor}.
*
* @return the contraction criterion used to reclaim memory.
* @since 3.1
@@ -754,15 +585,15 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
}
/**
- * Returns the element at the specified index
+ * 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>.
+ * @throws ArrayIndexOutOfBoundsException if {@code index} is less than
+ * zero or is greater than {@code getNumElements() - 1}.
*/
@Override
- public synchronized double getElement(int index) {
+ public double getElement(int index) {
if (index >= numElements) {
throw new ArrayIndexOutOfBoundsException(index);
} else if (index >= 0) {
@@ -773,14 +604,15 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
}
/**
- * 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>
+ * Returns a double array containing the elements of this ResizableArray.
+ * <p>
+ * 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 ResizableArray.
+ *
* @return the double array.
*/
@Override
- public synchronized double[] getElements() {
+ public double[] getElements() {
final double[] elementArray = new double[numElements];
System.arraycopy(internalArray, startIndex, elementArray, 0, numElements);
return elementArray;
@@ -788,20 +620,18 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
/**
* 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.
+ * needs to be expanded.
+ * <p>
+ * The {@code expansionMode} determines whether the size of the array
+ * is multiplied by the {@code expansionFactor} (MULTIPLICATIVE) or if
+ * the expansion is additive (ADDITIVE -- {@code expansionFactor}
+ * storage locations added). The default {@code expansionMode} is
+ * MULTIPLICATIVE and the default {@code expansionFactor} is 2.0.
*
* @return the expansion factor of this expandable double array
- * @deprecated As of 3.1. Return type will be changed to "double" in 4.0.
*/
- @Deprecated
- public float getExpansionFactor() {
- return (float) expansionFactor;
+ public double getExpansionFactor() {
+ return expansionFactor;
}
/**
@@ -809,33 +639,9 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
* array grows additively or multiplicatively when it is expanded.
*
* @return the expansion mode.
- * @deprecated As of 3.1. Return value to be changed to
- * {@link ExpansionMode} in 4.0.
- */
- @Deprecated
- public int getExpansionMode() {
- switch (expansionMode) {
- case MULTIPLICATIVE:
- return MULTIPLICATIVE_MODE;
- case ADDITIVE:
- return ADDITIVE_MODE;
- default:
- throw new MathInternalError(); // Should never happen.
- }
- }
-
- /**
- * 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.
- * @deprecated As of 3.1. Please use {@link #getCapacity()} instead.
*/
- @Deprecated
- synchronized int getInternalLength() {
- return internalArray.length;
+ public ExpansionMode getExpansionMode() {
+ return expansionMode;
}
/**
@@ -858,41 +664,23 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
* @return the number of elements.
*/
@Override
- public synchronized int getNumElements() {
+ public 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
- * @since 2.0
- * @deprecated As of 3.1.
- */
- @Deprecated
- public synchronized double[] getInternalValues() {
- return internalArray;
- }
-
- /**
* Provides <em>direct</em> access to the internal storage array.
* Please note that this method returns a reference to this object's
* storage array, not a copy.
- * <br/>
+ * <p>
* To correctly address elements of the array, the "start index" is
* required (available via the {@link #getStartIndex() getStartIndex}
* method.
- * <br/>
+ * <p>
* This method should only be used to avoid copying the internal array.
* The returned value <em>must</em> be used for reading only; other
* uses could lead to this object becoming inconsistent.
- * <br/>
+ * <p>
* The {@link #getElements} method has no such limitation since it
* returns a copy of this array's addressable elements.
*
@@ -907,6 +695,7 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
* Returns the "start index" of the internal array.
* This index is the position of the first addressable element in the
* internal storage array.
+ * <p>
* The addressable elements in the array are at indices contained in
* the interval [{@link #getStartIndex()},
* {@link #getStartIndex()} + {@link #getNumElements()} - 1].
@@ -919,23 +708,6 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
}
/**
- * Sets the contraction criteria.
- *
- * @param contractionCriteria contraction criteria
- * @throws MathIllegalArgumentException if the contractionCriteria is less than
- * the expansionCriteria.
- * @deprecated As of 3.1 (to be removed in 4.0 as field will become "final").
- */
- @Deprecated
- public void setContractionCriteria(float contractionCriteria)
- throws MathIllegalArgumentException {
- checkContractExpand(contractionCriteria, getExpansionFactor());
- synchronized(this) {
- this.contractionCriterion = contractionCriteria;
- }
- }
-
- /**
* Performs an operation on the addressable elements of the array.
*
* @param f Function to be applied on this array.
@@ -943,30 +715,24 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
* @since 3.1
*/
public double compute(MathArrays.Function f) {
- final double[] array;
- final int start;
- final int num;
- synchronized(this) {
- array = internalArray;
- start = startIndex;
- num = numElements;
- }
- return f.evaluate(array, start, num);
+ return f.evaluate(internalArray, startIndex, numElements);
}
/**
- * 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).
+ * Sets the element at the specified index.
+ * <p>
+ * If the specified index is greater than {@code getNumElements() - 1},
+ * the {@code numElements} property is increased to {@code index +1}
+ * 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 < 0}.
*/
@Override
- public synchronized void setElement(int index, double value) {
+ public void setElement(int index, double value) {
if (index < 0) {
throw new ArrayIndexOutOfBoundsException(index);
}
@@ -980,92 +746,17 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
}
/**
- * 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 MathIllegalArgumentException if expansionFactor is <= 1 or greater
- * than contractionFactor
- * @deprecated As of 3.1 (to be removed in 4.0 as field will become "final").
- */
- @Deprecated
- public void setExpansionFactor(float expansionFactor) throws MathIllegalArgumentException {
- checkContractExpand(getContractionCriterion(), 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 MathIllegalArgumentException if the specified mode value is not valid.
- * @deprecated As of 3.1. Please use {@link #setExpansionMode(ExpansionMode)} instead.
- */
- @Deprecated
- public void setExpansionMode(int expansionMode)
- throws MathIllegalArgumentException {
- if (expansionMode != MULTIPLICATIVE_MODE &&
- expansionMode != ADDITIVE_MODE) {
- throw new MathIllegalArgumentException(LocalizedFormats.UNSUPPORTED_EXPANSION_MODE, expansionMode,
- MULTIPLICATIVE_MODE, "MULTIPLICATIVE_MODE",
- ADDITIVE_MODE, "ADDITIVE_MODE");
- }
- synchronized(this) {
- if (expansionMode == MULTIPLICATIVE_MODE) {
- setExpansionMode(ExpansionMode.MULTIPLICATIVE);
- } else if (expansionMode == ADDITIVE_MODE) {
- setExpansionMode(ExpansionMode.ADDITIVE);
- }
- }
- }
-
- /**
- * Sets the {@link ExpansionMode expansion mode}.
- *
- * @param expansionMode Expansion mode to use for resizing the array.
- * @deprecated As of 3.1 (to be removed in 4.0 as field will become "final").
- */
- @Deprecated
- public void setExpansionMode(ExpansionMode expansionMode) {
- this.expansionMode = expansionMode;
- }
-
- /**
- * Sets the initial capacity. Should only be invoked by constructors.
- *
- * @param initialCapacity of the array
- * @throws MathIllegalArgumentException if <code>initialCapacity</code> is not
- * positive.
- * @deprecated As of 3.1, this is a no-op.
- */
- @Deprecated
- protected void setInitialCapacity(int initialCapacity)
- throws MathIllegalArgumentException {
- // Body removed in 3.1.
- }
-
- /**
* 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 MathIllegalArgumentException if <code>i</code> is negative.
+ * @throws MathIllegalArgumentException if {@code i} is negative.
*/
- public synchronized void setNumElements(int i)
- throws MathIllegalArgumentException {
+ public void setNumElements(int i) throws MathIllegalArgumentException {
// If index is negative thrown an error.
if (i < 0) {
- throw new MathIllegalArgumentException(
- LocalizedFormats.INDEX_NOT_POSITIVE,
- i);
+ throw new MathIllegalArgumentException(LocalizedFormats.INDEX_NOT_POSITIVE, i);
}
// Test the new num elements, check to see if the array needs to be
@@ -1085,7 +776,7 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
*
* @return true if array satisfies the contraction criteria
*/
- private synchronized boolean shouldContract() {
+ private boolean shouldContract() {
if (expansionMode == ExpansionMode.MULTIPLICATIVE) {
return (internalArray.length / ((float) numElements)) > contractionCriterion;
} else {
@@ -1094,57 +785,6 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
}
/**
- * 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 the starting index.
- * @deprecated As of 3.1.
- */
- @Deprecated
- 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 {@link NullArgumentException}
- * is thrown</p>
- *
- * @param source ResizableDoubleArray to copy
- * @param dest ResizableArray to replace with a copy of the source array
- * @exception NullArgumentException if either source or dest is null
- * @since 2.0
- *
- */
- public static void copy(ResizableDoubleArray source,
- ResizableDoubleArray dest)
- throws NullArgumentException {
- MathUtils.checkNotNull(source);
- MathUtils.checkNotNull(dest);
- synchronized(source) {
- synchronized(dest) {
- dest.contractionCriterion = source.contractionCriterion;
- 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.
*
@@ -1152,10 +792,8 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
* properties as this
* @since 2.0
*/
- public synchronized ResizableDoubleArray copy() {
- final ResizableDoubleArray result = new ResizableDoubleArray();
- copy(this, result);
- return result;
+ public ResizableDoubleArray copy() {
+ return new ResizableDoubleArray(this);
}
/**
@@ -1175,21 +813,17 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
if (object instanceof ResizableDoubleArray == false) {
return false;
}
- synchronized(this) {
- synchronized(object) {
- boolean result = true;
- final ResizableDoubleArray other = (ResizableDoubleArray) object;
- result = result && (other.contractionCriterion == contractionCriterion);
- 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);
- }
- }
+ boolean result = true;
+ final ResizableDoubleArray other = (ResizableDoubleArray) object;
+ result = result && (other.contractionCriterion == contractionCriterion);
+ 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);
}
}
@@ -1200,7 +834,7 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
* @since 2.0
*/
@Override
- public synchronized int hashCode() {
+ public int hashCode() {
final int[] hashData = new int[6];
hashData[0] = Double.valueOf(expansionFactor).hashCode();
hashData[1] = Double.valueOf(contractionCriterion).hashCode();
http://git-wip-us.apache.org/repos/asf/commons-math/blob/76b7413d/src/test/java/org/apache/commons/math4/util/ResizableDoubleArrayTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/util/ResizableDoubleArrayTest.java b/src/test/java/org/apache/commons/math4/util/ResizableDoubleArrayTest.java
index c91de57..1f31c0c 100644
--- a/src/test/java/org/apache/commons/math4/util/ResizableDoubleArrayTest.java
+++ b/src/test/java/org/apache/commons/math4/util/ResizableDoubleArrayTest.java
@@ -18,8 +18,8 @@ package org.apache.commons.math4.util;
import org.apache.commons.math4.distribution.IntegerDistribution;
import org.apache.commons.math4.distribution.UniformIntegerDistribution;
-import org.apache.commons.math4.util.MathArrays;
-import org.apache.commons.math4.util.ResizableDoubleArray;
+import org.apache.commons.math4.exception.NullArgumentException;
+import org.apache.commons.math4.util.ResizableDoubleArray.ExpansionMode;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@@ -28,7 +28,6 @@ import org.junit.Test;
/**
* This class contains test cases for the ResizableDoubleArray.
- *
*/
public class ResizableDoubleArrayTest extends DoubleArrayAbstractTest {
@@ -48,7 +47,7 @@ public class ResizableDoubleArrayTest extends DoubleArrayAbstractTest {
public void testConstructors() {
float defaultExpansionFactor = 2.0f;
double defaultContractionCriteria = 2.5;
- int defaultMode = ResizableDoubleArray.MULTIPLICATIVE_MODE;
+ ExpansionMode defaultMode = ResizableDoubleArray.ExpansionMode.MULTIPLICATIVE;
ResizableDoubleArray testDa = new ResizableDoubleArray(2);
Assert.assertEquals(0, testDa.getNumElements());
@@ -62,10 +61,10 @@ public class ResizableDoubleArrayTest extends DoubleArrayAbstractTest {
} catch (IllegalArgumentException ex) {
// expected
}
-
+
testDa = new ResizableDoubleArray((double[]) null);
Assert.assertEquals(0, testDa.getNumElements());
-
+
double[] initialArray = new double[] { 0, 1, 2 };
testDa = new ResizableDoubleArray(initialArray);
Assert.assertEquals(3, testDa.getNumElements());
@@ -102,19 +101,17 @@ public class ResizableDoubleArrayTest extends DoubleArrayAbstractTest {
// expected
}
- testDa = new ResizableDoubleArray(2, 2.0, 3.0,
- ResizableDoubleArray.ExpansionMode.ADDITIVE);
+ testDa = new ResizableDoubleArray(2, 2.0, 3.0, ResizableDoubleArray.ExpansionMode.ADDITIVE);
Assert.assertEquals(0, testDa.getNumElements());
Assert.assertEquals(2, testDa.getCapacity());
Assert.assertEquals(defaultExpansionFactor, testDa.getExpansionFactor(), 0);
Assert.assertEquals(3.0f, testDa.getContractionCriterion(), 0);
- Assert.assertEquals(ResizableDoubleArray.ADDITIVE_MODE,
- testDa.getExpansionMode());
+ Assert.assertEquals(ResizableDoubleArray.ExpansionMode.ADDITIVE, testDa.getExpansionMode());
try {
- da = new ResizableDoubleArray(2, 2.0f, 2.5f, -1);
- Assert.fail("Expecting IllegalArgumentException");
- } catch (IllegalArgumentException ex) {
+ da = new ResizableDoubleArray(2, 2.0d, 2.5d, null);
+ Assert.fail("Expecting NullArgumentException");
+ } catch (NullArgumentException ex) {
// expected
}
@@ -128,7 +125,6 @@ public class ResizableDoubleArrayTest extends DoubleArrayAbstractTest {
Assert.assertEquals(testDa, copyDa);
}
-
@Test
public void testSetElementArbitraryExpansion1() {
@@ -441,30 +437,6 @@ public class ResizableDoubleArrayTest extends DoubleArrayAbstractTest {
}
@Test
- public void testMutators() {
- ((ResizableDoubleArray)da).setContractionCriteria(10f);
- Assert.assertEquals(10f, ((ResizableDoubleArray)da).getContractionCriterion(), 0);
- ((ResizableDoubleArray)da).setExpansionFactor(8f);
- Assert.assertEquals(8f, ((ResizableDoubleArray)da).getExpansionFactor(), 0);
- try {
- ((ResizableDoubleArray)da).setExpansionFactor(11f); // greater than contractionCriteria
- Assert.fail("Expecting IllegalArgumentException");
- } catch (IllegalArgumentException ex) {
- // expected
- }
- ((ResizableDoubleArray)da).setExpansionMode(
- ResizableDoubleArray.ADDITIVE_MODE);
- Assert.assertEquals(ResizableDoubleArray.ADDITIVE_MODE,
- ((ResizableDoubleArray)da).getExpansionMode());
- try {
- ((ResizableDoubleArray)da).setExpansionMode(-1);
- Assert.fail("Expecting IllegalArgumentException");
- } catch (IllegalArgumentException ex) {
- // expected
- }
- }
-
- @Test
public void testEqualsAndHashCode() throws Exception {
// Wrong type
@@ -529,10 +501,6 @@ public class ResizableDoubleArrayTest extends DoubleArrayAbstractTest {
fourth.addElement(18);
verifyInequality(third, fourth);
- // copy
- ResizableDoubleArray.copy(fourth, fifth);
- verifyEquality(fourth, fifth);
-
// Copy constructor
verifyEquality(fourth, new ResizableDoubleArray(fourth));
@@ -567,6 +535,7 @@ public class ResizableDoubleArrayTest extends DoubleArrayAbstractTest {
}
final MathArrays.Function add = new MathArrays.Function() {
+ @Override
public double evaluate(double[] a, int index, int num) {
double sum = 0;
final int max = index + num;
@@ -575,6 +544,7 @@ public class ResizableDoubleArrayTest extends DoubleArrayAbstractTest {
}
return sum;
}
+ @Override
public double evaluate(double[] a) {
return evaluate(a, 0, a.length);
}