GofFormat.java

/*
 * Class:        GofFormat
 * Description:
 * Environment:  Java
 * Software:     SSJ
 * Copyright (C) 2001  Pierre L'Ecuyer and Universite de Montreal
 * Organization: DIRO, Universite de Montreal
 * @author
 * @since
 *
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
package umontreal.ssj.gof;
 
import cern.colt.list.*;
import umontreal.ssj.util.PrintfFormat;
import umontreal.ssj.probdist.*;
import java.io.PrintWriter;

public class GofFormat {
   private GofFormat() {
   }


   public static final int GNUPLOT = 0;

   public static final int MATHEMATICA = 1;

   public static int graphSoft = GNUPLOT;
 
   private static String formatMath2(double x, double y) {
      // Writes the pair (x, y) in file f, in a format understood
      // by Mathematica
      StringBuffer sb = new StringBuffer();
      String S;
 
      sb.append("   { ");
      if ((x != 0.0) && (x < 0.1 || x > 1.0)) {
         S = PrintfFormat.E(16, 7, x);
         int exppos = S.indexOf('E');
         if (exppos != -1)
            S = S.substring(0, exppos) + "*10^(" + S.substring(exppos + 1) + ")";
      } else
         S = PrintfFormat.g(16, 8, x);
 
      sb.append(S + ",     ");
 
      if (y != 0.0 && (y < 0.1 || y > 1.0)) {
         S = PrintfFormat.E(16, 7, y);
         int exppos = S.indexOf('E');
         if (exppos != -1)
            S = S.substring(0, exppos) + "*10^(" + S.substring(exppos + 1) + ")";
      } else
         S = PrintfFormat.g(16, 8, y);
 
      sb.append(S + " }");
      return sb.toString();
   }
 
   private static String graphFunc(ContinuousDistribution dist, double a, double b, int m, int mono, String desc) {
// Renommer drawCDF en fixant mono = 1 et éliminant mono.
      int i;
      double yprec, y, x, h;
      StringBuffer sb = new StringBuffer();
      String openComment = "";
      String closeComment = "";
      String openGraph = "";
      String closeGraph = "";
      if (mono != 1 && mono != -1)
         throw new IllegalArgumentException("mono must be 1 or -1");
      switch (graphSoft) {
      case GNUPLOT:
         openComment = "# ";
         closeComment = "";
         openGraph = "";
         closeGraph = PrintfFormat.NEWLINE;
         break;
      case MATHEMATICA:
         openComment = "(* ";
         closeComment = " *)";
         openGraph = "points = { " + PrintfFormat.NEWLINE;
         closeGraph = "}" + PrintfFormat.NEWLINE;
         break;
      }
 
      sb.append(openComment + "----------------------------------" + closeComment + PrintfFormat.NEWLINE);
      sb.append(openComment + PrintfFormat.s(-70, desc) + closeComment + PrintfFormat.NEWLINE + PrintfFormat.NEWLINE);
 
      sb.append(openGraph);
      h = (b - a) / m;
      if (mono == 1)
         yprec = -Double.MAX_VALUE;
      else if (mono == -1)
         yprec = Double.MAX_VALUE;
      else
         yprec = 0.0;
 
      for (i = 0; i <= m; i++) {
         x = a + i * h;
         y = mono == 1 ? dist.cdf(x) : dist.barF(x);
         switch (graphSoft) {
         case MATHEMATICA:
            sb.append(formatMath2(x, y));
            if (i < m)
               sb.append(',');
            break;
         default: // Default and GNUPLOT
            sb.append(PrintfFormat.g(20, 14, x) + "      " + PrintfFormat.g(20, 14, y));
         }
 
         switch (mono) {
         case 1:
            if (y < yprec)
               sb.append("    " + openComment + "  DECREASING" + closeComment);
            break;
         case -1:
            if (y > yprec)
               sb.append("    " + openComment + "  INCREASING" + closeComment);
            break;
         default:
            break;
         }
         sb.append(PrintfFormat.NEWLINE);
         yprec = y;
      }
      sb.append(closeGraph);
      return sb.toString();
   }

   public static String drawCdf(ContinuousDistribution dist, double a, double b, int m, String desc) {
      return graphFunc(dist, a, b, m, 1, desc);
   }

   public static String drawDensity(ContinuousDistribution dist, double a, double b, int m, String desc) {
      int i;
      double y, x, h;
      StringBuffer sb = new StringBuffer();
      String openComment = "";
      String closeComment = "";
      String openGraph = "";
      String closeGraph = "";
 
      switch (graphSoft) {
      case GNUPLOT:
         openComment = "# ";
         closeComment = "";
         openGraph = "";
         closeGraph = PrintfFormat.NEWLINE;
         break;
      case MATHEMATICA:
         openComment = "(* ";
         closeComment = " *)";
         openGraph = "points = { " + PrintfFormat.NEWLINE;
         closeGraph = "}" + PrintfFormat.NEWLINE;
         break;
      }
 
      sb.append(openComment + "----------------------------------" + closeComment + PrintfFormat.NEWLINE);
      sb.append(openComment + PrintfFormat.s(-70, desc) + closeComment + PrintfFormat.NEWLINE + PrintfFormat.NEWLINE);
 
      sb.append(openGraph);
      h = (b - a) / m;
 
      for (i = 0; i <= m; i++) {
         x = a + i * h;
         y = dist.density(x);
 
         switch (graphSoft) {
         case MATHEMATICA:
            sb.append(formatMath2(x, y));
            if (i < m)
               sb.append(',');
            break;
         default: // Default and GNUPLOT
            sb.append(PrintfFormat.g(16, 8, x) + "      " + PrintfFormat.g(16, 8, y));
         }
         sb.append(PrintfFormat.NEWLINE);
      }
      sb.append(closeGraph);
      return sb.toString();
   }

   public static String graphDistUnif(DoubleArrayList data, String desc) {
      double[] u = data.elements();
      int n = data.size();
      int i;
      double unSurN = 1.0 / n;
      StringBuffer sb = new StringBuffer();
 
      switch (graphSoft) {
      case GNUPLOT:
         sb.append("#----------------------------------" + PrintfFormat.NEWLINE);
         sb.append("# " + PrintfFormat.s(-70, desc) + PrintfFormat.NEWLINE + PrintfFormat.NEWLINE);
         sb.append(PrintfFormat.g(16, 8, 0.0) + "  " + PrintfFormat.g(16, 8, 0.0) + PrintfFormat.NEWLINE);
         for (i = 0; i < n; i++)
            sb.append(
                  PrintfFormat.g(16, 8, u[i]) + "  " + PrintfFormat.g(16, 8, (i + 1) * unSurN) + PrintfFormat.NEWLINE);
 
         sb.append(PrintfFormat.g(16, 8, 1.0) + "  " + PrintfFormat.g(16, 8, 1.0) + PrintfFormat.NEWLINE
               + PrintfFormat.NEWLINE);
         break;
      case MATHEMATICA:
         sb.append("(*----------------------------------*)" + PrintfFormat.NEWLINE);
         sb.append("(* " + PrintfFormat.s(-70, desc) + PrintfFormat.NEWLINE + " *)" + PrintfFormat.NEWLINE
               + PrintfFormat.NEWLINE + "points = { " + PrintfFormat.NEWLINE);
 
         sb.append(formatMath2(0.0, 0.0) + "," + PrintfFormat.NEWLINE);
         for (i = 0; i < n; i++)
            sb.append(formatMath2(u[i], (i + 1) * unSurN) + "," + PrintfFormat.NEWLINE);
         sb.append(formatMath2(1.0, 1.0) + PrintfFormat.NEWLINE);
         break;
      default:
         throw new IllegalArgumentException("graphSoft unknown");
      }
      return sb.toString();
   }



   public static double EPSILONP = 1.0E-15;

   public static double SUSPECTP = 0.01;

   public static String formatp0(double p) {
      // Formats the p-value of a test, without a descriptor
      if ((p >= 0.01) && (p <= 0.99))
         return PrintfFormat.format(8, 2, 1, p);
      else if (p < EPSILONP)
         return "   eps  ";
      else if (p < 0.01)
         return PrintfFormat.format(8, 2, 2, p);
      else if (p >= 1.0 - EPSILONP)
         return " 1 - eps ";
      else
         return " 1 - " + PrintfFormat.g(8, 2, 1.0 - p);
   }

   public static String formatp1(double p) {
      // Prints the p-value of a test, with a descriptor.
      StringBuffer sb = new StringBuffer();
      sb.append("p-value of test                       :" + formatp0(p));
      if (p < SUSPECTP || p > 1.0 - SUSPECTP)
         sb.append("    *****");
 
      sb.append(PrintfFormat.NEWLINE + PrintfFormat.NEWLINE);
      return sb.toString();
   }

   public static String formatp2(double x, double p) {
      // Prints the statistic x and its p-value p.
      return PrintfFormat.format(8, 2, 1, x) + PrintfFormat.NEWLINE + formatp1(p);
   }

   public static String formatp3(String testName, double x, double p) {
      final String SLT = "p-value of test";
      int l = Math.max(SLT.length(), testName.length());
      PrintfFormat pf = new PrintfFormat();
      pf.append(-l, testName).append(" : ").append(8, 2, 1, x).append(PrintfFormat.NEWLINE);
      pf.append(-l, SLT).append(" : ").append(formatp0(p));
      if (p < SUSPECTP || p > 1.0 - SUSPECTP)
         pf.append("    *****");
      pf.append(PrintfFormat.NEWLINE + PrintfFormat.NEWLINE);
      return pf.toString();
   }

   public static String formatChi2(int k, int d, double chi2) {
      StringBuffer sb = new StringBuffer();
      sb.append("Chi2 statistic                        : " + PrintfFormat.format(8, 2, 1, chi2));
      sb.append(PrintfFormat.NEWLINE + "p-value                               : "
            + formatp0(GofStat.pDisc(ChiSquareDist.cdf(k - 1, d, chi2), ChiSquareDist.barF(k - 1, d, chi2))));
      sb.append(PrintfFormat.NEWLINE + PrintfFormat.NEWLINE);
      return sb.toString();
   }

   public static String formatKS(int n, double dp, double dm, double d) {
      // Prints the results of a Kolmogorov-Smirnov test
      return "Kolmogorov-Smirnov+ statistic = D+    :" + formatp2(dp, KolmogorovSmirnovPlusDist.barF(n, dp))
            + "Kolmogorov-Smirnov- statistic = D-    :" + formatp2(dm, KolmogorovSmirnovPlusDist.barF(n, dm))
            + "Kolmogorov-Smirnov statistic = D      :" + formatp2(d, KolmogorovSmirnovDistQuick.barF(n, d))
            + PrintfFormat.NEWLINE + PrintfFormat.NEWLINE;
   }

   public static String formatKS(DoubleArrayList data, ContinuousDistribution dist) {
 
      double[] v = data.elements();
      int n = data.size();
 
      DoubleArrayList dataUnif = GofStat.unifTransform(data, dist);
      dataUnif.quickSortFromTo(0, dataUnif.size() - 1);
      double[] ret = GofStat.kolmogorovSmirnov(dataUnif);
      return formatKS(n, ret[0], ret[1], ret[2]);
   }

   public static String formatKSJumpOne(int n, double a, double dp) {
      double d = 1.0 - FDist.kolmogorovSmirnovPlusJumpOne(n, a, dp);
 
      return PrintfFormat.NEWLINE + "Kolmogorov-Smirnov+ statistic = D+    : " + PrintfFormat.g(8, 2, dp)
            + PrintfFormat.NEWLINE + formatp1(d) + PrintfFormat.NEWLINE;
   }

   public static String formatKSJumpOne(DoubleArrayList data, ContinuousDistribution dist, double a) {
 
      double[] v = data.elements();
      int n = data.size();
      DoubleArrayList dataUnif = GofStat.unifTransform(data, dist);
      dataUnif.quickSortFromTo(0, dataUnif.size() - 1);
      double[] ret = GofStat.kolmogorovSmirnovJumpOne(dataUnif, a);
      return formatKSJumpOne(n, a, ret[0]);
   }



   public static final int KSP = 0;

   public static final int KSM = 1;

   public static final int KS = 2;

   public static final int AD = 3;

   public static final int CM = 4;

   public static final int WG = 5;

   public static final int WU = 6;

   public static final int MEAN = 7;

   public static final int COR = 8;

   public static final int NTESTTYPES = 9;

   public static final String[] TESTNAMES = { "KolmogorovSmirnovPlus", "KolmogorovSmirnovMinus", "KolmogorovSmirnov",
         "Anderson-Darling", "CramerVon-Mises", "Watson G", "Watson U", "Mean", "Correlation" };

   public static boolean[] activeTests = null;
 
   private static void initActiveTests() {
      activeTests = new boolean[NTESTTYPES];
      for (int i = 0; i < activeTests.length; i++)
         activeTests[i] = false;
      activeTests[KSP] = activeTests[KSM] = true;
      activeTests[AD] = activeTests[MEAN] = activeTests[COR] = true;
   }
 
   static {
      initActiveTests();
   }

   public static void tests(DoubleArrayList sortedData, double[] sVal) {
      double[] u = sortedData.elements();
      int n = sortedData.size();
      int i;
      double a2 = 0.0, w2, dm = 0.0, dp = 0.0, w;
      double u1, ui, d2, d1;
      double sumZ;
      double unSurN;
 
      if (n <= 0)
         throw new IllegalArgumentException("n <= 0");
      if (sVal.length != NTESTTYPES)
         throw new IllegalArgumentException("sVal must " + "be of size NTESTTYPES.");
 
      // We assume that u is already sorted.
      if (n == 1) {
         sVal[KSP] = 1.0 - u[0];
         sVal[MEAN] = u[0];
         return;
      }
      unSurN = 1.0 / n;
      w2 = unSurN / 12.0;
      sumZ = 0.0;
      for (i = 0; i < n; i++) {
         // Statistics KS
         d1 = u[i] - i * unSurN;
         d2 = (i + 1) * unSurN - u[i];
         if (d1 > dm)
            dm = d1;
         if (d2 > dp)
            dp = d2;
         // Watson U and G
         sumZ += u[i];
         w = u[i] - (i + 0.5) * unSurN;
         w2 += w * w;
         // Anderson-Darling
         ui = u[i];
         u1 = 1.0 - ui;
         if (ui < GofStat.EPSILONAD)
            ui = GofStat.EPSILONAD;
         else if (u1 < GofStat.EPSILONAD)
            u1 = GofStat.EPSILONAD;
         a2 += (2 * i + 1) * Math.log(ui) + (1 + 2 * (n - i - 1)) * Math.log(u1);
      }
      if (dm > dp)
         sVal[KS] = dm;
      else
         sVal[KS] = dp;
      sVal[KSM] = dm;
      sVal[KSP] = dp;
      sumZ = sumZ * unSurN - 0.5;
      sVal[CM] = w2;
      sVal[WG] = Math.sqrt((double) n) * (dp + sumZ);
      sVal[WU] = w2 - sumZ * sumZ * n;
      sVal[AD] = -n - a2 * unSurN;
      sVal[MEAN] = sumZ + 0.5; // Nouveau ...
   }

   public static void tests(DoubleArrayList data, ContinuousDistribution dist, double[] sVal) {
 
      double[] v = data.elements();
      int n = data.size();
 
      if (n <= 0)
         throw new IllegalArgumentException("n <= 0");
 
      DoubleArrayList sortedData = GofStat.unifTransform(data, dist);
      sortedData.quickSortFromTo(0, sortedData.size() - 1);
      tests(sortedData, sVal);
      if (n == 1)
         sVal[MEAN] = v[0]; // On veut v[0], pas u[0].
   }

   public static void activeTests(DoubleArrayList sortedData, double[] sVal, double[] pVal) {
 
      double[] u = sortedData.elements();
      int n = sortedData.size();
 
      if (n <= 0)
         throw new IllegalArgumentException("n <= 0");
 
      if (sVal.length != NTESTTYPES || pVal.length != NTESTTYPES)
         throw new IllegalArgumentException("sVal and pVal must " + "be of length NTESTTYPES.");
 
      if (n == 1) {
         sVal[KSP] = 1.0 - u[0];
         pVal[KSP] = 1.0 - u[0];
         pVal[MEAN] = pVal[KSP];
         return;
      }
      // We assume that u is already sorted.
      tests(sortedData, sVal);
 
      if (activeTests.length != NTESTTYPES) {
         initActiveTests();
         System.err.println("activeTests was invalid, it was reinitialized.");
      }
 
      if (activeTests[KSP])
         pVal[KSP] = KolmogorovSmirnovPlusDist.barF(n, sVal[KSP]);
 
      if (activeTests[KSM])
         pVal[KSM] = KolmogorovSmirnovPlusDist.barF(n, sVal[KSM]);
 
      if (activeTests[KS])
         pVal[KS] = KolmogorovSmirnovDistQuick.barF(n, sVal[KS]);
 
      if (activeTests[AD])
         pVal[AD] = AndersonDarlingDistQuick.barF(n, sVal[AD]);
 
      if (activeTests[CM])
         pVal[CM] = CramerVonMisesDist.barF(n, sVal[CM]);
 
      if (activeTests[WG])
         pVal[WG] = WatsonGDist.barF(n, sVal[WG]);
 
      if (activeTests[WU])
         pVal[WU] = WatsonUDist.barF(n, sVal[WU]);
   }

   public static void activeTests(DoubleArrayList data, ContinuousDistribution dist, double[] sVal, double[] pVal) {
      double[] v = data.elements();
      int n = data.size();
 
      if (n <= 0)
         throw new IllegalArgumentException("n <= 0");
 
      DoubleArrayList sortedData = GofStat.unifTransform(data, dist);
      sortedData.quickSortFromTo(0, sortedData.size() - 1);
 
      activeTests(sortedData, sVal, pVal);
      if (n == 1)
         sVal[MEAN] = v[0];
   }

   public static String formatActiveTests(int n, double[] sVal, double[] pVal) {
 
      if (activeTests.length != NTESTTYPES) {
         initActiveTests();
         System.err.println("activeTests was invalid, it was reinitialized.");
      }
      if (sVal.length != NTESTTYPES || pVal.length != NTESTTYPES)
         throw new IllegalArgumentException("The length of " + "sVal and pVal must be NTESTTYPES.");
      if (n == 1)
         return formatp1(pVal[KSP]);
 
      StringBuffer sb = new StringBuffer(PrintfFormat.NEWLINE);
      if (activeTests[KSP])
         sb.append("Kolmogorov-Smirnov+ statistic = D+    :" + formatp2(sVal[KSP], pVal[KSP]));
      if (activeTests[KSM])
         sb.append("Kolmogorov-Smirnov- statistic = D-    :" + formatp2(sVal[KSM], pVal[KSM]));
      if (activeTests[KS])
         sb.append("Kolmogorov-Smirnov statistic  = D     :" + formatp2(sVal[KS], pVal[KS]));
      if (activeTests[AD])
         sb.append("Anderson-Darling statistic = A2       :" + formatp2(sVal[AD], pVal[AD]));
      if (activeTests[CM])
         sb.append("Cramer-von Mises statistic = W2       :" + formatp2(sVal[CM], pVal[CM]));
      if (activeTests[WG])
         sb.append("Watson statistic = G                  :" + formatp2(sVal[WG], pVal[WG]));
      if (activeTests[WU])
         sb.append("Watson statistic = U2                 :" + formatp2(sVal[WU], pVal[WU]));
      sb.append(PrintfFormat.NEWLINE);
      return sb.toString();
   }

   public static String iterSpacingsTests(DoubleArrayList sortedData, int k, boolean printval, boolean graph,
         PrintWriter f) {
 
      int n = sortedData.size();
 
      DoubleArrayList sortedDataCopy = (DoubleArrayList) sortedData.clone();
      DoubleArrayList diffArrayList = new DoubleArrayList(sortedData.size() + 2);
 
      int j;
      int i;
      double[] sVal = new double[NTESTTYPES], pVal = new double[NTESTTYPES];
 
      StringBuffer sb = new StringBuffer(PrintfFormat.NEWLINE);
 
      for (j = 1; j <= k; j++) {
         sb.append("-----------------------------------" + PrintfFormat.NEWLINE
               + "EDF Tests after \"iterateSpacings\", level : " + PrintfFormat.d(2, j) + PrintfFormat.NEWLINE);
 
         GofStat.diff(sortedDataCopy, diffArrayList, 0, n - 1, 0.0, 1.0);
         GofStat.iterateSpacings(sortedDataCopy, diffArrayList);
         sortedDataCopy.quickSortFromTo(0, sortedDataCopy.size() - 1);
         activeTests(sortedDataCopy, sVal, pVal);
 
         sb.append(formatActiveTests(n, sVal, pVal));
         String desc = "Values of Uniforms after iterateSpacings, level " + PrintfFormat.d(2, j);
         if (printval) {
            sb.append(desc + PrintfFormat.NEWLINE + "------------------------" + PrintfFormat.NEWLINE);
            sb.append(sortedDataCopy + PrintfFormat.NEWLINE);
         }
         if (graph && f != null)
            f.print(graphDistUnif(sortedDataCopy, desc));
         else if (graph && f == null)
            sb.append(graphDistUnif(sortedDataCopy, desc));
      }
      return sb.toString();
   }

   public static String iterPowRatioTests(DoubleArrayList sortedData, int k, boolean printval, boolean graph,
         PrintWriter f) {
 
      int n = sortedData.size();
      DoubleArrayList sortedDataCopy = (DoubleArrayList) sortedData.clone();
 
      int i;
      int j;
      double[] sVal = new double[NTESTTYPES], pVal = new double[NTESTTYPES];
 
      StringBuffer sb = new StringBuffer(PrintfFormat.NEWLINE);
 
      for (i = 1; i <= k; i++) {
         GofStat.powerRatios(sortedDataCopy);
         sb.append("-----------------------------------" + PrintfFormat.NEWLINE
               + "EDF Tests after \"powerRatios\", level : " + PrintfFormat.d(2, i) + PrintfFormat.NEWLINE);
 
         sortedDataCopy.quickSortFromTo(0, sortedDataCopy.size() - 1);
 
         activeTests(sortedDataCopy, sVal, pVal);
         sb.append(formatActiveTests(n, sVal, pVal));
         String desc = "Values of Uniforms after PowerRatios, level " + PrintfFormat.d(2, i);
         if (printval) {
            sb.append(desc + PrintfFormat.NEWLINE + "--------------------------" + PrintfFormat.NEWLINE);
            sb.append(sortedDataCopy + PrintfFormat.NEWLINE);
         }
         if (graph && f != null)
            f.print(graphDistUnif(sortedDataCopy, desc));
         else if (graph && f == null)
            sb.append(graphDistUnif(sortedDataCopy, desc));
      }
      return sb.toString();
   }
}