commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pste...@apache.org
Subject svn commit: r811685 [24/24] - in /commons/proper/math/trunk: ./ src/main/java/org/apache/commons/math/ src/main/java/org/apache/commons/math/analysis/ src/main/java/org/apache/commons/math/analysis/integration/ src/main/java/org/apache/commons/math/ana...
Date Sat, 05 Sep 2009 17:37:05 GMT
Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/MathUtilsTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/MathUtilsTest.java?rev=811685&r1=811684&r2=811685&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/MathUtilsTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/MathUtilsTest.java
Sat Sep  5 17:36:48 2009
@@ -311,7 +311,7 @@
       assertTrue(MathUtils.compareTo(152.308, 152.32, .011) < 0);
       assertTrue(MathUtils.compareTo(152.33, 152.318, .011) > 0);
     }
-    
+
     public void testCosh() {
         double x = 3.0;
         double expected = 10.06766;
@@ -361,7 +361,7 @@
         assertFalse(MathUtils.equals(153, 153.00000000000006, 1));
         assertTrue(MathUtils.equals(153, 152.99999999999997, 1));
         assertFalse(MathUtils.equals(153, 152.99999999999994, 1));
-        
+
         assertTrue(MathUtils.equals(-128, -127.99999999999999, 1));
         assertFalse(MathUtils.equals(-128, -127.99999999999997, 1));
         assertTrue(MathUtils.equals(-128, -128.00000000000003, 1));
@@ -378,7 +378,7 @@
 
         assertFalse(MathUtils.equals(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY,
100000));
     }
-    
+
     public void testArrayEquals() {
         assertFalse(MathUtils.equals(new double[] { 1d }, null));
         assertFalse(MathUtils.equals(null, new double[] { 1d }));
@@ -406,7 +406,7 @@
             assertEquals(i + "! ", factorial(i), MathUtils.factorialDouble(i), Double.MIN_VALUE);
             assertEquals(i + "! ", Math.log(factorial(i)), MathUtils.factorialLog(i), 10E-12);
         }
-        
+
         assertEquals("0", 1, MathUtils.factorial(0));
         assertEquals("0", 1.0d, MathUtils.factorialDouble(0), 1E-14);
         assertEquals("0", 0.0d, MathUtils.factorialLog(0), 1E-14);
@@ -529,7 +529,7 @@
         assertFalse(MathUtils.hash(new double[] { 1d }) ==
                     MathUtils.hash(new double[] { 1d, 1d }));
     }
-    
+
     /**
      * Make sure that permuted arrays do not hash to the same value.
      */
@@ -537,12 +537,12 @@
         double[] original = new double[10];
         double[] permuted = new double[10];
         RandomDataImpl random = new RandomDataImpl();
-        
+
         // Generate 10 distinct random values
         for (int i = 0; i < 10; i++) {
             original[i] = random.nextUniform(i + 0.5, i + 0.75);
         }
-        
+
         // Generate a random permutation, making sure it is not the identity
         boolean isIdentity = true;
         do {
@@ -554,7 +554,7 @@
                 permuted[i] = original[permutation[i]];
             }
         } while (isIdentity);
-        
+
         // Verify that permuted array has different hash
         assertFalse(MathUtils.hash(original) == MathUtils.hash(permuted));
     }
@@ -627,7 +627,7 @@
         } catch (ArithmeticException ex) {
             // expected
         }
-        
+
         try {
             // lcm == abs(MIN_VALUE) cannot be represented as a nonnegative int
             MathUtils.lcm(Integer.MIN_VALUE, 1<<20);
@@ -796,53 +796,53 @@
             }
         }
     }
