MatrixOfFunctionOfMultipleMeansTallies.java

/*
 * Class:        MatrixOfFunctionOfMultipleMeansTallies
 * Description:  Statistical collectors for functions of multiple means.
 * Environment:  Java
 * Software:     SSJ
 * Copyright (C) 2001  Pierre L'Ecuyer and Universite de Montreal
 * Organization: DIRO, Universite de Montreal
 * @author       Éric Buist
 * @since        2006
 
 * 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.stat.matrix;
 
import umontreal.ssj.stat.FunctionOfMultipleMeansTally;
import umontreal.ssj.util.MultivariateFunction;
import cern.colt.matrix.DoubleMatrix2D;
import cern.colt.matrix.DoubleMatrix3D;
import umontreal.ssj.stat.Tally;
import umontreal.ssj.stat.list.ListOfFunctionOfMultipleMeansTallies;
import umontreal.ssj.stat.list.ListOfTallies;
import umontreal.ssj.util.PrintfFormat;

public class MatrixOfFunctionOfMultipleMeansTallies<E extends FunctionOfMultipleMeansTally>
      extends MatrixOfStatProbes<E> {
   double[][][] temp;

   public MatrixOfFunctionOfMultipleMeansTallies(int numRows, int numColumns) {
      super(numRows, numColumns);
   }

   public MatrixOfFunctionOfMultipleMeansTallies(String name, int numRows, int numColumns) {
      super(name, numRows, numColumns);
   }

   public static MatrixOfFunctionOfMultipleMeansTallies<FunctionOfMultipleMeansTally> create(MultivariateFunction func,
         int d, int numRows, int numColumns) {
      MatrixOfFunctionOfMultipleMeansTallies<FunctionOfMultipleMeansTally> matrix = new MatrixOfFunctionOfMultipleMeansTallies<FunctionOfMultipleMeansTally>(
            numRows, numColumns);
      for (int r = 0; r < numRows; r++)
         for (int c = 0; c < numColumns; c++)
            matrix.set(r, c, new FunctionOfMultipleMeansTally(func, d));
      return matrix;
   }

   public void add(double[][][] x) {
      if (x.length != rows())
         throw new IllegalArgumentException(
               "The length of the given array must " + "correspond to the number of rows in the matrix");
      if (collect)
         for (int i = 0; i < x.length; i++) {
            if (x[i].length != columns())
               throw new IllegalArgumentException(
                     "The length of the array x[" + i + "] must correspond to the number of columns in the matrix");
            for (int j = 0; j < x[i].length; j++)
               get(i, j).add(x[i][j]);
         }
   }

   public void add(DoubleMatrix3D x) {
      if (x.rows() != rows())
         throw new IllegalArgumentException("The number of rows of the given matrix must "
               + "correspond to the number of rows in the matrix of probes");
      if (x.columns() != columns())
         throw new IllegalArgumentException("The number of columns of the given matrix must "
               + "correspond to the number of columns in the matrix of probes");
      if (collect)
         for (int i = 0; i < rows(); i++)
            for (int j = 0; j < x.columns(); j++)
               get(i, j).add(x.viewSlice(i).viewRow(j).toArray());
   }

   public void addSameDimension(DoubleMatrix2D... x) {
      final int nr = rows();
      final int nc = columns();
      final int d = getDimension();
 
      if (x.length != d)
         throw new IllegalArgumentException(
               "The length of the given array must be " + d + " while its actual length is " + x.length);
 
      if (x.length == 0 || nr == 0 || nc == 0)
         return;
 
      if (nr != x[0].rows() || nc != x[0].columns())
         throw new IllegalArgumentException("The given matrices must have the same dimensions");
 
      for (int i = 0; i < x.length - 1; i++)
         if (x[i].rows() != x[i + 1].rows() || x[i].columns() != x[i + 1].columns())
            throw new IllegalArgumentException("The given arrays must have the same length");
 
      if ((temp == null) || (temp.length != nr) || (temp[0].length != nc) || (temp[0][0].length != d))
         temp = new double[nr][nc][d];
 
      for (int r = 0; r < nr; r++)
         for (int c = 0; c < nc; c++)
            for (int j = 0; j < d; j++)
               temp[r][c][j] = x[j].getQuick(r, c);
      add(temp);
   }

   public int getDimension() {
      if (rows() == 0 || columns() == 0)
         return 0;
      FunctionOfMultipleMeansTally t0 = get(0, 0);
      return t0 == null ? 0 : t0.getDimension();
   }

   public int numberObs() {
      if (rows() == 0 || columns() == 0)
         return 0;
      FunctionOfMultipleMeansTally t0 = get(0, 0);
      return t0 == null ? 0 : t0.numberObs();
   }

   public boolean areAllNumberObsEqual() {
      final int nr = rows();
      final int nc = columns();
      int n = numberObs();
      for (int r = 0; r < nr; r++)
         for (int c = 0; c < nc; c++) {
            FunctionOfMultipleMeansTally t = get(r, c);
            if (t.numberObs() != n)
               return false;
         }
      return true;
   }

   public void average(DoubleMatrix2D m) {
      super.average(m);
      for (int i = 0; i < m.rows(); i++)
         for (int j = 0; j < m.columns(); j++)
            if (!Double.isNaN(m.getQuick(i, j)) && get(i, j).numberObs() == 0)
               m.setQuick(i, j, Double.NaN);
   }

   public void variance(DoubleMatrix2D m) {
      if (m.rows() != rows())
         throw new IllegalArgumentException(
               "Invalid number of rows in the given matrix: required " + rows() + " but found " + m.rows());
      if (m.columns() != columns())
         throw new IllegalArgumentException(
               "Invalid number of columns in the given matrix: required " + columns() + " but found " + m.columns());
      for (int r = 0; r < rows(); r++)
         for (int c = 0; c < columns(); c++) {
            FunctionOfMultipleMeansTally tally = get(r, c);
            m.setQuick(r, c, tally != null && tally.numberObs() >= 2 ? tally.variance() : Double.NaN);
         }
   }

   public void standardDeviation(DoubleMatrix2D m) {
      if (m.rows() != rows())
         throw new IllegalArgumentException(
               "Invalid number of rows in the given matrix: required " + rows() + " but found " + m.rows());
      if (m.columns() != columns())
         throw new IllegalArgumentException(
               "Invalid number of columns in the given matrix: required " + columns() + " but found " + m.columns());
      for (int r = 0; r < rows(); r++)
         for (int c = 0; c < columns(); c++) {
            FunctionOfMultipleMeansTally tally = get(r, c);
            m.setQuick(r, c, tally != null && tally.numberObs() >= 2 ? tally.standardDeviation() : Double.NaN);
         }
   }

   public MatrixOfFunctionOfMultipleMeansTallies<E> clone() {
      MatrixOfFunctionOfMultipleMeansTallies<E> clone = (MatrixOfFunctionOfMultipleMeansTallies<E>) super.clone();
      if (temp != null) {
         clone.temp = new double[temp.length][temp[0].length][temp[0].length];
         for (int i = 0; i < temp.length; i++)
            for (int j = 0; j < temp[i].length; i++)
               for (int k = 0; k < temp[i][j].length; k++)
                  clone.temp[i][j][k] = temp[i][j][k];
      }
 
      return clone;
   }
}