AdaptHistFillApplet.java - similar to TimerHistApplet in the Timers section except that it uses HistogramAdapt (see below). It also borrows code from HistStatsApplet in Chapter 7: Tech for displaying statistical info in a popup frame.

As before, a timer is used to indicate when an update to the plot should occur. The data making is done in the thread object, MakeData, and the class implements Updateable interface to provide for callbacks.

+ New class:
HistogramAdapt.java - subclass of HistogramStat, which is in turn a subclass of Histogram. Provides for dynamically extending the histogram limits to fit all data values.

+ Previous classes:
Chapter 8:Tech: MakeData.java, Updateable.java
Chapter 7:Tech: HistogramStat.java,
Chapter 6:Tech: Histogram.java, HistPanel.java
Chapter 6:Tech: PlotPanel.java, PlotFormat.java

/**
  *  This class provides provides histograms that offer the option
  *  to adapt the range to keep all points within bin limits. This
  *  requires a data array to hold each individual entry.
  *  Requires an expandable data storage array to hold each data point.
 **/
public class HistogramAdapt extends HistogramStat
{
  // flag for adapting the limits to the data
  boolean fAdapt = true;

  // flag to indicate a value outside limits
  boolean fNeedToRebin = false;

  // data array.
  double [] fData ;

  // index pointing where next datum goes
  int fDataIndex = 0;

  /**
    * Constructor
    *
    * @param estmated number of data points.
    *   Negative to turn off adaptable binning.
    * @param number of bins for the histogram.
    * @param lowest value of bin.
    * @param highest value of bin.
    * @param size of data array. Must equal number of data points
    *        expected to be entered into the histogram.
   **/
  public HistogramAdapt (int num_bins, double lo, double hi,
                        int num_data) {
    super (num_bins,lo,hi);
    if (num_data <= 0 )
        fAdapt = false;
    else
        setData (num_data);
  } // ctor

  /**
    * Constructor with title and x axis label.
    *
    * @param title for histogram
    * @param estmated number of data points.
    *   Negative to turn off adaptable binning.
    * @param label for x axis of histogram.
    * @param inital number of bins for the histogram.
    * @param lowest value of bin.
    * @param highest value of bin.
    * @param size of data array. Must equal number of data points
    *        expected to be entered into the histogram.
   **/
  public HistogramAdapt (String title, String x_label, int num_bins,
                       double lo, double hi, int num_data) {
    super (title, x_label, num_bins,lo,hi);

    if (num_data <= 0)
        fAdapt = false;
    else
        setData (num_data);
  } // ctor

  /** Create a data array if needed. **/
  void setData (int num_data) {
    // If previous data already present then
    // check if room for the new data. If not
    // then create a bigger data array.
    if (fDataIndex > 0 ) {
        int dataNeeded = fDataIndex + num_data + 1;
        if (dataNeeded > fData.length) {
          // Make a new data array
          double [] tmp = new double[dataNeeded];
          // Copy the old data into it
          System.arraycopy (fData,0,tmp,0,fData.length);
          // Move reference to new array
          fData = tmp;
       }
    } else // Create an initial or bigger data array if needed.
      if (fData == null || num_data > fData.length)
          fData = new double[num_data];
  } // setData

  /**
    * Clear the histogram and also reset the data array index
    * to the beginning.
   **/
  public void reset () {
    super.clear (); // Clear histogram arrys
    fDataIndex = 0; // reset data array pointer to beginning
  }

  /**  Provide access to the data array.**/
  double [] getData () {
    return fData;
  }

/**
   * Can enable or disable the range adaption.
   *
   * @param boolean to turn on or off the extending of the limits
   *   when data values outside current limits occur.
  **/
  void setAdaptEnabled (boolean flag) {
    fAdapt = flag;
  }

/**
   * Add an entry to the histogram. Check if value outside current
   * limits of the histogram. If it is and the adaptation flag turned
   * on, then rebin the histogram.


   * Synchronize so that
   *
   * @param non-zero length array of int values.
  **/
  public synchronized void add (double x) {
    if (fAdapt) {
        // Add new data point to array
        if (fDataIndex < fData.length) {
            fData[fDataIndex++] = x;
            // If data point outside range, set rebin flag.
            if (x < fLo || x > fHi) fNeedToRebin = true;
        } else {
            // Could throw an exception, open a warning
            // dialog, or use setData () to create a bigger data array.
            // However, we just do a simple console print.
            System.out.println ("Data overflow");
        }
    }
    addEntry (x);
  } // add

  /**
    *  Rebin the histogram using the data array.
    *  Synchronize to avoid interference with new data
    *  entering during this method.
   **/
  public synchronized void rebin () {
    if (fDataIndex <= 1) return;

    // Find new limits from the out of range datum,
    for (int i=0; i < fDataIndex; i++) {
        if ( fData[i] < fLo) fLo = fData[i];
        if ( fData[i] > fHi) fHi = fData[i];
    }

    // Set new limits
    fLo = Math.floor (fLo);
    fHi = Math.ceil (fHi);
    fRange = fHi - fLo;

    // Clear the histogram entries
    clear ();

    // Refill the histogram according to the new range.
    addFromDataArray ();

    fNeedToRebin = false;

  } // rebin

  /**  Add a value to the histogram and do the stats. **/
  public void addEntry (double x) {
    // Add entry
    super.add (x);

    // Then do moments if flag set.
    if (!fDoDataStats)
        return;
    else {
        fMoments[0] += 1;
        fMoments[1] += x;
        double x2 = x * x;
        fMoments[2] += x2;
        fMoments[3] += x2 * x;
        fMoments[4] += x2 * x2;
    }

  } // addEntry

  /**  Use the data array to fill the histogram **/
  public void addFromDataArray () {
    for (int i=0; i < fDataIndex; i++) {
       addEntry (fData[i]);
    }
  }

  /** Return index to data array element pointer. **/
  int getDataIndex () {
    return fDataIndex;
  }

  /**  Turn on or off the rebin request flag. **/
  void setRebinFlag (boolean flag) {
    fNeedToRebin = flag;
  }

  /**  Find if rebin request turned on. **/
  boolean getRebinFlag () {
    return fNeedToRebin;
  }

} // class HistogramAdapt

1  2  3  4  5  6  7  8  9  10  11  12