Accumulate.java

/*
 * Class:        Accumulate
 * Description:  collects statistics on a variable that evolves in
                 simulation time
 * 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.simevents;
// This class doesn't belong to package stat because objects of this class
 
// always depend of Simulator
 
import java.util.Observable;
import umontreal.ssj.util.PrintfFormat;
import umontreal.ssj.stat.StatProbe;

public class Accumulate extends StatProbe implements Cloneable {
 
   private double initTime; // Initialization time.
   private double lastTime; // Last update time.
   private double lastValue; // Value since last update.
   private Simulator sim;

   public Accumulate() {
      super();
      sim = Simulator.getDefaultSimulator();
      init();
   }

   public Accumulate(Simulator inSim) {
      super();
      if (inSim == null)
         throw new NullPointerException();
      sim = inSim;
      init();
   }

   public Accumulate(String name) {
      super();
      sim = Simulator.getDefaultSimulator();
      this.name = name;
      init();
   }

   public Accumulate(Simulator inSim, String name) {
      super();
      if (inSim == null)
         throw new NullPointerException();
      sim = inSim;
      this.name = name;
      init();
   }

   public void init() {
      maxValue = Double.MIN_VALUE;
      minValue = Double.MAX_VALUE;
      lastValue = 0.0;
      sumValue = 0.0;
      // May start the accumulator at t > 0; for ex., a warm-up period or
      // other reasons
      initTime = lastTime = sim.time();
   }

   public void init(double x) {
      init();
      update(x);
   }

   public void update() {
      update(lastValue);
   }

   public void update(double x) {
      if (collect) {
         double time = sim.time();
         if (x < minValue)
            minValue = x;
         if (x > maxValue)
            maxValue = x;
         sumValue += lastValue * (time - lastTime);
         lastValue = x;
         lastTime = time;
      }
      if (broadcast) {
         // setChanged();
         notifyListeners(x);
      }
   }
 
   public double sum() {
      update(lastValue);
      return sumValue;
   }

   public double average() {
      update(lastValue);
      double periode = lastTime - initTime;
      if (periode > 0.0)
         return sumValue / periode;
      else
         return 0.0;
   }
 
   public String shortReportHeader() {
      PrintfFormat pf = new PrintfFormat();
      pf.append(-9, "from time").append("   ");
      pf.append(-9, "to time").append("   ");
      pf.append(-8, "   min").append("   ");
      pf.append(-8, "   max").append("   ");
      pf.append(-10, " average");
      return pf.toString();
   }
 
   public String shortReport() {
      update();
      PrintfFormat pf = new PrintfFormat();
      pf.append(9, 2, 2, getInitTime()).append("   ");
      pf.append(9, 2, 2, getLastTime()).append("   ");
      pf.append(8, 3, 2, min()).append("   ");
      pf.append(8, 3, 2, max()).append("   ");
      pf.append(10, 3, 2, average());
      return pf.toString();
   }

   public String report() {
      update(lastValue);
      PrintfFormat str = new PrintfFormat();
      str.append("REPORT on Accumulate stat. collector ==> " + name);
      str.append(PrintfFormat.NEWLINE + "      from time   to time       min         max");
      str.append("         average").append(PrintfFormat.NEWLINE);
      str.append(12, 2, 2, initTime);
      str.append(13, 2, 2, lastTime);
      str.append(11, 3, 2, minValue);
      str.append(12, 3, 2, (double) maxValue);
      str.append(14, 3, 2, (double) average()).append(PrintfFormat.NEWLINE);
 
      return str.toString();
   }

   public double getInitTime() {
      return initTime;
   }

   public double getLastTime() {
      return lastTime;
   }

   public double getLastValue() {
      return lastValue;
   }

   public Simulator simulator() {
      return sim;
   }

   public void setSimulator(Simulator sim) {
      if (sim == null)
         throw new NullPointerException();
      this.sim = sim;
   }

   public Accumulate clone() {
      try {
         return (Accumulate) super.clone();
      } catch (CloneNotSupportedException e) {
         throw new IllegalStateException("Accumulate can't clone");
      }
   }
 
}