MatrixOfTallies.java

/*
 * Class:        MatrixOfTallies
 * Description:  Matrix of statistical collectors
 * 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.Tally;
import umontreal.ssj.stat.TallyStore;
import cern.colt.matrix.DoubleMatrix2D;
import umontreal.ssj.util.PrintfFormat;
import cern.colt.list.DoubleArrayList;
import cern.colt.matrix.impl.DenseDoubleMatrix2D;
import umontreal.ssj.stat.list.ListOfTallies;

public class MatrixOfTallies<E extends Tally> extends MatrixOfStatProbes<E> {

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

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

   public static MatrixOfTallies<Tally> createWithTally(int numRows, int numColumns) {
      MatrixOfTallies<Tally> matrix = new MatrixOfTallies<Tally>(numRows, numColumns);
      for (int r = 0; r < numRows; r++)
         for (int c = 0; c < numColumns; c++)
            matrix.set(r, c, new Tally());
      return matrix;
   }

   public static MatrixOfTallies<TallyStore> createWithTallyStore(int numRows, int numColumns) {
      MatrixOfTallies<TallyStore> matrix = new MatrixOfTallies<TallyStore>(numRows, numColumns);
      for (int r = 0; r < numRows; r++)
         for (int c = 0; c < numColumns; c++)
            matrix.set(r, c, new TallyStore());
      return matrix;
   }

   public void add(DoubleMatrix2D x) {
      int rows = rows();
      int columns = columns();
      if (x.rows() != rows || x.columns() != columns)
         throw new IllegalArgumentException("Incompatible matrix dimensions: given " + x.rows() + "x" + x.columns()
               + ", required " + rows() + "x" + columns());
      if (collect)
         for (int r = 0; r < rows; r++)
            for (int c = 0; c < columns; c++) {
               double v = x.getQuick(r, c);
               Tally ta = get(r, c);
               if (!Double.isNaN(v) && ta != null)
                  ta.add(v);
            }
      notifyListeners(x);
   }

   public void add(double[][] x) {
      int rows = rows();
      int columns = columns();
      if (x.length != rows)
         throw new IllegalArgumentException("Incompatible number of rows: given " + x.length + ", required " + rows);
      if (collect)
         for (int r = 0; r < rows; r++) {
            if (x[r].length != columns)
               throw new IllegalArgumentException("Incompatible number of columns in row " + r + ": given "
                     + x[r].length + ", but required " + columns);
            for (int c = 0; c < columns; c++) {
               double v = x[r][c];
               Tally ta = get(r, c);
               if (!Double.isNaN(v) && ta != null)
                  ta.add(v);
            }
         }
      notifyListeners(new DenseDoubleMatrix2D(x));
   }

   public int numberObs() {
      if (rows() == 0 || columns() == 0)
         return 0;
      Tally 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++) {
            Tally t = get(r, c);
            if (t.numberObs() != n)
               return false;
         }
      return true;
   }

   public void average(DoubleMatrix2D m) {
      for (int i = 0; i < m.rows(); i++)
         for (int j = 0; j < m.columns(); j++) {
            Tally ta = get(i, j);
            double v = ta == null || ta.numberObs() == 0 ? Double.NaN : ta.average();
            m.setQuick(i, j, v);
         }
   }

   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++) {
            Tally 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++) {
            Tally tally = get(r, c);
            m.setQuick(r, c, tally != null && tally.numberObs() >= 2 ? tally.standardDeviation() : Double.NaN);
         }
   }

   public MatrixOfTallies<E> clone() {
      return (MatrixOfTallies<E>) super.clone();
   }
}