-    
+
     public void testNormalizeArray() {
         double[] testValues1 = new double[] {1, 1, 2};
         TestUtils.assertEquals(
                 new double[] {.25, .25, .5},
                 MathUtils.normalizeArray(testValues1, 1),
                 Double.MIN_VALUE);
-     
+
         double[] testValues2 = new double[] {-1, -1, 1};
         TestUtils.assertEquals(
                 new double[] {1, 1, -1},
                 MathUtils.normalizeArray(testValues2, 1),
                 Double.MIN_VALUE);
-        
+
         // Ignore NaNs
         double[] testValues3 = new double[] {-1, -1, Double.NaN, 1, Double.NaN};
         TestUtils.assertEquals(
                 new double[] {1, 1,Double.NaN, -1, Double.NaN},
                 MathUtils.normalizeArray(testValues3, 1),
                 Double.MIN_VALUE);
-        
+
         // Zero sum -> ArithmeticException
         double[] zeroSum = new double[] {-1, 1};
         try {
             MathUtils.normalizeArray(zeroSum, 1);
             fail("expecting ArithmeticException");
         } catch (ArithmeticException ex) {}
-        
+
         // Infinite elements -> ArithmeticException
         double[] hasInf = new double[] {1, 2, 1, Double.NEGATIVE_INFINITY};
         try {
             MathUtils.normalizeArray(hasInf, 1);
             fail("expecting ArithmeticException");
         } catch (ArithmeticException ex) {}
-        
+
         // Infinite target -> IllegalArgumentException
         try {
             MathUtils.normalizeArray(testValues1, Double.POSITIVE_INFINITY);
             fail("expecting IllegalArgumentException");
         } catch (IllegalArgumentException ex) {}
-        
+
         // NaN target -> IllegalArgumentException
         try {
             MathUtils.normalizeArray(testValues1, Double.NaN);
             fail("expecting IllegalArgumentException");
-        } catch (IllegalArgumentException ex) {}  
-        
+        } catch (IllegalArgumentException ex) {}
+
     }
 
     public void testRoundDouble() {
@@ -1225,7 +1225,7 @@
         assertEquals(bigOne, MathUtils.pow(twentyOne, 103));
         assertEquals(bigOne, MathUtils.pow(twentyOne, 103l));
         assertEquals(bigOne, MathUtils.pow(twentyOne, BigInteger.valueOf(103l)));
-        
+
     }
 
     public void testL1DistanceDouble() {

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/OpenIntToDoubleHashMapTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/OpenIntToDoubleHashMapTest.java?rev=811685&r1=811684&r2=811685&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/OpenIntToDoubleHashMapTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/OpenIntToDoubleHashMapTest.java
Sat Sep  5 17:36:48 2009
@@ -5,9 +5,9 @@
  * 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.
@@ -68,12 +68,12 @@
         }
         return map;
     }
-    
+
     public void testPutAndGetWith0ExpectedSize() {
         OpenIntToDoubleHashMap map = new OpenIntToDoubleHashMap(0);
         assertPutAndGet(map);
     }
