X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fmath%2FMatrixTest.java;h=bd4108c231511eff1953656e0a5a853aafb99537;hb=567c2595554096f10feab130153f97286f3f7d80;hp=0d066ddebde144afe42e881afbecd86a3329378b;hpb=d6a30c6516e8e2f923c8c2f6dce7592cb3b7d974;p=jalview.git

diff --git a/test/jalview/math/MatrixTest.java b/test/jalview/math/MatrixTest.java
index 0d066dd..bd4108c 100644
--- a/test/jalview/math/MatrixTest.java
+++ b/test/jalview/math/MatrixTest.java
@@ -1,6 +1,7 @@
 package jalview.math;
 
 import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertNull;
 import static org.testng.Assert.assertTrue;
 import static org.testng.Assert.fail;
 
@@ -12,7 +13,7 @@ import org.testng.internal.junit.ArrayAsserts;
 
 public class MatrixTest
 {
-  final static double DELTA = 0.0001d;
+  final static double DELTA = 0.000001d;
 
   @Test(groups = "Timing")
   public void testPreMultiply_timing()
@@ -380,54 +381,137 @@ public class MatrixTest
   }
 
   @Test(groups = "Functional")
-  public void testGetMaxValue() {
+  public void testFindMinMax()
+  {
+    /*
+     * empty matrix case
+     */
+    Matrix m = new Matrix(new double[][] { {} });
+    assertNull(m.findMinMax());
+
+    /*
+     * normal case
+     */
     double[][] vals = new double[2][];
     vals[0] = new double[] {7d, 1d, -2.3d};
     vals[1] = new double[] {-12d, 94.3d, -102.34d};
-    MatrixI m = new Matrix(vals);
-    assertEquals(m.getMaxValue(), 94.3d);
+    m = new Matrix(vals);
+    double[] minMax = m.findMinMax();
+    assertEquals(minMax[0], -102.34d);
+    assertEquals(minMax[1], 94.3d);
   }
 
   @Test(groups = { "Functional", "Timing" })
-  public void testGetMaxValue_timing()
+  public void testFindMinMax_timing()
   {
     Random r = new Random();
     int size = 1000; // increase to stress test timing
     double[][] vals = new double[size][size];
     double max = -Double.MAX_VALUE;
+    double min = Double.MAX_VALUE;
     for (int i = 0; i < size; i++)
     {
       vals[i] = new double[size];
       for (int j = 0; j < size; j++)
       {
-        double d = r.nextDouble();
+        // use nextLong rather than nextDouble to include negative values
+        double d = r.nextLong();
         if (d > max)
         {
           max = d;
         }
+        if (d < min)
+        {
+          min = d;
+        }
         vals[i][j] = d;
       }
-      i++;
     }
-    MatrixI m = new Matrix(vals);
+    Matrix m = new Matrix(vals);
     long now = System.currentTimeMillis();
-    double theMax = m.getMaxValue();
-    System.out.println(String.format("getMaxValue for %d x %d took %dms",
+    double[] minMax = m.findMinMax();
+    System.out.println(String.format("findMinMax for %d x %d took %dms",
             size, size, (System.currentTimeMillis() - now)));
-    assertEquals(theMax, max);
+    assertEquals(minMax[0], min);
+    assertEquals(minMax[1], max);
   }
 
+  /**
+   * Test range reversal with maximum value becoming zero
+   */
   @Test(groups = "Functional")
-  public void testSubtractAllFrom()
+  public void testReverseRange_maxToZero()
   {
-    Matrix m1 = new Matrix(new double[][] { { 2, 3, 4 }, { -3, 4, 15 } });
-    m1.subtractAllFrom(12.5);
-    assertEquals(m1.getValue(0, 0), 10.5d);
-    assertEquals(m1.getValue(0, 1), 9.5d);
-    assertEquals(m1.getValue(0, 2), 8.5d);
-    assertEquals(m1.getValue(1, 0), 15.5d);
-    assertEquals(m1.getValue(1, 1), 8.5d);
-    assertEquals(m1.getValue(1, 2), -2.5d);
+    Matrix m1 = new Matrix(
+            new double[][] { { 2, 3.5, 4 }, { -3.4, 4, 15 } });
+
+    /*
+     * subtract all from max: range -3.4 to 15 becomes 18.4 to 0
+     */
+    m1.reverseRange(true);
+    assertEquals(m1.getValue(0, 0), 13d, DELTA);
+    assertEquals(m1.getValue(0, 1), 11.5d, DELTA);
+    assertEquals(m1.getValue(0, 2), 11d, DELTA);
+    assertEquals(m1.getValue(1, 0), 18.4d, DELTA);
+    assertEquals(m1.getValue(1, 1), 11d, DELTA);
+    assertEquals(m1.getValue(1, 2), 0d, DELTA);
+
+    /*
+     * repeat operation - range is now 0 to 18.4
+     */
+    m1.reverseRange(true);
+    assertEquals(m1.getValue(0, 0), 5.4d, DELTA);
+    assertEquals(m1.getValue(0, 1), 6.9d, DELTA);
+    assertEquals(m1.getValue(0, 2), 7.4d, DELTA);
+    assertEquals(m1.getValue(1, 0), 0d, DELTA);
+    assertEquals(m1.getValue(1, 1), 7.4d, DELTA);
+    assertEquals(m1.getValue(1, 2), 18.4d, DELTA);
   }
 
+  /**
+   * Test range reversal with minimum and maximum values swapped
+   */
+  @Test(groups = "Functional")
+  public void testReverseRange_swapMinMax()
+  {
+    Matrix m1 = new Matrix(
+            new double[][] { { 2, 3.5, 4 }, { -3.4, 4, 15 } });
+  
+    /*
+     * swap all values in min-max range
+     * = subtract from (min + max = 11.6) 
+     * range -3.4 to 15 becomes 18.4 to -3.4
+     */
+    m1.reverseRange(false);
+    assertEquals(m1.getValue(0, 0), 9.6d, DELTA);
+    assertEquals(m1.getValue(0, 1), 8.1d, DELTA);
+    assertEquals(m1.getValue(0, 2), 7.6d, DELTA);
+    assertEquals(m1.getValue(1, 0), 15d, DELTA);
+    assertEquals(m1.getValue(1, 1), 7.6d, DELTA);
+    assertEquals(m1.getValue(1, 2), -3.4d, DELTA);
+  
+    /*
+     * repeat operation - original values restored
+     */
+    m1.reverseRange(false);
+    assertEquals(m1.getValue(0, 0), 2d, DELTA);
+    assertEquals(m1.getValue(0, 1), 3.5d, DELTA);
+    assertEquals(m1.getValue(0, 2), 4d, DELTA);
+    assertEquals(m1.getValue(1, 0), -3.4d, DELTA);
+    assertEquals(m1.getValue(1, 1), 4d, DELTA);
+    assertEquals(m1.getValue(1, 2), 15d, DELTA);
+  }
+
+  @Test(groups = "Functional")
+  public void testMultiply()
+  {
+    Matrix m = new Matrix(new double[][] { { 2, 3.5, 4 }, { -3.4, 4, 15 } });
+    m.multiply(2d);
+    assertEquals(m.getValue(0, 0), 4d, DELTA);
+    assertEquals(m.getValue(0, 1), 7d, DELTA);
+    assertEquals(m.getValue(0, 2), 8d, DELTA);
+    assertEquals(m.getValue(1, 0), -6.8d, DELTA);
+    assertEquals(m.getValue(1, 1), 8d, DELTA);
+    assertEquals(m.getValue(1, 2), 30d, DELTA);
+  }
 }