Added integration test for fisher option (compare with epsilon value). Fixed scientific notation of numbers in expected VCF.

Author: PolinaBevad

src/main/java/com/astrazeneca/vardict/data/fishertest/FisherExact.java

@@ -33,9 +33,11 @@ public class FisherExact {
     private double PvalueLess;
     private double PvalueGreater;
     private double PvalueTwoSided;
-
     private List<Integer> support;
 
+    // Seems that Java and R have differences with round half even (JDK-8227248 example, it will round value in memory)
+    public static double RESULT_ROUND_R = 1E5;
+
     public FisherExact(int refFwd, int refRev, int altFwd, int altRev) {
         m = refFwd + refRev;
         n = altFwd + altRev;
@@ -47,8 +49,8 @@ public FisherExact(int refFwd, int refRev, int altFwd, int altRev) {
         for (int j = lo; j <= hi; j++) {
             support.add(j);
         }
-
         logdc = logdcDhyper(m, n, k);
+
         calculatePValue();
     }
 
@@ -66,7 +68,7 @@ private List<Double> logdcDhyper(int m, int n, int k) {
             if (value.isNaN()) {
                 value = 0.0;
             }
-            logdc.add(value);
+            logdc.add(roundHalfEven("0.0000000", value));
         }
         return logdc;
     }
@@ -129,14 +131,12 @@ public String getOddRatio() {
         } else if (oddRatio == Math.round(oddRatio)) {
             return new DecimalFormat("0").format(oddRatio);
         } else {
-            return String.valueOf(roundHalfEven("0.00000", oddRatio));
+            return String.valueOf(round_as_r(oddRatio));
         }
     }
 
     public double getPValue() {
-        double pValue = PvalueTwoSided;
-        double pValueRound = roundHalfEven("0.00000", pValue);
-        return pValueRound == 0.0 ? 0 : (pValueRound == 1.0 ? 1 : pValueRound);
+        return round_as_r(PvalueTwoSided);
     }
 
     public List<Double> getLogdc() {
@@ -145,15 +145,18 @@ public List<Double> getLogdc() {
     }
 
     public double getPValueGreater() {
-        double pValueGreater = PvalueGreater;
-        double pValueRound = roundHalfEven("0.00000", pValueGreater);
-        return pValueRound == 0.0 ? 0 : (pValueRound == 1.0 ? 1 : pValueRound);
+        return round_as_r(PvalueGreater);
     }
 
     public double getPValueLess() {
-        double pValueLess = PvalueLess;
-        double pValueRound = roundHalfEven("0.00000", pValueLess);
-        return pValueRound == 0.0 ? 0 : (pValueRound == 1.0 ? 1 : pValueRound);
+        return round_as_r(PvalueLess);
+    }
+
+    private double round_as_r(double value) {
+        value = roundHalfEven("0", value * RESULT_ROUND_R);
+        value = value/RESULT_ROUND_R;
+        value = value == 0.0 ? 0 : (value == 1.0 ? 1 : value);
+        return value;
     }
 
     private void calculatePValue() {

src/test/java/com/astrazeneca/vardict/data/fishertest/FisherExact_Test.java

@@ -7,19 +7,21 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import static com.astrazeneca.vardict.Utils.roundHalfEven;
+
 public class FisherExact_Test {
     @Test
     public void test_logdc() {
         FisherExact fisher_test = new FisherExact(11, 12, 1, 2);
         List<Double> logdc = fisher_test.getLogdc();
         List<Double> expected = new ArrayList<Double>() {{
-            add(-2.469639177657212);
-            add(-1.0345546523678895);
-            add(-0.867500567704723);
-            add(-1.9661128563728325);
+            add(-2.4696392);
+            add(-1.0345547);
+            add(-0.8675006);
+            add(-1.9661129);
         }};
         Assert.assertTrue(logdc.equals(expected));
-        // -2.4696392 -1.0345547 -0.8675006 -1.966112
+        // -2.4696392 -1.0345547 -0.8675006 -1.9661129
     }
 
     @DataProvider(name = "counts")
@@ -37,26 +39,29 @@ public Object[][] counts() {
                 { new FisherExact(10, 10, 10, 1), 0.04722, 0.02599, 0.99802, 0.10703 },
                 { new FisherExact(10, 10, 10, 0), 0.01099, 0.00615, 1.0, 0.0 },
                 { new FisherExact(69,1,	74,	95), 0.0, 1.0, 0.0, 87.68597 },
+                { new FisherExact(41, 86,	1,	1), 0.54688, 0.54687, 0.89571, 0.47973 },
+                { new FisherExact(130, 189,	1,	0), 0.40937, 0.40937, 1.0, 0.0 }, // R: 0.409375 round to 0.40938 in both
+                { new FisherExact(83,  40,	1,	2), 0.25746, 0.96473, 0.25746, 4.09908 },
+                { new FisherExact(74, 117,	1,	0), 0.39062, 0.39063, 1.0, 0.0 },
+                { new FisherExact(60, 62,	2, 0), 0.49593, 0.24797, 1.0, 0.0 },
+                { new FisherExact(43, 83,	1, 1), 1.0, 0.57111, 0.88361, 0.52091 },
+                { new FisherExact(78,	40,	1,	1), 1.0, 0.88515, 0.56849, 1.93844 },
         };
     }
 
     @Test(dataProvider = "counts")
     public void test_fexact(FisherExact fisherExact,
                             double pvalue, double pvalueLess, double pValueGreater, double oddRatio) {
         double p = fisherExact.getPValue();
-        System.err.println(p);
-        assert p == pvalue;
+        assert roundHalfEven("0.00000", p) == pvalue;
 
         p = fisherExact.getPValueLess();
-        System.err.println(p);
-        assert p == pvalueLess;
+        assert roundHalfEven("0.00000", p)  == pvalueLess;
 
         p = fisherExact.getPValueGreater();
-        System.err.println(p);
-        assert p == pValueGreater;
+        assert roundHalfEven("0.00000", p)  == pValueGreater;
 
         String odd = fisherExact.getOddRatio();
-        System.err.println(odd);
-        assert Double.valueOf(odd) == oddRatio;
+        assert roundHalfEven("0.00000", Double.valueOf(odd)) == oddRatio;
     }
 }