TallyStore.java

/*
 * Class:        TallyStore
 * 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.stat;
 
import cern.colt.list.DoubleArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
import umontreal.ssj.util.PrintfFormat;

public class TallyStore extends Tally {
 
   private DoubleArrayList array = null; // Where the observations are stored.
   private Logger log = Logger.getLogger("umontreal.ssj.stat");

   public TallyStore() {
      super();
      array = new DoubleArrayList();
   }

   public TallyStore(String name) {
      super(name);
      array = new DoubleArrayList();
   }

   public TallyStore(int capacity) {
      super();
      array = new DoubleArrayList(capacity);
   }

   public TallyStore(String name, int capacity) {
      super(name);
      array = new DoubleArrayList(capacity);
   }

   public TallyStore(DoubleArrayList a) {
      super();
      array = a;
      array.clear();
   }
 
   public void init() {
      super.init();
      // We must call super before any actions inside constructors.
      // Unfortunately, the base class calls init, which would
      // result in a NullPointerException.
      if (array != null)
         array.clear();
   }

   public void add(double x) {
      if (collect)
         array.add(x);
      super.add(x);
   }

   public double[] getArray() {
      array.trimToSize();
      return array.elements();
   }

   public DoubleArrayList getDoubleArrayList() {
      array.trimToSize();
      return array;
   }

   public void quickSort() {
      array.quickSort();
   }

   public double covariance(TallyStore t2) {
      if (numberObs() != t2.numberObs()) {
         // System.err.println ("******* TallyStore.covariance(): " +
         // "Tally's with different number of observations");
         log.logp(Level.WARNING, "TallyStore", "covariance",
               "This tally, with name " + getName() + ", contains " + numberObs() + " observations while "
                     + "the given tally, with name " + t2.getName() + ", contains " + t2.numberObs() + "observations");
         return Double.NaN;
      }
 
      if (numberObs() < 2 || t2.numberObs() < 2) {
         // System.err.println ("******* TallyStore.covariance() with " +
         // numberObs() + " Observation");
         log.logp(Level.WARNING, "TallyStore", "covariance",
               "This tally, with name " + getName() + ", contains " + numberObs() + " observation");
         return Double.NaN;
      }
 
      return cern.jet.stat.Descriptive.covariance(getDoubleArrayList(), t2.getDoubleArrayList());
   }

   public TallyStore clone() {
      TallyStore t = (TallyStore) super.clone();
      t.array = (DoubleArrayList) array.clone();
      return t;
   }

   public TallyStore extractSubrange(double a, double b) {
      int numObs = this.numberObs();
      double[] obs = this.getArray();
      double x;
      TallyStore t = new TallyStore();
      for (int i = 0; i < numObs; i++) {
         x = obs[i];
         if ((x > a) & (x < b))
            t.add(x);
      }
      return t;
   }

   public TallyStore aggregate(int gsize) {
      int numObs = this.numberObs();
      int numGroups = numObs / gsize;
      double[] obs = this.getArray();
      double sum;
      TallyStore t = new TallyStore(numGroups);
      for (int i = 0; i < numGroups; i++) {
         sum = 0.0;
         for (int j = 0; j < gsize; j++)
            sum += obs[gsize * i + j];
         sum /= gsize;
         t.add(sum);
      }
      // This is if gsize does not divide numObs.
      int rest = numObs - numGroups * gsize;
      if (rest > 0) {
         sum = 0.0;
         for (int j = 0; j < rest; j++)
            sum += obs[gsize * numGroups + j];
         sum /= rest;
         t.add(sum);
      }
      return t;
   }

   public String toString() {
      StringBuffer sb = new StringBuffer();
      for (int i = 0; i < numberObs(); i++)
         sb.append(i + "    " + array.getQuick(i) + PrintfFormat.NEWLINE);
      return sb.toString();
   }
 
}