MatrixOfStatProbes.java

/*
 * Class:        MatrixOfStatProbes
 * Description:  Matrix of statistical probes
 * 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.util.PrintfFormat;
import umontreal.ssj.stat.StatProbe;
import cern.colt.matrix.DoubleMatrix2D;
import java.util.List;
import java.util.ArrayList;
import java.util.AbstractList;
import java.util.Iterator;
import java.util.ConcurrentModificationException;
import java.util.NoSuchElementException;
import java.util.Collections;
import java.util.RandomAccess;

public class MatrixOfStatProbes<E extends StatProbe> implements Cloneable, Iterable<E> {
   private List<MatrixOfObservationListener> listeners = new ArrayList<MatrixOfObservationListener>();
   protected boolean collect = true;
   protected boolean broadcast = false;
   protected String name;
   private E[] probes;
   private int numRows;
   private int numColumns;
   private int modCount = 0;
 
   private static enum ListType {
      ROW, COLUMN
   }

   public MatrixOfStatProbes(int numRows, int numColumns) {
      createProbes(numRows, numColumns);
   }

   public MatrixOfStatProbes(String name, int numRows, int numColumns) {
      this.name = name;
      createProbes(numRows, numColumns);
   }
 
   // @SuppressWarnings("unchecked")
   private void createProbes(int numRows, int numColumns) {
      if (numRows < 0)
         throw new NegativeArraySizeException("The number of rows must not be negative");
      if (numColumns < 0)
         throw new NegativeArraySizeException("The number of columns must not be negative");
      this.numRows = numRows;
      this.numColumns = numColumns;
      int length = numRows * numColumns;
 
      probes = (E[]) new StatProbe[length];
   }

   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }

   public int rows() {
      return numRows;
   }

   public int columns() {
      return numColumns;
   }

   public void setRows(int newRows) {
      if (newRows < 0)
         throw new NegativeArraySizeException("The given number of rows is negative");
      if (rows() == newRows)
         return;
      E[] newProbes = (E[]) new StatProbe[newRows * columns()];
      int m = Math.min(rows(), newRows);
      System.arraycopy(probes, 0, newProbes, 0, m * columns());
      probes = newProbes;
      numRows = newRows;
      ++modCount;
   }

   public void setColumns(int newColumns) {
      if (newColumns < 0)
         throw new IllegalArgumentException("The given number of columns is negative");
      if (columns() == newColumns)
         return;
      // E[] newProbes = (E[])new StatProbe[probeClass, rows()*newColumns];
      E[] newProbes = (E[]) new StatProbe[rows() * newColumns];
      int m = Math.min(columns(), newColumns);
      for (int r = 0; r < rows(); r++)
         System.arraycopy(probes, columns() * r, newProbes, newColumns * r, m);
      probes = newProbes;
      numColumns = newColumns;
      ++modCount;
   }

   public E get(int r, int c) {
      if (r < 0 || r >= numRows)
         throw new ArrayIndexOutOfBoundsException("Row index out of bounds: " + r);
      if (c < 0 || c >= numColumns)
         throw new ArrayIndexOutOfBoundsException("Column index out of bounds: " + c);
      return probes[numColumns * r + c];
   }

   public void set(int r, int c, E probe) {
      if (r < 0 || r >= numRows)
         throw new ArrayIndexOutOfBoundsException("Row index out of bounds: " + r);
      if (c < 0 || c >= numColumns)
         throw new ArrayIndexOutOfBoundsException("Column index out of bounds: " + c);
      probes[numColumns * r + c] = probe;
      ++modCount;
   }

   public void init() {
      int rows = rows();
      int columns = columns();
      for (int r = 0; r < rows; r++)
         for (int c = 0; c < columns; c++)
            get(r, c).init();
   }

   public void sum(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++) {
            StatProbe probe = get(r, c);
            m.setQuick(r, c, probe == null ? Double.NaN : probe.sum());
         }
   }

   public void average(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++) {
            StatProbe probe = get(r, c);
            m.setQuick(r, c, probe == null ? Double.NaN : probe.average());
         }
   }

   public boolean isCollecting() {
      return collect;
   }

   public void setCollecting(boolean c) {
      collect = c;
   }

   public boolean isBroadcasting() {
      return broadcast;
   }

   public void setBroadcasting(boolean b) {
      broadcast = b;
   }

   public void addMatrixOfObservationListener(MatrixOfObservationListener l) {
      if (l == null)
         throw new NullPointerException();
      if (!listeners.contains(l))
         listeners.add(l);
   }

   public void removeMatrixOfObservationListener(MatrixOfObservationListener l) {
      listeners.remove(l);
   }

   public void clearMatrixOfObservationListeners() {
      listeners.clear();
   }

   public void notifyListeners(DoubleMatrix2D x) {
      if (!broadcast)
         return;
      // We could also use the enhanced for loop here, but this is less efficient.
      final int nl = listeners.size();
      for (int i = 0; i < nl; i++)
         listeners.get(i).newMatrixOfObservations(this, x);
   }

   public List<E> viewRow(int r) {
      return new MyList<E>(this, ListType.ROW, r);
   }

   public List<E> viewColumn(int c) {
      return new MyList<E>(this, ListType.COLUMN, c);
   }

   public String rowReport(int r) {
      return StatProbe.report(getName(), viewRow(r));
   }

   public String columnReport(int c) {
      return StatProbe.report(getName(), viewColumn(c));
   }

   public MatrixOfStatProbes<E> clone() {
      MatrixOfStatProbes<E> sm;
      try {
         sm = (MatrixOfStatProbes<E>) super.clone();
      } catch (CloneNotSupportedException cne) {
         throw new IllegalStateException("CloneNotSupportedException for a class implementing Cloneable");
      }
      if (probes != null)
         sm.probes = (E[]) probes.clone();
      return sm;
   }
 
   private class MyIterator implements Iterator<E> {
      private int index = 0;
      private int expectedModCount = modCount;
 
      public boolean hasNext() {
         if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
         return (index < probes.length - 1);
      }
 
      public E next() {
         if (!hasNext())
            throw new NoSuchElementException();
         return probes[index++];
      }
 
      public void remove() {
         throw new UnsupportedOperationException("Can not remove an element in a matrix");
      }
   }
 
   public Iterator<E> iterator() {
      return new MyIterator();
   }
 
   private static class MyList<E extends StatProbe> extends AbstractList<E> implements RandomAccess {
      private MatrixOfStatProbes<E> matrix;
      private ListType type;
      private int index;
 
      public MyList(MatrixOfStatProbes<E> matrix, ListType type, int index) {
         this.matrix = matrix;
         this.type = type;
         this.index = index;
      }
 
      public E get(int index) {
         if (type == ListType.ROW) {
            return matrix.get(this.index, index);
         } else {
            return matrix.get(index, this.index);
         }
      }
 
      public int size() {
         if (type == ListType.ROW) {
            return matrix.numColumns;
         } else {
            return matrix.numRows;
         }
      }
   }
 
}