Attachment #16 for bug #21

View | Details | Raw Unified | Return to bug 21
Collapse All | Expand All

(-)a/src/core/random-variable.h (-1 / +1 lines)

Lines 23-29	Link Here

#include <vector>

#include <vector>

#include <algorithm>

#include <algorithm>

#include "ns3/cairo-wideint-private.h"

#include <stdint.h>

/**

/**

 * \defgroup randomvariable Random Variable Distributions

 * \defgroup randomvariable Random Variable Distributions

(-)a/src/core/rng-stream.h (-1 / +1 lines)

Lines 20-26	Link Here

#ifndef RNGSTREAM_H

#ifndef RNGSTREAM_H

#define RNGSTREAM_H

#define RNGSTREAM_H

#include <string>

#include <string>

#include "ns3/cairo-wideint-private.h"

#include <stdint.h>

namespace ns3{

namespace ns3{




 *  - \ref ns3-Time-Min ns3::Min
 */
  
typedef uint64_t ts_precision_t;
  /*
   * Determines the base unit to store time values. If the
   * SetTsPrecision function is called, it must be set before any
   * TimeValue objects are created. All TimeUnit objects will use the
   * same time precision value.  The actual time can be
   * extracted as follows: m_data*10^(-m_tsPrecision) seconds.
   * tsPrecision == 0 : m_data stored in sec
   * tsPrecision == 3 : m_data stored in ms
   * tsPrecision == 6 : m_data stored in us
   * tsPrecision == 9 : m_data stored in ns
   * tsPrecision == 12 : m_data stored in ps
   * The default timestep precision units are ns.
   */
static const ts_precision_t SEC = 0;
static const ts_precision_t MS = 3;
static const ts_precision_t US = 6;
static const ts_precision_t NS = 9;
static const ts_precision_t PS = 12;
static const ts_precision_t FS = 15;

void SetTsPrecision(ts_precision_t newTsPrecision);
ts_precision_t GetTsPrecision();
static int64_t m_tsPrecisionFactor = (int64_t)pow(10,m_tsPrecision);
  // static void SetTsPrecision(ts_precision_t tsPrecision);
  // static ts_precision_t GetTsPrecision();

template <int N>
class TimeUnit

   *          instance.
   */
  double GetSeconds (void) const;

  /**
   * \returns an approximation in milliseconds of the time stored in this
   *          instance.
   */  
  int64_t GetMilliSeconds (void) const;
  /**
   * \returns an approximation in microseconds of the time stored in this

    return &m_data;
  }

  static uint64_t UnitsToTimestep (uint64_t unitValue, 
                                   ts_precision_t unitFactor);
private:
  HighPrecision m_data;

  /*
   * \Returns the value of time_value in units of unitPrec. time_value
   * must be specified in timestep units (which are the same as the
   * m_tsPrecision units
   */
  int64_t ConvertToUnits (int64_t timeValue, uint64_t unitFactor) const;
};