-    
+
     public void testPutAndGetWithExpectedSize() {
         OpenIntToDoubleHashMap map = new OpenIntToDoubleHashMap(500);
         assertPutAndGet(map);
@@ -122,7 +122,7 @@
     public void testGetAbsent() {
         Map<Integer, Double> generated = generateAbsent();
         OpenIntToDoubleHashMap map = createFromJavaMap();
-        
+
         for (Map.Entry<Integer, Double> mapEntry : generated.entrySet())
             assertTrue(Double.isNaN(map.get(mapEntry.getKey())));
     }
@@ -177,7 +177,7 @@
 
         OpenIntToDoubleHashMap map = createFromJavaMap();
         int mapSize = map.size();
-        
+
         for (Map.Entry<Integer, Double> mapEntry : generated.entrySet()) {
             map.remove(mapEntry.getKey());
             assertEquals(mapSize, map.size());
@@ -272,14 +272,14 @@
         map.put(key3, value1);
         assertEquals(value1, map.get(key3));
         assertEquals(3, map.size());
-        
+
         map.remove(key2);
         double value2 = 2.0;
         map.put(key3, value2);
         assertEquals(value2, map.get(key3));
         assertEquals(2, map.size());
     }
-    
+
     /**
      * Similar to testPutKeysWithCollisions() but exercises the codepaths in a slightly
      * different manner.
@@ -293,7 +293,7 @@
         map.put(key2, value1);
         assertEquals(2, map.size());
         assertEquals(value1, map.get(key2));
-        
+
         map.remove(key1);
         double value2 = 2.0;
         map.put(key2, value2);

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/OpenIntToFieldTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/OpenIntToFieldTest.java?rev=811685&r1=811684&r2=811685&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/OpenIntToFieldTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/OpenIntToFieldTest.java
Sat Sep  5 17:36:48 2009
@@ -5,9 +5,9 @@
  * 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.
@@ -62,7 +62,7 @@
         Random r = new Random();
         double dd=0;
         for (int i = 0; i < 2000; ++i)
-            dd = r.nextDouble(); 
+            dd = r.nextDouble();
             try {
                 map.put(r.nextInt(), new Fraction(dd));
             } catch (FractionConversionException e) {
@@ -78,12 +78,12 @@
         }
         return map;
     }
-    
+
     public void testPutAndGetWith0ExpectedSize() {
         OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field,0);
         assertPutAndGet(map);
     }
-    
+
     public void testPutAndGetWithExpectedSize() {
         OpenIntToFieldHashMap<Fraction> map = new OpenIntToFieldHashMap<Fraction>(field,500);
         assertPutAndGet(map);
@@ -132,7 +132,7 @@
     public void testGetAbsent() {
         Map<Integer, Fraction> generated = generateAbsent();
         OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field);
-        
+
         for (Map.Entry<Integer, Fraction> mapEntry : generated.entrySet())
             assertTrue(field.getZero().equals(map.get(mapEntry.getKey())));
     }
@@ -187,7 +187,7 @@
 
         OpenIntToFieldHashMap<Fraction> map = createFromJavaMap(field);
         int mapSize = map.size();
-        
+
         for (Map.Entry<Integer, Fraction> mapEntry : generated.entrySet()) {
             map.remove(mapEntry.getKey());
             assertEquals(mapSize, map.size());
@@ -282,14 +282,14 @@
         map.put(key3, value1);
         assertEquals(value1, map.get(key3));
         assertEquals(3, map.size());
-        
+
         map.remove(key2);
         Fraction value2 = new Fraction(2);
         map.put(key3, value2);
         assertEquals(value2, map.get(key3));
         assertEquals(2, map.size());
     }
-    
+
     /**
      * Similar to testPutKeysWithCollisions() but exercises the codepaths in a slightly
      * different manner.
@@ -303,7 +303,7 @@
         map.put(key2, value1);
         assertEquals(2, map.size());
         assertEquals(value1, map.get(key2));
-        
+
         map.remove(key1);
         Fraction value2 = new Fraction(2);
         map.put(key2, value2);

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ResizableDoubleArrayTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ResizableDoubleArrayTest.java?rev=811685&r1=811684&r2=811685&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ResizableDoubleArrayTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/ResizableDoubleArrayTest.java
Sat Sep  5 17:36:48 2009
@@ -5,9 +5,9 @@
  * 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.
@@ -21,11 +21,11 @@
 
 /**
  * This class contains test cases for the ResizableDoubleArray.
- * 
+ *
  * @version $Revision$ $Date$
  */
 public class ResizableDoubleArrayTest extends DoubleArrayAbstractTest {
-    
+
     public ResizableDoubleArrayTest(String name) {
         super( name );
     }
@@ -35,18 +35,18 @@
         da = null;
         ra = null;
     }
-       
+
     @Override
     protected void setUp() throws Exception {
         da = new ResizableDoubleArray();
         ra = new ResizableDoubleArray();
     }
-    
+
     public void testConstructors() {
         float defaultExpansionFactor = 2.0f;
         float defaultContractionCriteria = 2.5f;
         int defaultMode = ResizableDoubleArray.MULTIPLICATIVE_MODE;
-        
+
         ResizableDoubleArray testDa = new ResizableDoubleArray(2);
         assertEquals(0, testDa.getNumElements());
         assertEquals(2, testDa.getInternalLength());
@@ -59,88 +59,88 @@
         } catch (IllegalArgumentException ex) {
             // expected
         }
-        
+
         testDa = new ResizableDoubleArray(2, 2.0f);
         assertEquals(0, testDa.getNumElements());
         assertEquals(2, testDa.getInternalLength());
         assertEquals(defaultExpansionFactor, testDa.getExpansionFactor(), 0);
         assertEquals(defaultContractionCriteria, testDa.getContractionCriteria(), 0);
         assertEquals(defaultMode, testDa.getExpansionMode());
-        
+
         try {
             da = new ResizableDoubleArray(2, 0.5f);
             fail("Expecting IllegalArgumentException");
         } catch (IllegalArgumentException ex) {
             // expected
         }
-        
+
         testDa = new ResizableDoubleArray(2, 3.0f);
         assertEquals(3.0f, testDa.getExpansionFactor(), 0);
         assertEquals(3.5f, testDa.getContractionCriteria(), 0);
-        
+
         testDa = new ResizableDoubleArray(2, 2.0f, 3.0f);
         assertEquals(0, testDa.getNumElements());
         assertEquals(2, testDa.getInternalLength());
         assertEquals(defaultExpansionFactor, testDa.getExpansionFactor(), 0);
         assertEquals(3.0f, testDa.getContractionCriteria(), 0);
         assertEquals(defaultMode, testDa.getExpansionMode());
-        
+
         try {
             da = new ResizableDoubleArray(2, 2.0f, 1.5f);
             fail("Expecting IllegalArgumentException");
         } catch (IllegalArgumentException ex) {
             // expected
         }
-        
-        testDa = new ResizableDoubleArray(2, 2.0f, 3.0f, 
+
+        testDa = new ResizableDoubleArray(2, 2.0f, 3.0f,
                 ResizableDoubleArray.ADDITIVE_MODE);
         assertEquals(0, testDa.getNumElements());
         assertEquals(2, testDa.getInternalLength());
         assertEquals(defaultExpansionFactor, testDa.getExpansionFactor(), 0);
         assertEquals(3.0f, testDa.getContractionCriteria(), 0);
-        assertEquals(ResizableDoubleArray.ADDITIVE_MODE, 
+        assertEquals(ResizableDoubleArray.ADDITIVE_MODE,
                 testDa.getExpansionMode());
-        
+
         try {
             da = new ResizableDoubleArray(2, 2.0f, 2.5f, -1);
             fail("Expecting IllegalArgumentException");
         } catch (IllegalArgumentException ex) {
             // expected
         }
-        
+
         // Copy constructor
-        testDa = new ResizableDoubleArray(2, 2.0f, 3.0f, 
+        testDa = new ResizableDoubleArray(2, 2.0f, 3.0f,
                 ResizableDoubleArray.ADDITIVE_MODE);
         testDa.addElement(2.0);
         testDa.addElement(3.2);
         ResizableDoubleArray copyDa = new ResizableDoubleArray(testDa);
         assertEquals(copyDa, testDa);
-        assertEquals(testDa, copyDa);   
+        assertEquals(testDa, copyDa);
     }
-    
-    
+
+
     public void testSetElementArbitraryExpansion() {
-        
-        // MULTIPLICATIVE_MODE 
+
+        // MULTIPLICATIVE_MODE
         da.addElement(2.0);
         da.addElement(4.0);
         da.addElement(6.0);
         da.setElement(1, 3.0);
-        
+
         // Expand the array arbitrarily to 1000 items
         da.setElement(1000, 3.4);
-        
-        assertEquals( "The number of elements should now be 1001, it isn't", 
+
+        assertEquals( "The number of elements should now be 1001, it isn't",
                 da.getNumElements(), 1001);
-        
+
         assertEquals( "Uninitialized Elements are default value of 0.0, index 766 wasn't",
0.0,
                 da.getElement( 760 ), Double.MIN_VALUE );
-        
-        assertEquals( "The 1000th index should be 3.4, it isn't", 3.4, da.getElement(1000),

+
+        assertEquals( "The 1000th index should be 3.4, it isn't", 3.4, da.getElement(1000),
                 Double.MIN_VALUE );
-        assertEquals( "The 0th index should be 2.0, it isn't", 2.0, da.getElement(0), 
-                Double.MIN_VALUE); 
-        
+        assertEquals( "The 0th index should be 2.0, it isn't", 2.0, da.getElement(0),
+                Double.MIN_VALUE);
+
         // Make sure numElements and expansion work correctly for expansion boundary cases
         da.clear();
         da.addElement(2.0);
@@ -157,24 +157,24 @@
         da.setElement(9, 10.0);
         assertEquals(11, ((ResizableDoubleArray) da).getInternalLength());
         assertEquals(11, da.getNumElements());
-        
+
         try {
             da.setElement(-2, 3);
             fail("Expecting ArrayIndexOutOfBoundsException for negative index");
         } catch (ArrayIndexOutOfBoundsException ex) {
             // expected
         }
-        
+
         // ADDITIVE_MODE
-        
-        ResizableDoubleArray testDa = new ResizableDoubleArray(2, 2.0f, 3.0f, 
+
+        ResizableDoubleArray testDa = new ResizableDoubleArray(2, 2.0f, 3.0f,
                 ResizableDoubleArray.ADDITIVE_MODE);
         assertEquals(2, testDa.getInternalLength());
         testDa.addElement(1d);
         testDa.addElement(1d);
         assertEquals(2, testDa.getInternalLength());
         testDa.addElement(1d);
-        assertEquals(4, testDa.getInternalLength());         
+        assertEquals(4, testDa.getInternalLength());
     }
 
     @Override
@@ -188,7 +188,7 @@
     @Override
     public void testAddElementRolling() {
         super.testAddElementRolling();
-        
+
         // MULTIPLICATIVE_MODE
         da.clear();
         da.addElement(1);
@@ -203,10 +203,10 @@
         da.addElementRolling(6);
         assertEquals(4, da.getElement(0), 0);
         assertEquals(5, da.getElement(1), 0);
-        assertEquals(6, da.getElement(2), 0);   
-        
+        assertEquals(6, da.getElement(2), 0);
+
         // ADDITIVE_MODE  (x's are occupied storage locations, 0's are open)
-        ResizableDoubleArray testDa = new ResizableDoubleArray(2, 2.0f, 2.5f, 
+        ResizableDoubleArray testDa = new ResizableDoubleArray(2, 2.0f, 2.5f,
                 ResizableDoubleArray.ADDITIVE_MODE);
         assertEquals(2, testDa.getInternalLength());
         testDa.addElement(1d); // x,0
@@ -214,27 +214,27 @@
         testDa.addElement(3d); // x,x,x,0 -- expanded
         assertEquals(1d, testDa.getElement(0), 0);
         assertEquals(2d, testDa.getElement(1), 0);
-        assertEquals(3d, testDa.getElement(2), 0);   
-        assertEquals(4, testDa.getInternalLength());  // x,x,x,0 
+        assertEquals(3d, testDa.getElement(2), 0);
+        assertEquals(4, testDa.getInternalLength());  // x,x,x,0
         assertEquals(3, testDa.getNumElements());
         testDa.addElementRolling(4d);
         assertEquals(2d, testDa.getElement(0), 0);
         assertEquals(3d, testDa.getElement(1), 0);
-        assertEquals(4d, testDa.getElement(2), 0);   
+        assertEquals(4d, testDa.getElement(2), 0);
         assertEquals(4, testDa.getInternalLength());  // 0,x,x,x
         assertEquals(3, testDa.getNumElements());
         testDa.addElementRolling(5d);   // 0,0,x,x,x,0 -- time to contract
         assertEquals(3d, testDa.getElement(0), 0);
         assertEquals(4d, testDa.getElement(1), 0);
-        assertEquals(5d, testDa.getElement(2), 0);   
-        assertEquals(4, testDa.getInternalLength());  // contracted -- x,x,x,0     
+        assertEquals(5d, testDa.getElement(2), 0);
+        assertEquals(4, testDa.getInternalLength());  // contracted -- x,x,x,0
         assertEquals(3, testDa.getNumElements());
         try {
             testDa.getElement(4);
             fail("Expecting ArrayIndexOutOfBoundsException");
         } catch (ArrayIndexOutOfBoundsException ex) {
             // expected
-        }  
+        }
         try {
             testDa.getElement(-1);
             fail("Expecting ArrayIndexOutOfBoundsException");
@@ -242,7 +242,7 @@
             // expected
         }
     }
-    
+
     public void testSetNumberOfElements() {
         da.addElement( 1.0 );
         da.addElement( 1.0 );
@@ -251,64 +251,64 @@
         da.addElement( 1.0 );
         da.addElement( 1.0 );
         assertEquals( "Number of elements should equal 6", da.getNumElements(), 6);
-        
+
         ((ResizableDoubleArray) da).setNumElements( 3 );
         assertEquals( "Number of elements should equal 3", da.getNumElements(), 3);
-        
+
         try {
             ((ResizableDoubleArray) da).setNumElements( -3 );
             fail( "Setting number of elements to negative should've thrown an exception");
         } catch( IllegalArgumentException iae ) {
         }
-        
+
         ((ResizableDoubleArray) da).setNumElements(1024);
         assertEquals( "Number of elements should now be 1024", da.getNumElements(), 1024);
         assertEquals( "Element 453 should be a default double", da.getElement( 453 ), 0.0,
Double.MIN_VALUE);
-        
+
     }
-    
+
     public void testWithInitialCapacity() {
-        
+
         ResizableDoubleArray eDA2 = new ResizableDoubleArray(2);
         assertEquals("Initial number of elements should be 0", 0, eDA2.getNumElements());
-        
+
         RandomData randomData = new RandomDataImpl();
         int iterations = randomData.nextInt(100, 1000);
-        
+
         for( int i = 0; i < iterations; i++) {
             eDA2.addElement( i );
         }
-        
+
         assertEquals("Number of elements should be equal to " + iterations, iterations, eDA2.getNumElements());
-        
+
         eDA2.addElement( 2.0 );
-        
+
         assertEquals("Number of elements should be equals to " + (iterations +1),
                 iterations + 1 , eDA2.getNumElements() );
     }
-    
+
     public void testWithInitialCapacityAndExpansionFactor() {
-        
+
         ResizableDoubleArray eDA3 = new ResizableDoubleArray(3, 3.0f, 3.5f);
         assertEquals("Initial number of elements should be 0", 0, eDA3.getNumElements() );
-        
+
         RandomData randomData = new RandomDataImpl();
         int iterations = randomData.nextInt(100, 3000);
-        
+
         for( int i = 0; i < iterations; i++) {
             eDA3.addElement( i );
         }
-        
+
         assertEquals("Number of elements should be equal to " + iterations, iterations,eDA3.getNumElements());
-        
+
         eDA3.addElement( 2.0 );
-        
+
         assertEquals("Number of elements should be equals to " + (iterations +1),
                 iterations +1, eDA3.getNumElements() );
-        
+
         assertEquals("Expansion factor should equal 3.0", 3.0f, eDA3.getExpansionFactor(),
Double.MIN_VALUE);
     }
-    
+
     public void testDiscard() {
         da.addElement(2.0);
         da.addElement(2.0);
@@ -322,7 +322,7 @@
         da.addElement(2.0);
         da.addElement(2.0);
         assertEquals( "Number of elements should be 11", 11, da.getNumElements());
-        
+
         ((ResizableDoubleArray)da).discardFrontElements(5);
         assertEquals( "Number of elements should be 6", 6, da.getNumElements());
 
@@ -334,7 +334,7 @@
 
         ((ResizableDoubleArray)da).discardMostRecentElements(2);
         assertEquals( "Number of elements should be 8", 8, da.getNumElements());
-        
+
         try {
             ((ResizableDoubleArray)da).discardFrontElements(-1);
             fail( "Trying to discard a negative number of element is not allowed");
@@ -362,7 +362,7 @@
     }
 
     public void testSubstitute() {
-    
+
         da.addElement(2.0);
         da.addElement(2.0);
         da.addElement(2.0);
@@ -375,7 +375,7 @@
         da.addElement(2.0);
         da.addElement(2.0);
         assertEquals( "Number of elements should be 11", 11, da.getNumElements());
-        
+
         ((ResizableDoubleArray)da).substituteMostRecentElement(24);
 
         assertEquals( "Number of elements should be 11", 11, da.getNumElements());
@@ -391,11 +391,11 @@
         assertEquals( "Number of elements should be 1", 1, da.getNumElements());
 
     }
-    
+
     public void testMutators() {
         ((ResizableDoubleArray)da).setContractionCriteria(10f);
         assertEquals(10f, ((ResizableDoubleArray)da).getContractionCriteria(), 0);
-        ((ResizableDoubleArray)da).setExpansionFactor(8f);  
+        ((ResizableDoubleArray)da).setExpansionFactor(8f);
         assertEquals(8f, ((ResizableDoubleArray)da).getExpansionFactor(), 0);
         try {
             ((ResizableDoubleArray)da).setExpansionFactor(11f);  // greater than contractionCriteria
@@ -405,7 +405,7 @@
         }
         ((ResizableDoubleArray)da).setExpansionMode(
                 ResizableDoubleArray.ADDITIVE_MODE);
-        assertEquals(ResizableDoubleArray.ADDITIVE_MODE, 
+        assertEquals(ResizableDoubleArray.ADDITIVE_MODE,
                 ((ResizableDoubleArray)da).getExpansionMode());
         try {
             ((ResizableDoubleArray)da).setExpansionMode(-1);
@@ -414,25 +414,25 @@
             // expected
         }
     }
-    
+
     public void testEqualsAndHashCode() throws Exception {
-        
+
         // Wrong type
         ResizableDoubleArray first = new ResizableDoubleArray();
         Double other = new Double(2);
         assertFalse(first.equals(other));
-        
+
         // Null
         other = null;
         assertFalse(first.equals(other));
-        
+
         // Reflexive
         assertTrue(first.equals(first));
-        
+
         // Argumentless constructor
         ResizableDoubleArray second = new ResizableDoubleArray();
         verifyEquality(first, second);
-        
+
         // Equals iff same data, same properties
         ResizableDoubleArray third = new ResizableDoubleArray(3, 2.0f, 2.0f);
         verifyInequality(third, first);
@@ -447,7 +447,7 @@
         fourth.addElement(4.2);
         fourth.addElement(4.3);
         verifyEquality(third, fourth);
-        
+
         // expand
         fourth.addElement(4.4);
         verifyInequality(third, fourth);
@@ -460,47 +460,47 @@
         fourth.addElementRolling(4.5);
         third.addElementRolling(4.5);
         verifyEquality(third, fourth);
-        
+
         // discard
         third.discardFrontElements(1);
         verifyInequality(third, fourth);
         fourth.discardFrontElements(1);
         verifyEquality(third, fourth);
-        
+
         // discard recent
         third.discardMostRecentElements(2);
         fourth.discardMostRecentElements(2);
         verifyEquality(third, fourth);
-        
+
         // wrong order
         third.addElement(18);
         fourth.addElement(17);
         third.addElement(17);
         fourth.addElement(18);
         verifyInequality(third, fourth);
-        
+
         // copy
         ResizableDoubleArray.copy(fourth, fifth);
         verifyEquality(fourth, fifth);
-        
+
         // Copy constructor
         verifyEquality(fourth, new ResizableDoubleArray(fourth));
-        
+
         // Instance copy
-        verifyEquality(fourth, fourth.copy());   
-             
+        verifyEquality(fourth, fourth.copy());
+
     }
-    
+
     private void verifyEquality(ResizableDoubleArray a, ResizableDoubleArray b) {
         assertTrue(b.equals(a));
         assertTrue(a.equals(b));
-        assertEquals(a.hashCode(), b.hashCode());    
+        assertEquals(a.hashCode(), b.hashCode());
     }
-    
+
     private void verifyInequality(ResizableDoubleArray a, ResizableDoubleArray b) {
         assertFalse(b.equals(a));
         assertFalse(a.equals(b));
         assertFalse(a.hashCode() == b.hashCode());
     }
-    
+
 }

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/TestBean.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/TestBean.java?rev=811685&r1=811684&r2=811685&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/TestBean.java (original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/TestBean.java Sat
Sep  5 17:36:48 2009
@@ -5,9 +5,9 @@
  * 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.
@@ -28,42 +28,42 @@
     private String y = "1.0";
 
     /**
-     * 
+     *
      */
     public Double getX() {
         return x;
     }
 
     /**
-     * 
+     *
      */
     public String getY() {
         return y;
     }
 
     /**
-     * 
+     *
      */
     public void setX(Double double1) {
         x = double1;
     }
 
     /**
-     * 
+     *
      */
     public void setY(String string) {
         y = string;
     }
-    
+
     /**
-     * 
+     *
      */
     public Double getZ() {
         throw new MathRuntimeException("?");
     }
 
     /**
-     * 
+     *
      */
     public void setZ(Double double1) {
     }

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/TransformerMapTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/TransformerMapTest.java?rev=811685&r1=811684&r2=811685&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/TransformerMapTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/util/TransformerMapTest.java
Sat Sep  5 17:36:48 2009
@@ -5,9 +5,9 @@
  * 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.
@@ -26,18 +26,18 @@
  */
 public class TransformerMapTest extends TestCase {
     /**
-     * 
+     *
      */
     public void testPutTransformer(){
         NumberTransformer expected = new DefaultTransformer();
-        
+
         TransformerMap map = new TransformerMap();
         map.putTransformer(TransformerMapTest.class, expected);
         assertEquals(expected, map.getTransformer(TransformerMapTest.class));
     }
-    
+
     /**
-     * 
+     *
      */
     public void testContainsClass(){
         NumberTransformer expected = new DefaultTransformer();
@@ -45,9 +45,9 @@
         map.putTransformer(TransformerMapTest.class, expected);
         assertTrue(map.containsClass(TransformerMapTest.class));
     }
-    
+
     /**
-     * 
+     *
      */
     public void testContainsTransformer(){
         NumberTransformer expected = new DefaultTransformer();
@@ -57,11 +57,11 @@
     }
 
     /**
-     * 
+     *
      */
     public void testRemoveTransformer(){
         NumberTransformer expected = new DefaultTransformer();
-        
+
         TransformerMap map = new TransformerMap();
         map.putTransformer(TransformerMapTest.class, expected);
         assertTrue(map.containsClass(TransformerMapTest.class));
@@ -72,20 +72,20 @@
     }
 
     /**
-     * 
+     *
      */
     public void testClear(){
         NumberTransformer expected = new DefaultTransformer();
-        
+
         TransformerMap map = new TransformerMap();
         map.putTransformer(TransformerMapTest.class, expected);
         assertTrue(map.containsClass(TransformerMapTest.class));
         map.clear();
         assertFalse(map.containsClass(TransformerMapTest.class));
     }
-    
+
     /**
-     * 
+     *
      */
     public void testClasses(){
         NumberTransformer expected = new DefaultTransformer();
@@ -93,9 +93,9 @@
         map.putTransformer(TransformerMapTest.class, expected);
         assertTrue(map.classes().contains(TransformerMapTest.class));
     }
-    
+
     /**
-     * 
+     *
      */
     public void testTransformers(){
         NumberTransformer expected = new DefaultTransformer();



Mime
View raw message