CustomHistogramDataset.java

 
package umontreal.ssj.charts;
 
import java.util.*;
import org.jfree.data.general.DatasetChangeEvent;
import org.jfree.data.statistics.HistogramBin;
import org.jfree.data.statistics.HistogramType;
import org.jfree.data.xy.AbstractIntervalXYDataset;
import org.jfree.data.xy.IntervalXYDataset;
import org.jfree.util.ObjectUtilities;
import org.jfree.util.PublicCloneable;
 
/*
 * Class:        CustomHistogramDataset
 * 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.
 *
 */

public class CustomHistogramDataset extends AbstractIntervalXYDataset
      implements IntervalXYDataset, Cloneable, PublicCloneable {

   private List<Map> list;

   public HistogramType type;

   public CustomHistogramDataset() {
      list = new ArrayList<Map>();
      type = HistogramType.FREQUENCY;
   }

   public HistogramType getType() {
      return type;
   }

   public void setType(HistogramType type) {
      if (type == null) {
         throw new IllegalArgumentException("Null 'type' argument");
      } else {
         this.type = type;
         notifyListeners(new DatasetChangeEvent(this, this));
         return;
      }
   }

   public void addSeries(Comparable key, double values[], int bins) {
      double minimum = getMinimum(values);
      double maximum = getMaximum(values);
      addSeries(key, values, bins, minimum, maximum);
   }

   public void addSeries(Comparable key, double values[], int numPoints, int bins) {
      double minimum = getMinimum(values);
      double maximum = getMaximum(values);
      addSeries(key, values, numPoints, bins, minimum, maximum);
   }

   public void addSeries(Comparable key, double values[], int bins, double minimum, double maximum) {
      addSeries(key, values, values.length, bins, minimum, maximum);
   }

   public void addSeries(Comparable key, double values[], int numPoints, int bins, double minimum, double maximum) {
      if (key == null)
         throw new IllegalArgumentException("Null 'key' argument.");
      if (values == null)
         throw new IllegalArgumentException("Null 'values' argument.");
      if (bins < 1)
         throw new IllegalArgumentException("The 'bins' value must be at least 1.");
      double binWidth = (maximum - minimum) / (double) bins;
      double lower = minimum;
      final double EPS = 1.0e-15;
      List<HistogramBin> binList = new ArrayList<HistogramBin>(bins);
      for (int i = 0; i < bins; i++) {
         HistogramBin bin;
         if (i == bins - 1) {
            bin = new HistogramBin(lower, maximum * (1.0 + EPS));
         } else {
            double upper = minimum + (double) (i + 1) * binWidth;
            bin = new HistogramBin(lower, upper);
            lower = upper;
         }
         binList.add(bin);
      }
 
      ArrayList<Double> valuesList = new ArrayList<Double>(numPoints);
      for (int i = 0; i < numPoints; i++)
         valuesList.add(Double.valueOf(values[i]));
 
      synchronizeValuesAndBins(binList, valuesList);
      Map map = new HashMap();
      map.put("key", key);
      map.put("values", valuesList);
      map.put("bins", binList);
      map.put("numPoints", Integer.valueOf(numPoints));
      map.put("bin width", Double.valueOf(binWidth));
      list.add(map);
   }

   public void addSeries(Comparable key, double values[], HistogramBin bins[]) {
      addSeries(key, values, values.length, bins);
   }

   public void addSeries(Comparable key, double values[], int numPoints, HistogramBin bins[]) {
      if (key == null)
         throw new IllegalArgumentException("Null 'key' argument.");
      if (values == null)
         throw new IllegalArgumentException("Null 'values' argument.");
      if (bins == null || bins.length < 2)
         throw new IllegalArgumentException(
               "The 'bins' table must contain at least 1 org.jfree.data.statistics.HistogramBin.");
      List binList = new ArrayList(bins.length);
      for (int i = 0; i < bins.length; i++)
         binList.add(bins[i]);
 
      ArrayList valuesList = new ArrayList(numPoints);
      for (int i = 0; i < numPoints; i++)
         valuesList.add(Double.valueOf(values[i]));
 
      synchronizeValuesAndBins(binList, valuesList);
      Map map = new HashMap();
      map.put("key", key);
      map.put("values", valuesList);
      map.put("bins", binList);
      map.put("numPoints", Integer.valueOf(numPoints));
      map.put("bin width", Double.valueOf(-1D));
      list.add(map);
   }

   private double getMinimum(double values[]) {
      if (values == null || values.length < 1)
         throw new IllegalArgumentException("Null or zero length 'values' argument.");
      double min = 1.7E+308D;
      for (int i = 0; i < values.length; i++)
         if (values[i] < min)
            min = values[i];
 
      return min;
   }

   private double getMaximum(double values[]) {
      if (values == null || values.length < 1)
         throw new IllegalArgumentException("Null or zero length 'values' argument.");
      double max = -1.7E+308D;
      for (int i = 0; i < values.length; i++)
         if (values[i] > max)
            max = values[i];
 
      return max;
   }

   public List getBins(int series) {
      Map map = (Map) list.get(series);
      return (List) map.get("bins");
   }

   public void setBins(int series, int bins) {
      double minimum = getMinimum(getValues(series));
      double maximum = getMaximum(getValues(series));
      setBins(series, bins, minimum, maximum);
   }

   public void setBins(int series, int bins, double minimum, double maximum) {
      Map map = (Map) list.get(series);
      List currentValues = (List) map.get("values");
      double binWidth = (maximum - minimum) / (double) bins;
      double lower = minimum;
      List binList = new ArrayList(bins);
      double EPS = 1.0e-15;
      for (int i = 0; i < bins; i++) {
         HistogramBin bin;
         if (i == bins - 1) {
            bin = new HistogramBin(lower, maximum * (1.0 + EPS));
         } else {
            double upper = minimum + (double) (i + 1) * binWidth;
            bin = new HistogramBin(lower, upper);
            lower = upper;
         }
         binList.add(bin);
      }
 
      synchronizeValuesAndBins(binList, currentValues);
      map.put("values", currentValues);
      map.put("bins", binList);
   }

   public void setBins(int series, HistogramBin bins[]) {
      Map map = (Map) list.get(series);
      List currentValues = (List) map.get("values");
      ArrayList binList = new ArrayList(bins.length);
      for (int i = 0; i < bins.length; i++)
         binList.add(bins[i]);
 
      synchronizeValuesAndBins(binList, currentValues);
      map.put("values", currentValues);
      map.put("bins", binList);
   }

   public List getValuesList(int series) {
      Map map = (Map) list.get(series);
      return (List) map.get("values");
   }

   public double[] getValues(int series) {
      List valuesList = (List) ((Map) list.get(series)).get("values");
      ListIterator iter = valuesList.listIterator();
      double retour[] = new double[valuesList.size()];
      for (int i = 0; iter.hasNext(); i++)
         retour[i] = ((Double) iter.next()).doubleValue();
 
      return retour;
   }

   public void setValues(int series, List valuesList) {
      Map map = (Map) list.get(series);
      List currentBins = (List) map.get("bins");
      synchronizeValuesAndBins(currentBins, valuesList);
      map.put("values", valuesList);
      map.put("bins", currentBins);
   }

   public void setValues(int series, double values[]) {
      ArrayList valuesList = new ArrayList(values.length);
      for (int i = 0; i < values.length; i++)
         valuesList.add(new Double(values[i]));
 
      setValues(series, ((List) (valuesList)));
   }

   private void synchronizeValuesAndBins(List bins, List values) {
      ListIterator iterBins = bins.listIterator(0);
      ListIterator iterValues = values.listIterator();
      HistogramBin bin;
      for (; iterBins.hasNext(); iterBins.set(new HistogramBin(bin.getStartBoundary(), bin.getEndBoundary())))
         bin = (HistogramBin) iterBins.next();
 
      iterBins = bins.listIterator(0);
      while (iterValues.hasNext()) {
         double currentValue = ((Double) iterValues.next()).doubleValue();
         boolean continu = true;
         iterBins = bins.listIterator(0);
         while (continu && iterBins.hasNext()) {
            HistogramBin tempBin = (HistogramBin) iterBins.next();
            if (currentValue >= tempBin.getStartBoundary() && currentValue < tempBin.getEndBoundary()) {
               tempBin.incrementCount();
               continu = false;
            }
         }
      }
   }

   public int getTotal(int series) {
      Map map = (Map) list.get(series);
      return ((Integer) map.get("numPoints")).intValue();
   }

   public double getBinWidth(int series) {
      Map map = (Map) list.get(series);
      return ((Double) map.get("bin width")).doubleValue();
   }

   public int getSeriesCount() {
      return list.size();
   }

   public Comparable getSeriesKey(int series) {
      Map map = (Map) list.get(series);
      return (Comparable) map.get("key");
   }

   public int getItemCount(int series) {
      return getBins(series).size();
   }

   public Number getX(int series, int item) {
      List bins = getBins(series);
      HistogramBin bin = (HistogramBin) bins.get(item);
      double x = (bin.getStartBoundary() + bin.getEndBoundary()) / 2D;
      return new Double(x);
   }

   public Number getY(int series, int item) {
      List bins = getBins(series);
      HistogramBin bin = (HistogramBin) bins.get(item);
      double total = getTotal(series);
      double binWidth = getBinWidth(series);
      if (type == HistogramType.FREQUENCY)
         return new Double(bin.getCount());
      if (type == HistogramType.RELATIVE_FREQUENCY)
         return new Double((double) bin.getCount() / total);
      if (type == HistogramType.SCALE_AREA_TO_1)
         return new Double((double) bin.getCount() / (binWidth * total));
      else
         throw new IllegalStateException();
   }

   public Number getStartX(int series, int item) {
      List bins = getBins(series);
      HistogramBin bin = (HistogramBin) bins.get(item);
      return new Double(bin.getStartBoundary());
   }

   public Number getEndX(int series, int item) {
      List bins = getBins(series);
      HistogramBin bin = (HistogramBin) bins.get(item);
      return new Double(bin.getEndBoundary());
   }

   public Number getStartY(int series, int item) {
      return getY(series, item);
   }

   public Number getEndY(int series, int item) {
      return getY(series, item);
   }

   public boolean equals(Object obj) {
      if (obj == this)
         return true;
      if (!(obj instanceof CustomHistogramDataset))
         return false;
      CustomHistogramDataset that = (CustomHistogramDataset) obj;
      if (!ObjectUtilities.equal(type, that.type))
         return false;
      return ObjectUtilities.equal(list, that.list);
   }

   public Object clone() throws CloneNotSupportedException {
      return super.clone();
   }
}