/**





namespace ns3 {

static const uint64_t MS_FACTOR = (uint64_t)pow(10,3);
static const uint64_t US_FACTOR = (uint64_t)pow(10,6);
static const uint64_t NS_FACTOR = (uint64_t)pow(10,9);
static const uint64_t PS_FACTOR = (uint64_t)pow(10,12);
static const uint64_t FS_FACTOR = (uint64_t)pow(10,15);
static ts_precision_t tsPrecision = NS;
static uint64_t tsPrecFactor = NS_FACTOR;

ts_precision_t
GetTsPrecision (void)
{
  return tsPrecision;
}

void 
SetTsPrecision (ts_precision_t newTsPrecision)
{
  tsPrecision = newTsPrecision;
  tsPrecFactor = (uint64_t)pow(10, tsPrecision);
}

TimeUnit<1>::TimeUnit(const std::string& s)

    std::string trailer = s.substr(n, std::string::npos);
    if (trailer == std::string("s"))
    {
      m_data = HighPrecision (r * tsPrecFactor);
      return;
    }
    if (trailer == std::string("ms"))
    {
      m_data = HighPrecision ((int64_t)(r * (tsPrecFactor/pow(10,3))), 
                              false);
      return;
    }
    if (trailer == std::string("us"))
    {
      m_data = HighPrecision ((int64_t)(r * (tsPrecFactor/pow(10,6))), 
                              false);
      return;
    }
    if (trailer == std::string("ns"))
    {
      m_data = HighPrecision ((int64_t)(r * (tsPrecFactor/pow(10,9))), 
                              false);
      return;
    }
    if (trailer == std::string("ps"))
    {
      m_data = HighPrecision ((int64_t)(r * (tsPrecFactor/pow(10,12))), 
                              false);
      return;
    }
    if (trailer == std::string("fs"))
    {
      m_data = HighPrecision ((int64_t)(r * (tsPrecFactor/pow(10,15))), 
                              false);
      return;
    }

  }
  //else
  //they didn't provide units, assume seconds
  m_data = HighPrecision (atof(s.c_str()) * tsPrecFactor);
}

double 
TimeUnit<1>::GetSeconds (void) const
{
  double timeValue = GetHighPrecision ().GetDouble ();
  return timeValue/tsPrecFactor;
}

int64_t
TimeUnit<1>::ConvertToUnits (int64_t timeValue, uint64_t unitFactor) const
{
  uint64_t precFactor;
  // In order to avoid conversion to double, precFactor can't be less 1
  if (tsPrecFactor < unitFactor)
    {
      precFactor = unitFactor / tsPrecFactor;
      timeValue = timeValue * precFactor;
    }
  else
    {
      precFactor = tsPrecFactor / unitFactor;
      timeValue = timeValue / precFactor;
    }
  return timeValue;
}


int64_t 
TimeUnit<1>::GetMilliSeconds (void) const
{
  int64_t ts = GetTimeStep();
  int64_t ms = ConvertToUnits(ts, MS_FACTOR);

  return ms;
}
int64_t 
TimeUnit<1>::GetMicroSeconds (void) const
{
  int64_t ts = GetTimeStep();
  int64_t us = ConvertToUnits(ts, US_FACTOR);

  return us;
}
int64_t 
TimeUnit<1>::GetNanoSeconds (void) const
{
  int64_t ts = GetTimeStep();
  int64_t ns = ConvertToUnits(ts, NS_FACTOR);

  return ns;
}
int64_t 
TimeUnit<1>::GetPicoSeconds (void) const
{
  int64_t ts = GetTimeStep();
  int64_t ps = ConvertToUnits(ts, PS_FACTOR);

  return ps;
}
int64_t 
TimeUnit<1>::GetFemtoSeconds (void) const
{
  int64_t ts = GetTimeStep();
  int64_t fs = ConvertToUnits(ts, FS_FACTOR);

  return fs;
}

/**

int64_t
TimeUnit<1>::GetTimeStep (void) const
{
  int64_t timeValue = GetHighPrecision ().GetInteger ();
  return timeValue;
}




Time Seconds (double seconds)
{
  double d_sec = seconds * tsPrecFactor;
  return Time (HighPrecision (d_sec));
  //  return Time (HighPrecision ((int64_t)d_sec, false));
}

uint64_t
TimeUnit<1>::UnitsToTimestep (uint64_t unitValue, 
                              uint64_t unitFactor)
{
  uint64_t precFactor;
  // In order to avoid conversion to double, precFactor can't be less 1
  if (tsPrecFactor < unitFactor)
    {
      precFactor = unitFactor / tsPrecFactor;
      unitValue = unitValue / precFactor;
    }
  else
    {
      precFactor = tsPrecFactor / unitFactor;
      unitValue = unitValue * precFactor;
    }
  return unitValue;
}

Time MilliSeconds (uint64_t ms)
{
  uint64_t ts = TimeUnit<1>::UnitsToTimestep(ms, MS_FACTOR);
  return TimeStep(ts);
}

Time MicroSeconds (uint64_t us)
{
  uint64_t ts = TimeUnit<1>::UnitsToTimestep(us, US_FACTOR);
  return TimeStep(ts);
}

Time NanoSeconds (uint64_t ns)
{
  uint64_t ts = TimeUnit<1>::UnitsToTimestep(ns, NS_FACTOR);
  return TimeStep(ts);
}
Time PicoSeconds (uint64_t ps)
{
  uint64_t ts = TimeUnit<1>::UnitsToTimestep(ps, PS_FACTOR);
  return TimeStep(ts);
}
Time FemtoSeconds (uint64_t fs)
{
  uint64_t ts = TimeUnit<1>::UnitsToTimestep(fs, FS_FACTOR);
  return TimeStep(ts);
}

/*
 * The timestep value passed to this function must be of the precision
 * of m_tsPrecision
 */
