DiscrepancyContainer.java

/*
 * Class:        DiscrepancyContainer
 * Description:
 * Environment:  Java
 * Software:     SSJ
 * Copyright (C) 2001  Pierre L'Ecuyer and Universite de Montreal
 * Organization: DIRO, Universite de Montreal
 * @author       Adam L'Archevêque Gaudet
 * @since        January 2009
 
 * SSJ is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License (GPL) as published by the
 * Free Software Foundation, either version 3 of the License, or
 * any later version.
 
 * SSJ is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 
 * A copy of the GNU General Public License is available at
   <a href="http://www.gnu.org/licenses">GPL licence site</a>.
 */
package umontreal.ssj.discrepancy;
 
import umontreal.ssj.util.PrintfFormat;
import umontreal.ssj.util.Num;
import umontreal.ssj.charts.XYLineChart;
import umontreal.ssj.functionfit.LeastSquares;
import java.io.*;

public class DiscrepancyContainer {
   private double[][] disc;
   private Discrepancy[] discrepancies;
   private double[] regression;
   private int n, nbDisc;
   private String title, xLabel, yLabel;

   public DiscrepancyContainer(Discrepancy[] discrepancies) {
      this.discrepancies = discrepancies;
      nbDisc = discrepancies.length;
      regression = new double[nbDisc + 1];
   }

   public void init(int n, String title, String xLabel, String yLabel) {
      this.xLabel = xLabel;
      this.yLabel = yLabel;
      this.n = n;
      disc = new double[nbDisc + 1][n];
      reset();
   }

   public void init(int n) {
      init(n, "", "Parameter", "Discrepancy");
   }

   public void reset(int i) {
      for (int j = 0; j < nbDisc; ++j)
         disc[j + 1][i] = 0.0;
   }

   public void reset() {
      for (int i = 0; i < n; ++i)
         reset(i);
   }

   public void compute(int i, double[] points, int n) {
      for (int j = 0; j < nbDisc; ++j)
         disc[j + 1][i] = discrepancies[j].compute(points, n);
   }

   public void compute(int i, double[][] points, int n, int s) {
      for (int j = 0; j < nbDisc; ++j)
         disc[j + 1][i] = discrepancies[j].compute(points, n, s);
   }

   public void add(int i, double[] points, int n) {
      for (int j = 0; j < nbDisc; ++j)
         disc[j + 1][i] += discrepancies[j].compute(points, n);
   }

   public void addSquare(int i, double[] points, int n) {
      double discrepancy;
      for (int j = 0; j < nbDisc; ++j) {
         discrepancy = discrepancies[j].compute(points, n);
         disc[j + 1][i] += discrepancy * discrepancy;
      }
   }

   public void add(int i, double[][] points, int n, int s) {
      for (int j = 0; j < nbDisc; ++j)
         disc[j + 1][i] += discrepancies[j].compute(points, n, s);
   }

   public void addSquare(int i, double[][] points, int n, int s) {
      double discrepancy;
      for (int j = 0; j < nbDisc; ++j) {
         discrepancy = discrepancies[j].compute(points, n, s);
         disc[j + 1][i] += discrepancy * discrepancy;
      }
   }

   public void scale(int i, double scale) {
      for (int j = 0; j < nbDisc; ++j)
         disc[j + 1][i] *= scale;
   }

   public void scale(double scale) {
      for (int i = 0; i < n; ++i)
         scale(i, scale);
   }

   public void log2(int i) {
      for (int j = 0; j < nbDisc; ++j)
         disc[j + 1][i] = Num.log2(disc[j + 1][i]);
   }

   public void square(int i) {
      for (int j = 0; j < nbDisc; ++j)
         disc[j + 1][i] *= disc[j + 1][i];
   }

   public void setParam(int i, double paramValue) {
      disc[0][i] = paramValue;
   }
 
   // Removes infinite values caused by loss of precision in
   // discrepancy computations.
   private void removeInfinite() {
      for (int i = 0; i < n; ++i) {
         for (int j = 0; j < nbDisc; ++j)
            if (disc[j + 1][i] == Double.NEGATIVE_INFINITY)
               disc[j + 1][i] = 0.0;
      }
   }

   protected void calcRegressionSlope() {
      for (int j = 0; j < nbDisc; ++j)
         regression[j] = LeastSquares.calcCoefficients(disc[0], disc[j + 1], 1)[1];
   }

   public String regressionToString() {
      calcRegressionSlope();
      StringBuffer sb = new StringBuffer(
            "***************************************************************" + PrintfFormat.NEWLINE);
      sb.append("Linear regression slope" + PrintfFormat.NEWLINE);
      for (int j = 0; j < nbDisc; ++j)
         sb.append(PrintfFormat.s(15, discrepancies[j].toString()) + PrintfFormat.g(15, 6, regression[j])
               + PrintfFormat.NEWLINE);
      return sb.toString();
   }

   public void toTexFile(String filename) {
      removeInfinite();
      // XYLineChart chart = new XYLineChart(title, xLabel, yLabel); // ambigu
      XYLineChart chart = new XYLineChart();
      chart.setTitle(title);
      chart.getXAxis().setLabel(xLabel);
      chart.getYAxis().setLabel(yLabel);
      for (int j = 0; j < nbDisc; ++j)
         chart.add(disc[0], disc[j + 1], discrepancies[j].toString(), "sharp plot");
 
      try {
         Writer file = new FileWriter(filename + ".tex");
         file.write(chart.toLatex(9, 5));
         file.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }

   public void toDatFile(String filename, String header) {
      try {
         Writer file = new FileWriter(filename + ".dat");
         file.write(header);
         file.write(toString());
         file.write(regressionToString());
         file.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }

   public String toString() {
      StringBuffer sb = new StringBuffer(PrintfFormat.NEWLINE);
      sb.append(PrintfFormat.s(35, xLabel));
      for (int i = 0; i < n; ++i)
         sb.append(PrintfFormat.g(15, 6, disc[0][i]));
      sb.append(PrintfFormat.NEWLINE);
 
      for (int j = 0; j < nbDisc; ++j) {
         sb.append(PrintfFormat.s(15, yLabel));
         sb.append(PrintfFormat.s(20, discrepancies[j].toString()));
         for (int i = 0; i < n; ++i)
            sb.append(PrintfFormat.g(15, 6, disc[j + 1][i]));
         sb.append(PrintfFormat.NEWLINE);
      }
      return sb.toString();
   }
 
}