Timer.cpp

Go to the documentation of this file.

// Timer.cpp: implementation of the Timer class.
//
 
#include "Timer.h"
#include <boost/serialization/export.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(Timer)
using namespace std;
 
// Construction/Destruction
 
Timer::Timer() {
  remaining_time = 0.0;
  total_time_required = 0.0;
  t_minimum = 1.0;
  alpha_weibull = 5.0;
  beta_weibull = 2.0;
  number_of_intervals = 0;
  number_of_intervals_passed = 1;
  time_at_demand = 0.0;
}
 
Timer::~Timer() {
 
}
void Timer::setRemainingTime(double x) { remaining_time = x; }
double Timer::getRemainingTime() { return remaining_time; }
void Timer::setTotalTimeRequired(double x) { total_time_required = x; }
double Timer::getTotalTimeRequired() { return total_time_required; }
void Timer::setAlpha_Weibull(double x) { alpha_weibull = x; }
double Timer::getAlpha_Weibull() { return alpha_weibull; }
void Timer::setBeta_Weibull(double x) { beta_weibull = x; }
double Timer::getBeta_Weibull() { return beta_weibull; }
void Timer::setT_Minimum(double x) { t_minimum = x; }
double Timer::getT_Minimum() { return t_minimum; }
double Timer::reduceRemainingTime(double x) {
  remaining_time -= x;
  return remaining_time;
}
void Timer::copyTimer(Timer &_timer) {
  remaining_time = _timer.getRemainingTime();
  total_time_required = _timer.getTotalTimeRequired();
  alpha_weibull = _timer.getAlpha_Weibull();
  beta_weibull = _timer.getBeta_Weibull();
  t_minimum = _timer.getT_Minimum();
  number_of_intervals = _timer.getNumberOfIntervals();
  number_of_intervals_passed = _timer.getNumberOfIntervalsPassed();
  time_at_demand = _timer.getTimeAtDemand();
}
void Timer::saveTimerToFile(ofstream &fout) {
  fout << remaining_time << ' ' << total_time_required << ' '
       << alpha_weibull << ' ' << beta_weibull << ' '
       << t_minimum << '\n';
}
void Timer::retrieveTimerFromFile(ifstream &fin) {
  fin >> remaining_time >> total_time_required
      >> alpha_weibull >> beta_weibull
      >> t_minimum;
}
bool Timer::checkIfIsIdenticalTimer(Timer &_timer) {
  bool matched = true;
  if (fabs(remaining_time - _timer.getRemainingTime()) > 0.1) {
    matched = false;
  }
  return false;
}
void Timer::setBothTotalTimeRequiredAndRemainingTime(double x) {
  remaining_time = x;
  total_time_required = x;
}
 
double Timer::calculateRequiredTime() {
  double cdf, t;
  // pick a random number for cdf
  cdf = static_cast<double>(rand()) / static_cast<double>(RAND_MAX);
  // calculate time based on weibull distribution
  t = alpha_weibull * pow(-log(1.0 - cdf), 1.0 / beta_weibull) + t_minimum;
  return t;
}
 
double Timer::calculateRequiredTime(double _cdf) {
  double t;
  t = alpha_weibull * pow(-log(1.0 - _cdf), 1.0 / beta_weibull) + t_minimum;
  return t;
}
 
double Timer::calculateWeibull_pdf(double _t) {
  double pdf;
  if (_t > t_minimum) {
    pdf = (beta_weibull / alpha_weibull) * pow((_t - t_minimum) / alpha_weibull, beta_weibull - 1.0)
        * exp(-pow((_t - t_minimum) / alpha_weibull, beta_weibull));
  } else {
    pdf = 0.0;
  }
  return pdf;
}
 
double Timer::calculateMeanRequiredTime(double _lower, double _upper) {
  // calcalate mean time within cdf interval defined by _lower and _upper
  double t_lower, t_upper, h, tmean, sum;
  double t1, t2, s0, s1, s2;
  s1 = 0.0;
  s2 = 0.0;
  sum = 0.0;
  int m, j;
  m = 500; // number of intervals
  // cap upper bound if cdf value is close to 1.0
  if (_upper > 0.999999) { _upper = 0.999999; }
  //
  t_lower = this->calculateRequiredTime(_lower);
  t_upper = this->calculateRequiredTime(_upper);
  h = (t_upper - t_lower) / (2 * (double) m);
  s0 = this->calculateWeibull_pdf(t_lower) + this->calculateWeibull_pdf(t_upper);
  for (j = 0; j != m - 1; j++) {
    t1 = t_lower + (2.0 * j + 1.0) * h;
    t2 = t_lower + 2 * h * (j + 1.0);
    s1 += t1 * this->calculateWeibull_pdf(t1);
    s2 += t2 * this->calculateWeibull_pdf(t2);
  }
  s1 += (t_lower + h * (2.0 * (m - 1.0) + 1)) * this->calculateWeibull_pdf(t_lower + h * (2.0 * (m - 1.0) + 1));
  sum = h * (s0 + 4.0 * s1 + 2.0 * s2) / 3.0;
  tmean = sum / (_upper - _lower);
  //
  return tmean;
}
 
double Timer::calculateMeanRequiredTime() {
  // calcalate mean time within cdf interval defined by _lower and _upper
  double t_lower, t_upper, h, tmean, sum;
  double t1, t2, s0, s1, s2;
  s1 = 0.0;
  s2 = 0.0;
  sum = 0.0;
  int m, j;
  m = 500; // number of intervals
  //
  t_lower = this->calculateRequiredTime(0.0);
  t_upper = this->calculateRequiredTime(0.999999);
  h = (t_upper - t_lower) / (2 * (double) m);
  s0 = this->calculateWeibull_pdf(t_lower) + this->calculateWeibull_pdf(t_upper);
  for (j = 0; j != m - 1; j++) {
    t1 = t_lower + (2.0 * j + 1.0) * h;
    t2 = t_lower + 2 * h * (j + 1.0);
    s1 += t1 * this->calculateWeibull_pdf(t1);
    s2 += t2 * this->calculateWeibull_pdf(t2);
  }
  s1 += (t_lower + h * (2.0 * (m - 1.0) + 1)) * this->calculateWeibull_pdf(t_lower + h * (2.0 * (m - 1.0) + 1));
  sum = h * (s0 + 4.0 * s1 + 2.0 * s2) / 3.0;
  tmean = sum;
  return tmean;
}
int Timer::getNumberOfIntervals() const {
  return number_of_intervals;
}
void Timer::setNumberOfIntervals(int number_of_intervals) {
  Timer::number_of_intervals = number_of_intervals;
}
int Timer::getNumberOfIntervalsPassed() const {
  return number_of_intervals_passed;
}
void Timer::setNumberOfIntervalsPassed(int number_of_intervals_passed) {
  Timer::number_of_intervals_passed = number_of_intervals_passed;
}
double Timer::getTimeAtDemand() const {
  return time_at_demand;
}
void Timer::setTimeAtDemand(double time_at_demand) {
  Timer::time_at_demand = time_at_demand;
}