Time TimeStep (uint64_t ts)
{

  virtual ~TimeTests ();
  virtual bool RunTests (void);

  /*
   * Verifies that a calculated time value is as expected using
   * doubles since GetSeconds() returns a double
   */ 

                    bool *flag, double precMultFactor = 1, 
                    bool verbose = false);

  /*
   * Verifies that a calculated time value is as expected.
   */ 
  void CheckTime(std::string test_id, int64_t actual, int64_t expected, 
                 bool *flag, double precMultFactor = 1, 
                 bool verbose = false);

  /*
   * Verifies the +, -, * and / operations for the TimeUnit<1> or Time class
   */
  void CheckOperations(Time t0, Time t1, bool *ok, bool verbose = false);

  /*
   * Verifies that the TimeUnit class stores values with the precision
   * set in the variable m_tsPrecision
   * Checks that overflow and underflow occur at expected numbers
   */
  void CheckPrecision(ts_precision_t prec, uint64_t val, bool *ok,
                      bool verbose = false);

  /*
   * Verifies that the conversion between units in the class
   * TimeUnit<1> or Time is done correctly. This is verified both when
   * setting and retrieving a Time value
   */
  void CheckConversions(uint64_t tval, bool *ok, bool verbose = false);

  /*
   * These are the old tests that used to be run
   */
  void CheckOld(bool *ok);

  CheckConversions((uint64_t)0, &ok);
  CheckConversions((uint64_t)783, &ok);
  CheckConversions((uint64_t)1132, &ok);
  //  CheckConversions((uint64_t)3341039, &ok);

  // Now vary the precision and check the conversions
  if (GetTsPrecision() != NS) {

  CheckConversions((uint64_t)7, &ok);
  CheckConversions((uint64_t)546, &ok);
  CheckConversions((uint64_t)6231, &ok);
  //  CheckConversions((uint64_t)1234639, &ok);

  CheckPrecision(MS, 3, &ok);

  CheckConversions((uint64_t)3, &ok);
  CheckConversions((uint64_t)134, &ok);
  CheckConversions((uint64_t)2341, &ok);
  //  CheckConversions((uint64_t)8956239, &ok);

  CheckPrecision(PS, 21, &ok);

  CheckConversions((uint64_t)4, &ok);
  CheckConversions((uint64_t)342, &ok);
  CheckConversions((uint64_t)1327, &ok);
  //  CheckConversions((uint64_t)5439627, &ok);

  CheckPrecision(NS, 12, &ok);
  CheckConversions((uint64_t)12, &ok);


  CheckPrecision(FS, 5, &ok);
  CheckConversions((uint64_t)5, &ok);

  SetTsPrecision(NS);

  return ok;
}

  
}

void TimeTests::CheckPrecision(ts_precision_t prec, uint64_t val, bool *ok, 
                               bool verbose) {
  if (verbose) {
    std::cout << "check precision 10^-" << prec << std::endl;

                              double expected, bool *flag, double precMultFactor,
                              bool verbose)
{
  double prec = pow(10,-((double)(ns3::tsPrecision))) * precMultFactor;
  if ((actual < (expected-prec)) || (actual > (expected+prec))) {
    std::cout << "FAIL " << test_id 
              << " Expected:" << expected 

                           int64_t expected, bool *flag, double precMultFactor,
                           bool verbose)
{
  double prec = pow(10,-((double)(ns3::tsPrecision))) * precMultFactor;
  if ((actual < (expected-prec)) || (actual > (expected+prec))) {
    std::cout << "FAIL " << test_id 
              << " Expected:" << expected 

Return to bug 21