TallyHistogram.java

package umontreal.ssj.stat;
 
/*
 * Class:        TallyHistogram
 * Description:  A Tally that also builds a Histogram
 * Environment:  Java
 * Software:     SSJ
 * Copyright (C) 2001  Pierre L'Ecuyer and Universite de Montreal
 * Organization: DIRO, Universite de Montreal
 * @author       Richard Simard and Pierre L'Ecuyer
 * @since        January 2011
 *
 *
 * 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.
 *
 */
 
import umontreal.ssj.util.PrintfFormat;

public class TallyHistogram extends Tally {
   protected int numBins; // number of bins
   protected int[] count; // counter for number of values in bin[i].
   protected int leftCount; // Count values that are less than a.
   protected int rightCount; // Count values that are larger than b.
   protected double m_h; // width of 1 bin
   protected double m_a; // left boundary of first bin
   protected double m_b; // right boundary of last bin

   public TallyHistogram(double a, double b, int numBins) {
      super();
      init(a, b, numBins);
   }

   public TallyHistogram(String name, double a, double b, int numBins) {
      super(name);
      init(a, b, numBins);
   }

   public void init(double a, double b, int numBins) {
      /*
       * The counters count[0] to count[s-1] contains the number of observations
       * falling in the interval [a, b]. leftCount is the number of observations < a,
       * and rightCount is the number of observations > b.
       */
      super.init();
      if (b <= a)
         throw new IllegalArgumentException("   b <= a");
      count = new int[numBins];
      this.numBins = numBins;
      m_h = (b - a) / (double) numBins;
      m_a = a;
      m_b = b;
      leftCount = rightCount = 0;
      for (int i = 0; i < numBins; i++)
         count[i] = 0;
   }

   public void init() {
      super.init();
      leftCount = rightCount = 0;
      for (int i = 0; i < numBins; i++)
         count[i] = 0;
   }

   public void fillFromArray(double[] obs, int numObs) {
      init();
      for (int i = 0; i < numObs; i++)
         add(obs[i]);
   }

   public void fillFromArray(double[] obs) {
      fillFromArray(obs, obs.length);
   }

   public void fillFromTallyStore(TallyStore ts) {
      fillFromArray(ts.getArray(), ts.numberObs());
   }

   public void add(double x) {
      super.add(x);
      if (x < m_a)
         ++leftCount;
      else if (x > m_b)
         ++rightCount;
      else {
         int i = (int) ((x - m_a) / m_h);
         ++count[i];
      }
   }

   public TallyHistogram trimHistogram() {
      TallyHistogram image = (TallyHistogram) super.clone();
      int i = 0;
      int j = numBins - 1; // last bin in the initial histogram
      int cpL = 0; // number of empty bins from left initialized to zero
      int cpR = 0; // number of empty bins from right initialized to zero
      while (count[i] == 0) {
         i++;
         cpL++;
      }
      while (count[j] == 0) {
         j--;
         cpR++;
      }
      int[] coco = new int[numBins - cpL - cpR];
      System.arraycopy(count, i, coco, 0, j - i + 1);
      image.count = coco;
      image.m_h = m_h;
      image.m_a = m_a + (cpL * m_h);
      image.m_b = m_b - (cpR * m_h);
      image.numBins = numBins - cpL - cpR;
      image.leftCount = leftCount;
      image.rightCount = rightCount;
      return image;
   }

   public TallyHistogram addHistograms(TallyHistogram other) {
      if (this.numBins != other.numBins)
         throw new IllegalArgumentException("different number of bin in two histogram to merge");
      TallyHistogram image = (TallyHistogram) super.clone();
      int[] countNew = new int[numBins];
      System.arraycopy(count, 0, countNew, 0, numBins);
      int coOther[] = other.getCounters();
      for (int i = 0; i < countNew.length; i++)
         countNew[i] = countNew[i] + coOther[i];
      image.count = countNew;
      image.leftCount = leftCount + other.leftCount;
      image.rightCount = rightCount + other.rightCount;
      image.m_h = m_h;
      image.m_a = m_a;
      image.m_b = m_b;
      image.numBins = numBins;
      return image;
 
   }

   public TallyHistogram aggregateBins(int g) {
      TallyHistogram image = (TallyHistogram) super.clone();
      int numBinsNew = (int) Math.ceil((double) numBins / (double) g);
      int[] countNew = new int[numBinsNew];
      int b = 0;
      for (int j = 0; j < numBinsNew - 1; j++) {
         for (int i = b; i < b + g; i++)
            countNew[j] += count[i];
         b = b + g;
      }
      while (b < numBins - 1) {
         countNew[numBinsNew - 1] += count[b];
         b++;
      }
      image.count = countNew;
      image.m_h = m_h * g;
      image.m_a = m_a;
      image.m_b = m_h * numBinsNew;
      image.numBins = numBinsNew;
      image.leftCount = leftCount;
      image.rightCount = rightCount;
      return image;
   }

   public int[] getCounters() {
      return count;
   }

   public int getNumBins() {
      return numBins;
   }

   public double getA() {
      return m_a;
   }

   public double getB() {
      return m_b;
   }

   public double getH() {
      return m_h;
   }

   public double getProportionInBoundaries() {
      int total = 0;
      for (int num : count) {
         total += num;
      }
      return (double) total / (double) (total + leftCount + rightCount);
   }

   public TallyHistogram clone() {
      TallyHistogram image = (TallyHistogram) super.clone();
      int[] coco = new int[numBins];
      System.arraycopy(count, 0, coco, 0, numBins);
      image.count = coco;
      image.leftCount = leftCount;
      image.rightCount = rightCount;
      image.m_h = m_h;
      image.m_a = m_a;
      image.m_b = m_b;
      image.numBins = numBins;
      return image;
   }

   public String toString() {
      StringBuffer sb = new StringBuffer();
      sb.append("---------------------------------------" + PrintfFormat.NEWLINE);
      sb.append(name + PrintfFormat.NEWLINE);
      sb.append("Interval = [ " + m_a + ", " + m_b + " ]" + PrintfFormat.NEWLINE);
      sb.append("Number of bins = " + numBins + PrintfFormat.NEWLINE);
      sb.append(PrintfFormat.NEWLINE + "Counters = {" + PrintfFormat.NEWLINE);
      sb.append("   (-inf, " + PrintfFormat.f(6, 3, m_a) + ")    " + leftCount + PrintfFormat.NEWLINE);
      for (int i = 0; i < numBins; i++) {
         double a = m_a + (i - 1) * m_h;
         double b = m_a + i * m_h;
         sb.append("   (" + PrintfFormat.f(6, 3, a) + ", " + PrintfFormat.f(6, 3, b) + ")    " + count[i]
               + PrintfFormat.NEWLINE);
      }
      sb.append("   (" + PrintfFormat.f(6, 3, m_b) + ", inf)    " + rightCount + PrintfFormat.NEWLINE);
      sb.append("}" + PrintfFormat.NEWLINE);
      return sb.toString();
   }
 
}