Attachment #104 for bug #133

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




  m_socket = 0;
  m_peer = remote;
  m_connected = false;
  m_onTime = onTime;
  m_offTime = offTime;
  m_pktSize = size;
  m_residualBits = 0;
  m_lastStartTime = Seconds (0);

  NS_LOG_FUNCTION;

  m_socket = 0;
  delete m_onTime;
  delete m_offTime;

  m_onTime = 0;
  m_offTime = 0;

  // chain up
  Application::DoDispose ();
}

{  // Schedules the event to start sending data (switch to the "On" state)
  NS_LOG_FUNCTION;

  Time offInterval = Seconds(m_offTime.GetValue());
  NS_LOG_LOGIC ("start at " << offInterval);
  m_startStopEvent = Simulator::Schedule(offInterval, &OnOffApplication::StartSending, this);
}

{  // Schedules the event to stop sending data (switch to "Off" state)
  NS_LOG_FUNCTION;

  Time onInterval = Seconds(m_onTime.GetValue());
  Simulator::Schedule(onInterval, &OnOffApplication::StopSending, this);
}


(-)a/src/applications/onoff/onoff-application.h (-2 / +3 lines)

Lines 30-35	Link Here

#include "ns3/ptr.h"

#include "ns3/ptr.h"

#include "ns3/data-rate.h"

#include "ns3/data-rate.h"

#include "ns3/callback-trace-source.h"

#include "ns3/callback-trace-source.h"

#include "ns3/random-variable.h"

namespace ns3 {

namespace ns3 {

Lines 128-135 private:	Link Here

128

  Ptr<Socket>     m_socket;       // Associated socket

129

  Ptr<Socket>     m_socket;       // Associated socket

129

  Address         m_peer;         // Peer address

130

  Address         m_peer;         // Peer address

130

  bool            m_connected;    // True if connected

131

  bool            m_connected;    // True if connected

131

  RandomVariable* m_onTime;       // rng for On Time

132

  RandomVariable m_onTime;       // rng for On Time

132

  RandomVariable* m_offTime;      // rng for Off Time

133

  RandomVariable m_offTime;      // rng for Off Time

133

  DataRate        m_cbrRate;      // Rate that data is generated

134

  DataRate        m_cbrRate;      // Rate that data is generated

134

  uint32_t        m_pktSize;      // Size of packets

135

  uint32_t        m_pktSize;      // Size of packets

135

  uint32_t        m_residualBits; // Number of generated, but not sent, bits

136

  uint32_t        m_residualBits; // Number of generated, but not sent, bits




{
  NS_LOG_FUNCTION;
  // Assume a uniform random variable if user does not specify
  m_ranvar = UniformVariable ();
}

RateErrorModel::~RateErrorModel () 
{
  NS_LOG_FUNCTION;
  delete m_ranvar;
}

enum ErrorUnit 

RateErrorModel::SetRandomVariable (const RandomVariable &ranvar)
{
  NS_LOG_FUNCTION;
  m_ranvar = ranvar;
  m_ranvar = ranvar.Copy ();
}

bool 

RateErrorModel::DoCorruptPkt (Ptr<Packet> p)
{
  NS_LOG_FUNCTION;
  return (m_ranvar.GetValue () < m_rate);
}

bool

  NS_LOG_FUNCTION;
  // compute pkt error rate, assume uniformly distributed byte error
  double per = 1 - pow (1.0 - m_rate, p->GetSize ());
  return (m_ranvar.GetValue () < per);
}

bool

  NS_LOG_FUNCTION;
  // compute pkt error rate, assume uniformly distributed bit error
  double per = 1 - pow (1.0 - m_rate, (8 * p->GetSize ()) );
  return (m_ranvar.GetValue () < per);
}

void 





#include <list>
#include "ns3/object.h"
#include "ns3/random-variable.h"

namespace ns3 {

class Packet;
class RandomVariable;

/**
 * \brief General error model that can be used to corrupt packets

  enum ErrorUnit m_unit;
  double m_rate;

  RandomVariable m_ranvar;
};

/**




  DefaultValueList::Add (this);
}

RandomVariable
RandomVariableDefaultValue::Get (void) const
{
  RandomVariable variable;
  bool ok;
  ok = Parse (m_value, true, &variable);
  NS_ASSERT (ok);
  return variable;
}
double
RandomVariableDefaultValue::ReadAsDouble (std::string value, bool &ok) const
{
  double v;
  std::istringstream iss;

}
bool
RandomVariableDefaultValue::Parse (const std::string &value, 
				   bool mustCreate, RandomVariable *pVariable) const
{
  std::string::size_type pos = value.find_first_of(":");
  if (pos == std::string::npos)

      if (mustCreate)
	{
          NS_LOG_LOGIC ("create Constant constant=" << constant);
	  *pVariable = ConstantVariable (constant);
	}
      else
        {

      if (mustCreate)
	{
          NS_LOG_LOGIC ("create Uniform min=" << min << ", max=" << max);
	  *pVariable = UniformVariable (minVal, maxVal);
	}
      else
        {

(-)a/src/core/random-variable-default-value.h (-3 / +3 lines)

Lines 33-42 class RandomVariableDefaultValue : publi	Link Here

			      std::string help,

			      std::string help,

			      std::string defaultValue);

			      std::string defaultValue);

  RandomVariable *GetCopy (void);

  RandomVariable Get (void) const;

private:

private:

  bool Parse (const std::string &value, bool mustCreate, RandomVariable **pVariable);

  bool Parse (const std::string &value, bool mustCreate, RandomVariable *pVariable) const;

  double ReadAsDouble (const std::string value, bool &ok);

  double ReadAsDouble (const std::string value, bool &ok) const;

  virtual bool DoParseValue (const std::string &value);

  virtual bool DoParseValue (const std::string &value);

  virtual std::string DoGetType (void) const;

  virtual std::string DoGetType (void) const;

  virtual std::string DoGetDefaultValue (void) const;

  virtual std::string DoGetDefaultValue (void) const;




#include <fcntl.h>       


#include "assert.h"
#include "random-variable.h"
#include "rng-stream.h"
#include "fatal-error.h"


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// RandomVariableBase methods


class RandomVariableBase 
{
public:
  RandomVariableBase ();
  RandomVariableBase (const RandomVariableBase &o);
  virtual ~RandomVariableBase();
  virtual double  GetValue() = 0;
  virtual uint32_t GetIntValue();
  virtual RandomVariableBase*   Copy(void) const = 0;
  virtual void GetSeed(uint32_t seed[6]);

  static  void UseDevRandom(bool udr = true);
  static void UseGlobalSeed(uint32_t s0, uint32_t s1, uint32_t s2, 
                            uint32_t s3, uint32_t s4, uint32_t s5);
  static void SetRunNumber(uint32_t n);
private:
  static void GetRandomSeeds(uint32_t seeds[6]);
private:
  static bool useDevRandom;    // True if using /dev/random desired
  static bool globalSeedSet;   // True if global seed has been specified
  static int  devRandom;       // File handle for /dev/random
  static uint32_t globalSeed[6]; // The global seed to use
  friend class RandomVariableInitializer;
protected:
  static unsigned long heuristic_sequence;
  static RngStream* m_static_generator;
  static uint32_t runNumber;
  static void Initialize();    // Initialize  the RNG system
  static bool initialized;     // True if package seed is set 
  RngStream* m_generator;  //underlying generator being wrapped
};



bool          RandomVariableBase::initialized = false;   // True if RngStream seed set 
bool          RandomVariableBase::useDevRandom = false;  // True if use /dev/random
bool          RandomVariableBase::globalSeedSet = false; // True if GlobalSeed called
int           RandomVariableBase::devRandom = -1;
uint32_t      RandomVariableBase::globalSeed[6];
unsigned long RandomVariableBase::heuristic_sequence;
RngStream*    RandomVariableBase::m_static_generator = 0;
uint32_t      RandomVariableBase::runNumber = 0;

//the static object random_variable_initializer initializes the static members
//of RandomVariable

  public:
  RandomVariableInitializer()
  {
//     RandomVariableBase::Initialize(); // sets the static package seed
//     RandomVariableBase::m_static_generator = new RngStream();
//     RandomVariableBase::m_static_generator->InitializeStream();
  }
  ~RandomVariableInitializer()
  {
    delete RandomVariableBase::m_static_generator;
  }
} random_variable_initializer;

RandomVariableBase::RandomVariableBase() 
  : m_generator(NULL)
{
//   m_generator = new RngStream();
//   m_generator->InitializeStream();
//   m_generator->ResetNthSubstream(RandomVariableBase::runNumber);
}

RandomVariableBase::RandomVariableBase(const RandomVariableBase& r)
  :m_generator(0)
{
  if(r.m_generator)

  }
}

RandomVariableBase::~RandomVariableBase()
{
  delete m_generator;
}

uint32_t RandomVariableBase::GetIntValue() 
{
  return (uint32_t)GetValue();
}

void RandomVariableBase::UseDevRandom(bool udr) 
{
  RandomVariableBase::useDevRandom = udr;
}

void RandomVariableBase::GetSeed(uint32_t seed[6])
{
  if(!m_generator)
  {
    m_generator = new RngStream();
    m_generator->InitializeStream();
    m_generator->ResetNthSubstream(RandomVariableBase::runNumber);
  }
  m_generator->GetState(seed);
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// RandomVariableBase static methods
void RandomVariableBase::UseGlobalSeed(uint32_t s0, uint32_t s1, uint32_t s2, 
                                   uint32_t s3, uint32_t s4, uint32_t s5)
{
  if (RandomVariableBase::globalSeedSet)
    {
      cerr << "Random number generator already initialized!" << endl;
      cerr << "Call to RandomVariableBase::UseGlobalSeed() ignored" << endl;
      return;
    }
  RandomVariableBase::globalSeed[0] = s0;
  RandomVariableBase::globalSeed[1] = s1;
  RandomVariableBase::globalSeed[2] = s2;
  RandomVariableBase::globalSeed[3] = s3;
  RandomVariableBase::globalSeed[4] = s4;
  RandomVariableBase::globalSeed[5] = s5;
  if (!RngStream::CheckSeed(RandomVariableBase::globalSeed))
    NS_FATAL_ERROR("Invalid seed");
  
  RandomVariableBase::globalSeedSet = true;
}

void RandomVariableBase::Initialize()
{ 
  if (RandomVariableBase::initialized) return; // Already initialized and seeded
  RandomVariableBase::initialized = true;
  if (!RandomVariableBase::globalSeedSet)
    { // No global seed, try a random one
      GetRandomSeeds(globalSeed);
    }

  RngStream::SetPackageSeed(globalSeed);
}

void RandomVariableBase::GetRandomSeeds(uint32_t seeds[6])
{
  // Check if /dev/random exists
  if (RandomVariableBase::useDevRandom && RandomVariableBase::devRandom < 0)
    {
      RandomVariableBase::devRandom = open("/dev/random", O_RDONLY);
    }
  if (RandomVariableBase::devRandom > 0)
    { // Use /dev/random
      while(true)
        {
          for (int i = 0; i < 6; ++i)
            {
              read(RandomVariableBase::devRandom, &seeds[i], sizeof(seeds[i]));
            }
          if (RngStream::CheckSeed(seeds)) break; // Got a valid one
        }

    }
}

void RandomVariableBase::SetRunNumber(uint32_t n)
{
  runNumber = n;
}



RandomVariable::RandomVariable()
  : m_variable (0)
{}
RandomVariable::RandomVariable(const RandomVariable&o)
  : m_variable (o.m_variable->Copy ())
{}
RandomVariable::RandomVariable (const RandomVariableBase &variable)
  : m_variable (variable.Copy ())
{}
RandomVariable &
RandomVariable::operator = (const RandomVariable &o)
{
  delete m_variable;
  m_variable = o.m_variable->Copy ();
  return *this;
}
RandomVariable::~RandomVariable()
{
  delete m_variable;
}
double  
RandomVariable::GetValue (void) const
{
  return m_variable->GetValue ();
}

uint32_t 
RandomVariable::GetIntValue (void) const
{
  return m_variable->GetIntValue ();
}
void 
RandomVariable::GetSeed(uint32_t seed[6]) const
{
  return m_variable->GetSeed (seed);
}
void 
RandomVariable::UseDevRandom(bool udr)
{
  RandomVariableBase::UseDevRandom (udr);
}
void 
RandomVariable::UseGlobalSeed(uint32_t s0, uint32_t s1, uint32_t s2, 
                              uint32_t s3, uint32_t s4, uint32_t s5)
{
  RandomVariableBase::UseGlobalSeed (s0, s1, s2, s3, s4, s5);
}
void 
RandomVariable::SetRunNumber(uint32_t n)
{
  RandomVariableBase::SetRunNumber (n);
}
RandomVariableBase *
RandomVariable::Peek (void)
{
  return m_variable;
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// UniformVariableImpl

class UniformVariableImpl : public RandomVariableBase {
public:
  /**
   * Creates a uniform random number generator in the
   * range [0.0 .. 1.0).
   */
  UniformVariableImpl();

  /**
   * Creates a uniform random number generator with the specified range
   * \param s Low end of the range
   * \param l High end of the range
   */
  UniformVariableImpl(double s, double l);

  UniformVariableImpl(const UniformVariableImpl& c);
  
  /**
   * \return A value between low and high values specified by the constructor
   */
  virtual double GetValue();
  virtual RandomVariableBase*  Copy(void) const;

public:
  /**
   * \param s Low end of the range
   * \param l High end of the range
   * \return A uniformly distributed random number between s and l
   */
  static double GetSingleValue(double s, double l);
private:
  double m_min;
  double m_max;
};

UniformVariableImpl::UniformVariableImpl() 
  : m_min(0), m_max(1.0) { }
  
UniformVariableImpl::UniformVariableImpl(double s, double l) 
  : m_min(s), m_max(l) { }

UniformVariableImpl::UniformVariableImpl(const UniformVariableImpl& c) 
  : RandomVariableBase(c), m_min(c.m_min), m_max(c.m_max) { }

double UniformVariableImpl::GetValue()
{
  if(!RandomVariableBase::initialized)
  {
    RandomVariableBase::Initialize();
  }
  if(!m_generator)
  {
    m_generator = new RngStream();
    m_generator->InitializeStream();
    m_generator->ResetNthSubstream(RandomVariableBase::runNumber);
  }
  return m_min + m_generator->RandU01() * (m_max - m_min);
}

RandomVariableBase* UniformVariableImpl::Copy() const
{
  return new UniformVariableImpl(*this);
}

double UniformVariableImpl::GetSingleValue(double s, double l)
{
  if(!RandomVariableBase::m_static_generator)
  {
    RandomVariableBase::Initialize(); // sets the static package seed
    RandomVariableBase::m_static_generator = new RngStream();
    RandomVariableBase::m_static_generator->InitializeStream();
  }
  return s + m_static_generator->RandU01() * (l - s);;
}

UniformVariable::UniformVariable()
  : RandomVariable (UniformVariableImpl ())
{}
UniformVariable::UniformVariable(double s, double l)
  : RandomVariable (UniformVariableImpl (s, l))
{}
double 
UniformVariable::GetSingleValue(double s, double l)
{
  return UniformVariableImpl::GetSingleValue (s, l);
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// ConstantVariableImpl methods

class ConstantVariableImpl : public RandomVariableBase { 

public:
  /**
   * Construct a ConstantVariableImpl RNG that returns zero every sample
   */
  ConstantVariableImpl();
  
  /**
   * Construct a ConstantVariableImpl RNG that returns the specified value
   * every sample.
   * \param c Unchanging value for this RNG.
   */
  ConstantVariableImpl(double c);


  ConstantVariableImpl(const ConstantVariableImpl& c) ;

  /**
   * \brief Specify a new constant RNG for this generator.
   * \param c New constant value for this RNG.
   */
  void    NewConstant(double c);

  /**
   * \return The constant value specified
   */
  virtual double  GetValue();
  virtual uint32_t GetIntValue();
  virtual RandomVariableBase*   Copy(void) const;
private:
  double m_const;
};

ConstantVariableImpl::ConstantVariableImpl() 
  : m_const(0) { }

ConstantVariableImpl::ConstantVariableImpl(double c) 
  : m_const(c) { };
  
ConstantVariableImpl::ConstantVariableImpl(const ConstantVariableImpl& c) 
  : RandomVariableBase(c), m_const(c.m_const) { }

void ConstantVariableImpl::NewConstant(double c) 
  { m_const = c;}
  
double ConstantVariableImpl::GetValue()
{
  return m_const;
}

uint32_t ConstantVariableImpl::GetIntValue()
{
  return (uint32_t)m_const;
}

RandomVariableBase* ConstantVariableImpl::Copy() const
{
  return new ConstantVariableImpl(*this);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// SequentialVariable methods
SequentialVariable::SequentialVariable(double f, double l, double i, uint32_t c)
  : m_min(f), m_max(l), m_increment(ConstantVariable(i).Copy()), m_consecutive(c),
    m_current(f), m_currentConsecutive(0)
{
}

ConstantVariable::ConstantVariable()
  : RandomVariable (ConstantVariableImpl ())
{}
ConstantVariable::ConstantVariable(double c)
  : RandomVariable (ConstantVariableImpl (c))
{}
void 
ConstantVariable::SetConstant(double c)
{
  *this = ConstantVariable (c);
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// SequentialVariableImpl methods


class SequentialVariableImpl : public RandomVariableBase {

public:
  /**
   * \brief Constructor for the SequentialVariableImpl RNG.
   *
   * The four parameters define the sequence.  For example
   * SequentialVariableImpl(0,5,1,2) creates a RNG that has the sequence
   * 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 0, 0 ...
   * \param f First value of the sequence.
   * \param l One more than the last value of the sequence.
   * \param i Increment between sequence values
   * \param c Number of times each member of the sequence is repeated
   */
  SequentialVariableImpl(double f, double l, double i = 1, uint32_t c = 1);

  /**
   * \brief Constructor for the SequentialVariableImpl RNG.
   *
   * Differs from the first only in that the increment parameter is a
   * random variable
   * \param f First value of the sequence.
   * \param l One more than the last value of the sequence.
   * \param i Reference to a RandomVariableBase for the sequence increment
   * \param c Number of times each member of the sequence is repeated
   */
  SequentialVariableImpl(double f, double l, const RandomVariable& i, uint32_t c = 1);

  SequentialVariableImpl(const SequentialVariableImpl& c);
  
  ~SequentialVariableImpl();
  /**
   * \return The next value in the Sequence
   */
  virtual double GetValue();
  virtual RandomVariableBase*  Copy(void) const;
private:
  double m_min;
  double m_max;
  RandomVariable  m_increment;
  uint32_t  m_consecutive;
  double m_current;
  uint32_t  m_currentConsecutive;
};

SequentialVariableImpl::SequentialVariableImpl(double f, double l, double i, uint32_t c)
  : m_min(f), m_max(l), m_increment(ConstantVariable(i)), m_consecutive(c),
    m_current(f), m_currentConsecutive(0)
{}

SequentialVariableImpl::SequentialVariableImpl(double f, double l, const RandomVariable& i, uint32_t c)
  : m_min(f), m_max(l), m_increment(i), m_consecutive(c),
    m_current(f), m_currentConsecutive(0)
{}

SequentialVariableImpl::SequentialVariableImpl(const SequentialVariableImpl& c)
  : RandomVariableBase(c), m_min(c.m_min), m_max(c.m_max),
    m_increment(c.m_increment), m_consecutive(c.m_consecutive),
    m_current(c.m_current), m_currentConsecutive(c.m_currentConsecutive)
{}
}

SequentialVariableImpl::~SequentialVariableImpl()
{}
  delete m_increment;
}

double SequentialVariableImpl::GetValue()
{ // Return a sequential series of values
  double r = m_current;
  if (++m_currentConsecutive == m_consecutive)
    { // Time to advance to next
      m_currentConsecutive = 0;
      m_current += m_increment.GetValue();
      if (m_current >= m_max)
        m_current = m_min + (m_current - m_max);
    }
  return r;
}

RandomVariableBase* SequentialVariableImpl::Copy() const
{
  return new SequentialVariableImpl(*this);
}

SequentialVariable::SequentialVariable(double f, double l, double i, uint32_t c)
  : RandomVariable (SequentialVariableImpl (f, l, i, c))
{}
SequentialVariable::SequentialVariable(double f, double l, const RandomVariable& i, uint32_t c)
  : RandomVariable (SequentialVariableImpl (f, l, i, c))
{}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// ExponentialVariableImpl methods

class ExponentialVariableImpl : public RandomVariableBase { 
public:
  /**
   * Constructs an exponential random variable  with a mean
   * value of 1.0.
   */
  ExponentialVariableImpl();

  /**
   * \brief Constructs an exponential random variable with a specified mean
   * \param m Mean value for the random variable
   */
  explicit ExponentialVariableImpl(double m);

  /**
   * \brief Constructs an exponential random variable with spefified
   * \brief mean and upper limit.
   *
   * Since exponential distributions can theoretically return unbounded values,
   * it is sometimes useful to specify a fixed upper limit.  Note however when
   * the upper limit is specified, the true mean of the distribution is 
   * slightly smaller than the mean value specified.
   * \param m Mean value of the random variable
   * \param b Upper bound on returned values
   */
  ExponentialVariableImpl(double m, double b);

  ExponentialVariableImpl(const ExponentialVariableImpl& c);
  
  /**
   * \return A random value from this exponential distribution
   */
  virtual double GetValue();
  virtual RandomVariableBase* Copy(void) const;
public:
  /**
   * \param m The mean of the distribution from which the return value is drawn
   * \param b The upper bound value desired, beyond which values get clipped
   * \return A random number from an exponential distribution with mean m
   */
  static double GetSingleValue(double m, double b=0);
private:
  double m_mean;  // Mean value of RV
  double m_bound; // Upper bound on value (if non-zero)
};

ExponentialVariableImpl::ExponentialVariableImpl() 
  : m_mean(1.0), m_bound(0) { }
  
ExponentialVariableImpl::ExponentialVariableImpl(double m) 
  : m_mean(m), m_bound(0) { }
  
ExponentialVariableImpl::ExponentialVariableImpl(double m, double b) 
  : m_mean(m), m_bound(b) { }
  
ExponentialVariableImpl::ExponentialVariableImpl(const ExponentialVariableImpl& c) 
  : RandomVariableBase(c), m_mean(c.m_mean), m_bound(c.m_bound) { }

double ExponentialVariableImpl::GetValue()
{
  if(!RandomVariableBase::initialized)
  {
    RandomVariableBase::Initialize();
  }
  if(!m_generator)
  {
    m_generator = new RngStream();
    m_generator->InitializeStream();
    m_generator->ResetNthSubstream(RandomVariableBase::runNumber);
  }
  double r = -m_mean*log(m_generator->RandU01());
  if (m_bound != 0 && r > m_bound) return m_bound;
  return r;
}

RandomVariableBase* ExponentialVariableImpl::Copy() const
{
  return new ExponentialVariableImpl(*this);
}
double ExponentialVariableImpl::GetSingleValue(double m, double b/*=0*/)
{
  if(!RandomVariableBase::m_static_generator)
  {
    RandomVariableBase::Initialize(); // sets the static package seed
    RandomVariableBase::m_static_generator = new RngStream();
    RandomVariableBase::m_static_generator->InitializeStream();
  }
  double r = -m*log(m_static_generator->RandU01());
  if (b != 0 && r > b) return b;
  return r;
}

ExponentialVariable::ExponentialVariable()
  : RandomVariable (ExponentialVariableImpl ())
{}
ExponentialVariable::ExponentialVariable(double m)
  : RandomVariable (ExponentialVariableImpl (m))
{}
ExponentialVariable::ExponentialVariable(double m, double b)
  : RandomVariable (ExponentialVariableImpl (m, b))
{}
double 
ExponentialVariable::GetSingleValue(double m, double b)
{
  return ExponentialVariableImpl::GetSingleValue (m, b);
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// ParetoVariableImpl methods
class ParetoVariableImpl : public RandomVariableBase {
public:
  /**
   * Constructs a pareto random variable with a mean of 1 and a shape
   * parameter of 1.5
   */
  ParetoVariableImpl();

  /**
   * Constructs a pareto random variable with specified mean and shape
   * parameter of 1.5
   * \param m Mean value of the distribution
   */
  explicit ParetoVariableImpl(double m);

  /**
   * Constructs a pareto random variable with the specified mean value and
   * shape parameter.
   * \param m Mean value of the distribution
   * \param s Shape parameter for the distribution
   */
  ParetoVariableImpl(double m, double s);

  /**
   * \brief Constructs a pareto random variable with the specified mean
   * \brief value, shape (alpha), and upper bound.
   *
   * Since pareto distributions can theoretically return unbounded values,
   * it is sometimes useful to specify a fixed upper limit.  Note however
   * when the upper limit is specified, the true mean of the distribution
   * is slightly smaller than the mean value specified.
   * \param m Mean value
   * \param s Shape parameter
   * \param b Upper limit on returned values
   */
  ParetoVariableImpl(double m, double s, double b);

  ParetoVariableImpl(const ParetoVariableImpl& c);
  
  /**
   * \return A random value from this Pareto distribution
   */
  virtual double GetValue();
  virtual RandomVariableBase* Copy() const;
public:
  /**
   * \param m The mean value of the distribution from which the return value
   * is drawn.
   * \param s The shape parameter of the distribution from which the return
   * value is drawn.
   * \param b The upper bound to which to restrict return values
   * \return A random number from a Pareto distribution with mean m and shape
   * parameter s.
   */
  static double GetSingleValue(double m, double s, double b=0);
private:
  double m_mean;  // Mean value of RV
  double m_shape; // Shape parameter
  double m_bound; // Upper bound on value (if non-zero)
};

ParetoVariableImpl::ParetoVariableImpl() 
  : m_mean(1.0), m_shape(1.5), m_bound(0) { }

ParetoVariableImpl::ParetoVariableImpl(double m) 
  : m_mean(m), m_shape(1.5), m_bound(0) { }

ParetoVariableImpl::ParetoVariableImpl(double m, double s) 
    : m_mean(m), m_shape(s), m_bound(0) { }

ParetoVariableImpl::ParetoVariableImpl(double m, double s, double b) 
  : m_mean(m), m_shape(s), m_bound(b) { }

ParetoVariableImpl::ParetoVariableImpl(const ParetoVariableImpl& c) 
  : RandomVariableBase(c), m_mean(c.m_mean), m_shape(c.m_shape), 
    m_bound(c.m_bound) { }

double ParetoVariableImpl::GetValue()
{
  if(!RandomVariableBase::initialized)
  {
    RandomVariableBase::Initialize();
  }
  if(!m_generator)
  {
    m_generator = new RngStream();
    m_generator->InitializeStream();
    m_generator->ResetNthSubstream(RandomVariableBase::runNumber);
  }
  double scale = m_mean * ( m_shape - 1.0) / m_shape;
  double r = (scale * ( 1.0 / pow(m_generator->RandU01(), 1.0 / m_shape)));

  return r;
}

RandomVariableBase* ParetoVariableImpl::Copy() const
{
  return new ParetoVariableImpl(*this);
}

double ParetoVariableImpl::GetSingleValue(double m, double s, double b/*=0*/)
{
  if(!RandomVariableBase::m_static_generator)
  {
    RandomVariableBase::Initialize(); // sets the static package seed
    RandomVariableBase::m_static_generator = new RngStream();
    RandomVariableBase::m_static_generator->InitializeStream();
  }
  double scale = m * ( s - 1.0) / s;
  double r = (scale * ( 1.0 / pow(m_static_generator->RandU01(), 1.0 / s)));
  if (b != 0 && r > b) return b;
  return r;
}

ParetoVariable::ParetoVariable ()
  : RandomVariable (ParetoVariableImpl ())
{}
ParetoVariable::ParetoVariable(double m)
  : RandomVariable (ParetoVariableImpl (m))
{}
ParetoVariable::ParetoVariable(double m, double s)
  : RandomVariable (ParetoVariableImpl (m, s))
{}
ParetoVariable::ParetoVariable(double m, double s, double b)
  : RandomVariable (ParetoVariableImpl (m, s, b))
{}
double 
ParetoVariable::GetSingleValue(double m, double s, double b)
{
  return ParetoVariableImpl::GetSingleValue (m, s, b);
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// WeibullVariableImpl methods

class WeibullVariableImpl : public RandomVariableBase {
public:
  /**
   * Constructs a weibull random variable  with a mean
   * value of 1.0 and a shape (alpha) parameter of 1
   */
  WeibullVariableImpl();


  /**
   * Constructs a weibull random variable with the specified mean
   * value and a shape (alpha) parameter of 1.5.
   * \param m mean value of the distribution
   */
   WeibullVariableImpl(double m) ;

  /**
   * Constructs a weibull random variable with the specified mean
   * value and a shape (alpha).
   * \param m Mean value for the distribution.
   * \param s Shape (alpha) parameter for the distribution.
   */
  WeibullVariableImpl(double m, double s);

   /**
   * \brief Constructs a weibull random variable with the specified mean
   * \brief value, shape (alpha), and upper bound.
   * Since WeibullVariableImpl distributions can theoretically return unbounded values,
   * it is sometimes usefull to specify a fixed upper limit.  Note however
   * that when the upper limit is specified, the true mean of the distribution
   * is slightly smaller than the mean value specified.
   * \param m Mean value for the distribution.
   * \param s Shape (alpha) parameter for the distribution.
   * \param b Upper limit on returned values
   */
  WeibullVariableImpl(double m, double s, double b);

  WeibullVariableImpl(const WeibullVariableImpl& c);
  
  /**
   * \return A random value from this Weibull distribution
   */
  virtual double GetValue();
  virtual RandomVariableBase* Copy(void) const;
public:
  /**
   * \param m Mean value for the distribution.
   * \param s Shape (alpha) parameter for the distribution.
   * \param b Upper limit on returned values
   * \return Random number from a distribution specified by m,s, and b
   */
  static double GetSingleValue(double m, double s, double b=0);
private:
  double m_mean;  // Mean value of RV
  double m_alpha; // Shape parameter
  double m_bound; // Upper bound on value (if non-zero)
};

WeibullVariableImpl::WeibullVariableImpl() : m_mean(1.0), m_alpha(1), m_bound(0) { }
WeibullVariableImpl::WeibullVariableImpl(double m) 
  : m_mean(m), m_alpha(1), m_bound(0) { }
WeibullVariableImpl::WeibullVariableImpl(double m, double s) 
  : m_mean(m), m_alpha(s), m_bound(0) { }
WeibullVariableImpl::WeibullVariableImpl(double m, double s, double b) 
  : m_mean(m), m_alpha(s), m_bound(b) { };
WeibullVariableImpl::WeibullVariableImpl(const WeibullVariableImpl& c) 
  : RandomVariableBase(c), m_mean(c.m_mean), m_alpha(c.m_alpha),
    m_bound(c.m_bound) { }

double WeibullVariableImpl::GetValue()
{
  if(!RandomVariableBase::initialized)
  {
    RandomVariableBase::Initialize();
  }
  if(!m_generator)
  {
    m_generator = new RngStream();
    m_generator->InitializeStream();
    m_generator->ResetNthSubstream(RandomVariableBase::runNumber);
  }
  double exponent = 1.0 / m_alpha;
  double r = m_mean * pow( -log(m_generator->RandU01()), exponent);

  return r;
}

RandomVariableBase* WeibullVariableImpl::Copy() const
{
  return new WeibullVariableImpl(*this);
}

double WeibullVariableImpl::GetSingleValue(double m, double s, double b/*=0*/)
{
  if(!RandomVariableBase::m_static_generator)
  {
    RandomVariableBase::Initialize(); // sets the static package seed
    RandomVariableBase::m_static_generator = new RngStream();
    RandomVariableBase::m_static_generator->InitializeStream();
  }
  double exponent = 1.0 / s;
  double r = m * pow( -log(m_static_generator->RandU01()), exponent);
  if (b != 0 && r > b) return b;
  return r;
}

WeibullVariable::WeibullVariable()
  : RandomVariable (WeibullVariableImpl ())
{}
WeibullVariable::WeibullVariable(double m)
  : RandomVariable (WeibullVariableImpl (m))
{}
WeibullVariable::WeibullVariable(double m, double s)
  : RandomVariable (WeibullVariableImpl (m, s))
{}
WeibullVariable::WeibullVariable(double m, double s, double b)
  : RandomVariable (WeibullVariableImpl (m, s, b))
{}
double 
WeibullVariable::GetSingleValue(double m, double s, double b)
{
  return WeibullVariableImpl::GetSingleValue (m, s, b);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// NormalVariableImpl methods
bool         NormalVariable::m_static_nextValid = false;
double       NormalVariable::m_static_next;
const double NormalVariable::INFINITE_VALUE = 1e307;

class NormalVariableImpl : public RandomVariableBase { // Normally Distributed random var

public:
   static const double INFINITE_VALUE;
  /**
   * Constructs an normal random variable  with a mean
   * value of 0 and variance of 1.
   */ 
  NormalVariableImpl();

  /**
   * \brief Construct a normal random variable with specified mean and variance
   * \param m Mean value
   * \param v Variance
   * \param b Bound.  The NormalVariableImpl is bounded within +-bound.
   */ 
  NormalVariableImpl(double m, double v, double b = INFINITE_VALUE);

  NormalVariableImpl(const NormalVariableImpl& c);
  
  /**
   * \return A value from this normal distribution
   */
  virtual double GetValue();
  virtual RandomVariableBase* Copy(void) const;
public:
  /**
   * \param m Mean value
   * \param v Variance
   * \param b Bound.  The NormalVariableImpl is bounded within +-bound.
   * \return A random number from a distribution specified by m,v, and b.
   */ 
  static double GetSingleValue(double m, double v, double b = INFINITE_VALUE);
private:
  double m_mean;      // Mean value of RV
  double m_variance;  // Mean value of RV
  double m_bound;     // Bound on value (absolute value)
  bool   m_nextValid; // True if next valid
  double m_next;      // The algorithm produces two values at a time
  static bool   m_static_nextValid;
  static double m_static_next;
};

bool         NormalVariableImpl::m_static_nextValid = false;
double       NormalVariableImpl::m_static_next;
const double NormalVariableImpl::INFINITE_VALUE = 1e307;

NormalVariableImpl::NormalVariableImpl() 
  : m_mean(0.0), m_variance(1.0), m_bound(INFINITE_VALUE), m_nextValid(false){}

NormalVariableImpl::NormalVariableImpl(double m, double v, double b/*=INFINITE_VALUE*/)
  : m_mean(m), m_variance(v), m_bound(b), m_nextValid(false) { }

NormalVariableImpl::NormalVariableImpl(const NormalVariableImpl& c)
  : RandomVariableBase(c), m_mean(c.m_mean), m_variance(c.m_variance),
    m_bound(c.m_bound) { }

double NormalVariableImpl::GetValue()
{
  if(!RandomVariableBase::initialized)
  {
    RandomVariableBase::Initialize();
  }
  if(!m_generator)
  {
    m_generator = new RngStream();
    m_generator->InitializeStream();
    m_generator->ResetNthSubstream(RandomVariableBase::runNumber);
  }
  if (m_nextValid)
    { // use previously generated

    }
}

RandomVariableBase* NormalVariableImpl::Copy() const
{
  return new NormalVariableImpl(*this);
}

double NormalVariableImpl::GetSingleValue(double m, double v, double b)
{
  if(!RandomVariableBase::m_static_generator)
  {
    RandomVariableBase::Initialize(); // sets the static package seed
    RandomVariableBase::m_static_generator = new RngStream();
    RandomVariableBase::m_static_generator->InitializeStream();
  }
  if (m_static_nextValid)
    { // use previously generated

    }
}

NormalVariable::NormalVariable()
  : RandomVariable (NormalVariableImpl ())
{}
NormalVariable::NormalVariable(double m, double v, double b)
  : RandomVariable (NormalVariableImpl (m, v, b))
{}
double 
NormalVariable::GetSingleValue(double m, double v, double b)
{
  return NormalVariableImpl::GetSingleValue (m, v, b);
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class EmpiricalVariableImpl : public RandomVariableBase {
public:
  /**
   * Constructor for the EmpiricalVariableImpl random variables.
   */
  explicit EmpiricalVariableImpl();

  virtual ~EmpiricalVariableImpl();
  EmpiricalVariableImpl(const EmpiricalVariableImpl& c);
  /**
   * \return A value from this empirical distribution
   */
  virtual double GetValue();
  virtual RandomVariableBase* Copy(void) const;
  /**
   * \brief Specifies a point in the empirical distribution
   * \param v The function value for this point
   * \param c Probability that the function is less than or equal to v
   */
  virtual void CDF(double v, double c);  // Value, prob <= Value

private:
  class ValueCDF {
  public:
    ValueCDF();
    ValueCDF(double v, double c);
    ValueCDF(const ValueCDF& c);
    double value;
    double    cdf;
  };
  virtual void Validate();  // Insure non-decreasing emiprical values
  virtual double Interpolate(double, double, double, double, double);
  bool validated; // True if non-decreasing validated
  std::vector<ValueCDF> emp;       // Empicical CDF
};


// ValueCDF methods
EmpiricalVariableImpl::ValueCDF::ValueCDF() 
  : value(0.0), cdf(0.0){ }
EmpiricalVariableImpl::ValueCDF::ValueCDF(double v, double c) 
  : value(v), cdf(c) { }
EmpiricalVariableImpl::ValueCDF::ValueCDF(const ValueCDF& c) 
  : value(c.value), cdf(c.cdf) { }

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// EmpiricalVariableImpl methods
EmpiricalVariableImpl::EmpiricalVariableImpl() 
  : validated(false) { }

EmpiricalVariableImpl::EmpiricalVariableImpl(const EmpiricalVariableImpl& c)
  : RandomVariableBase(c), validated(c.validated), emp(c.emp) { }

EmpiricalVariableImpl::~EmpiricalVariableImpl() { }

double EmpiricalVariableImpl::GetValue()
{ // Return a value from the empirical distribution
  // This code based (loosely) on code by Bruce Mah (Thanks Bruce!)
  if(!RandomVariableBase::initialized)
  {
    RandomVariableBase::Initialize();
  }
  if(!m_generator)
  {
    m_generator = new RngStream();
    m_generator->InitializeStream();
    m_generator->ResetNthSubstream(RandomVariableBase::runNumber);
  }
  if (emp.size() == 0) return 0.0; // HuH? No empirical data
  if (!validated) Validate();      // Insure in non-decreasing

    }
}

RandomVariableBase* EmpiricalVariableImpl::Copy() const
{
  return new EmpiricalVariableImpl(*this);
}

void EmpiricalVariableImpl::CDF(double v, double c)
{ // Add a new empirical datapoint to the empirical cdf
  // NOTE.   These MUST be inserted in non-decreasing order
  emp.push_back(ValueCDF(v, c));
}

void EmpiricalVariableImpl::Validate()
{
  ValueCDF prior;
  for (std::vector<ValueCDF>::size_type i = 0; i < emp.size(); ++i)

  validated = true;
}

double EmpiricalVariableImpl::Interpolate(double c1, double c2,
                                double v1, double v2, double r)
{ // Interpolate random value in range [v1..v2) based on [c1 .. r .. c2)
  return (v1 + ((v2 - v1) / (c2 - c1)) * (r - c1));
}

EmpiricalVariable::EmpiricalVariable()
  : RandomVariable (EmpiricalVariableImpl ())
{}
EmpiricalVariable::EmpiricalVariable (const RandomVariableBase &variable)
  : RandomVariable (variable)
{}
void 
EmpiricalVariable::CDF(double v, double c)
{
  EmpiricalVariableImpl *impl = dynamic_cast<EmpiricalVariableImpl *> (Peek ());
  NS_ASSERT (impl);
  impl->CDF (v, c);
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Integer EmpiricalVariableImpl methods
class IntEmpiricalVariableImpl : public EmpiricalVariableImpl {
public:

  IntEmpiricalVariableImpl();
  
  virtual RandomVariableBase* Copy(void) const;
  /**
   * \return An integer value from this empirical distribution
   */
  virtual uint32_t GetIntValue();
private:
  virtual double Interpolate(double, double, double, double, double);
};


IntEmpiricalVariableImpl::IntEmpiricalVariableImpl() { }

uint32_t IntEmpiricalVariableImpl::GetIntValue()
{
  return (uint32_t)GetValue();
}

RandomVariableBase* IntEmpiricalVariableImpl::Copy() const
{
  return new IntEmpiricalVariableImpl(*this);
}

double IntEmpiricalVariableImpl::Interpolate(double c1, double c2,
                                   double v1, double v2, double r)
{ // Interpolate random value in range [v1..v2) based on [c1 .. r .. c2)
  return ceil(v1 + ((v2 - v1) / (c2 - c1)) * (r - c1));
}

IntEmpiricalVariable::IntEmpiricalVariable()
  : EmpiricalVariable (IntEmpiricalVariableImpl ())
{}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// DeterministicVariableImpl
class DeterministicVariableImpl : public RandomVariableBase 
{

public:
  /**
   * \brief Constructor
   *
   * Creates a generator that returns successive elements of the d array
   * on successive calls to ::Value().  Note that the d pointer is copied
   * for use by the generator (shallow-copy), not its contents, so the 
   * contents of the array d points to have to remain unchanged for the use 
   * of DeterministicVariableImpl to be meaningful.
   * \param d Pointer to array of random values to return in sequence
   * \param c Number of values in the array
   */
  explicit DeterministicVariableImpl(double* d, uint32_t c);

  virtual ~DeterministicVariableImpl();
  /**
   * \return The next value in the deterministic sequence
   */
  virtual double GetValue();
  virtual RandomVariableBase* Copy(void) const;
private:
  uint32_t   count;
  uint32_t   next;
  double* data;
};

DeterministicVariableImpl::DeterministicVariableImpl(double* d, uint32_t c)
    : count(c), next(c), data(d)
{ // Nothing else needed
}

DeterministicVariableImpl::~DeterministicVariableImpl() { }
  
double DeterministicVariableImpl::GetValue()
{
  if (next == count) next = 0;
  return data[next++];
}

RandomVariableBase* DeterministicVariableImpl::Copy() const
{
  return new DeterministicVariableImpl(*this);
}

DeterministicVariable::DeterministicVariable(double* d, uint32_t c)
  : RandomVariable (DeterministicVariableImpl (d, c))
{}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// LogNormalVariableImpl
class LogNormalVariableImpl : public RandomVariableBase { 
public:
  /**
   * \param mu mu parameter of the lognormal distribution
   * \param sigma sigma parameter of the lognormal distribution
   */
  LogNormalVariableImpl (double mu, double sigma);

  /**
   * \return A random value from this distribution
   */
  virtual double GetValue ();
  virtual RandomVariableBase* Copy(void) const;
public:
  /**
   * \param mu mu parameter of the underlying normal distribution
   * \param sigma sigma parameter of the underlying normal distribution
   * \return A random number from the distribution specified by mu and sigma
   */
  static double GetSingleValue(double mu, double sigma);
private:
  double m_mu;
  double m_sigma;
};


RandomVariableBase* LogNormalVariableImpl::Copy () const
{
  return new LogNormalVariableImpl (m_mu, m_sigma);
}

LogNormalVariableImpl::LogNormalVariableImpl (double mu, double sigma)
    :m_mu(mu), m_sigma(sigma) 
{
}

   for x > 0. Lognormal random numbers are the exponentials of
   gaussian random numbers */
double
LogNormalVariableImpl::GetValue ()
{
  if(!RandomVariableBase::initialized)
  {
    RandomVariableBase::Initialize();
  }
  if(!m_generator)
  {
    m_generator = new RngStream();
    m_generator->InitializeStream();
    m_generator->ResetNthSubstream(RandomVariableBase::runNumber);
  }
  double u, v, r2, normal, z;


  return z;
}

double LogNormalVariableImpl::GetSingleValue (double mu, double sigma)
{
  if(!RandomVariableBase::m_static_generator)
  {
    RandomVariableBase::Initialize(); // sets the static package seed
    RandomVariableBase::m_static_generator = new RngStream();
    RandomVariableBase::m_static_generator->InitializeStream();
  }
  double u, v, r2, normal, z;
  do

  return z;
}

LogNormalVariable::LogNormalVariable (double mu, double sigma)
  : RandomVariable (LogNormalVariableImpl (mu, sigma))
{}
double 
LogNormalVariable::GetSingleValue(double mu, double sigma)
{
  return LogNormalVariableImpl::GetSingleValue (mu, sigma);
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// TriangularVariableImpl methods
class TriangularVariableImpl : public RandomVariableBase {
public:
  /**
   * Creates a triangle distribution random number generator in the
   * range [0.0 .. 1.0), with mean of 0.5
   */
  TriangularVariableImpl();

  /**
   * Creates a triangle distribution random number generator with the specified
   * range
   * \param s Low end of the range
   * \param l High end of the range
   * \param mean mean of the distribution
   */
  TriangularVariableImpl(double s, double l, double mean);

  TriangularVariableImpl(const TriangularVariableImpl& c);
  
  /**
   * \return A value from this distribution
   */
  virtual double GetValue();
  virtual RandomVariableBase*  Copy(void) const;
public:
  /**
   * \param s Low end of the range
   * \param l High end of the range
   * \param mean mean of the distribution
   * \return A triangularly distributed random number between s and l
   */
  static double GetSingleValue(double s, double l, double mean);
private:
  double m_min;
  double m_max;
  double m_mode;  //easier to work with the mode internally instead of the mean
                  //they are related by the simple: mean = (min+max+mode)/3
};

TriangularVariableImpl::TriangularVariableImpl() 
  : m_min(0), m_max(1), m_mode(0.5) { }
  
TriangularVariableImpl::TriangularVariableImpl(double s, double l, double mean) 
  : m_min(s), m_max(l), m_mode(3.0*mean-s-l) { }
  
TriangularVariableImpl::TriangularVariableImpl(const TriangularVariableImpl& c) 
  : RandomVariableBase(c), m_min(c.m_min), m_max(c.m_max), m_mode(c.m_mode) { }

double TriangularVariableImpl::GetValue()
{
  if(!RandomVariableBase::initialized)
  {
    RandomVariableBase::Initialize();
  }
  if(!m_generator)
  {
    m_generator = new RngStream();
    m_generator->InitializeStream();
    m_generator->ResetNthSubstream(RandomVariableBase::runNumber);
  }
  double u = m_generator->RandU01();
  if(u <= (m_mode - m_min) / (m_max - m_min) )

    return m_max - sqrt( (1-u) * (m_max - m_min) * (m_max - m_mode) );
}

RandomVariableBase* TriangularVariableImpl::Copy() const
{
  return new TriangularVariableImpl(*this);
}

double TriangularVariableImpl::GetSingleValue(double s, double l, double mean)
{
  if(!RandomVariableBase::m_static_generator)
  {
    RandomVariableBase::Initialize(); // sets the static package seed
    RandomVariableBase::m_static_generator = new RngStream();
    RandomVariableBase::m_static_generator->InitializeStream();
  }
  double mode = 3.0*mean-s-l;
  double u = m_static_generator->RandU01();

  else
    return l - sqrt( (1-u) * (l - s) * (l - mode) );
}

TriangularVariable::TriangularVariable()
  : RandomVariable (TriangularVariableImpl ())
{}
TriangularVariable::TriangularVariable(double s, double l, double mean)
  : RandomVariable (TriangularVariableImpl (s,l,mean))
{}
double 
TriangularVariable::GetSingleValue(double s, double l, double mean)
{
  return TriangularVariableImpl::GetSingleValue (s,l,mean);
}



}//namespace ns3





namespace ns3{

class RandomVariableBase;

/**
 * \brief The basic RNG for NS-3.

 * the University of Montreal.
 * 
 * NS-3 has a rich set of  random number generators.
 * Class RandomVariableBase defines the base class functionalty
 * required for all random number generators.  By default, the underlying
 * generator is seeded with the time of day, and then deterministically
 * creates a sequence of seeds for each subsequent generator that is created.
 * The rest of the documentation outlines how to change this behavior.
 */
class RandomVariable
{ 
public:
  /**
   * \brief Constructor for a random number generator with a random seed.
   */
  RandomVariable();
  RandomVariable(const RandomVariable&o);
  RandomVariable &operator = (const RandomVariable &o);
  ~RandomVariable();
   */  
  RandomVariable(const RandomVariable&);
  
  /**
   * \brief Destructor for a random number generator with a random seed.
   */
  virtual ~RandomVariable();
  
  /**
   * \brief Returns a random double from the underlying distribution
   * \return A floating point random value
   */
  double GetValue (void) const;

  /**
   * \brief Returns a random integer integer from the underlying distribution
   * \return  Integer cast of ::GetValue()
   */
  uint32_t GetIntValue (void) const;

  /**
   * \return A copy of this object
   */  
  virtual RandomVariable*   Copy() const = 0;
  
  /**
   * \brief Get the internal state of the RNG

   * \param seed Output parameter; gets overwritten with the internal state of
   * of the RNG.
   */
  void GetSeed(uint32_t seed[6]) const;
  
  /**
   * \brief Set seeding behavior

   * generator is seeded with data from /dev/random instead of
   * being seeded based upon the time of day.  For this to be effective,
   * it must be called before the creation of the first instance of a 
   * RandomVariableBase or subclass.  Example:
   * \code
   * RandomVariable::UseDevRandom();
   * UniformVariable x(2,3);  //these are seeded randomly

   */
  static void SetRunNumber(uint32_t n);
private:
  RandomVariableBase *m_variable;
private:
  static bool useDevRandom;    // True if using /dev/random desired
  static bool globalSeedSet;   // True if global seed has been specified
  static int  devRandom;       // File handle for /dev/random
  static uint32_t globalSeed[6]; // The global seed to use
  friend class RandomVariableInitializer;
protected:
  RandomVariable (const RandomVariableBase &variable);
  RandomVariableBase *Peek (void);
  static uint32_t runNumber;
  static void Initialize();    // Initialize  the RNG system
  static bool initialized;     // True if package seed is set 
  RngStream* m_generator;  //underlying generator being wrapped
};


/**
 * \brief The uniform distribution RNG for NS-3.

 * UniformVariable::GetSingleValue(100,1000); //returns a value [100,1000)
 * \endcode
 */
class UniformVariable : public RandomVariable 
{
public:
  /**
   * Creates a uniform random number generator in the

   * \param l High end of the range
   */
  UniformVariable(double s, double l);

  UniformVariable(const UniformVariable& c);
  
  /**
   * \return A value between low and high values specified by the constructor
   */
  virtual double GetValue();
  virtual RandomVariable*  Copy() const;
public:
  /**
   * \param s Low end of the range

   * \return A uniformly distributed random number between s and l
   */
  static double GetSingleValue(double s, double l);
private:
  double m_min;
  double m_max;
};

/**
 * \brief A random variable that returns a constant
 * \ingroup randomvariable
 *
 * Class ConstantVariableImpl defines a random number generator that
 * returns the same value every sample.
 */
class ConstantVariable : public RandomVariable { 

public:
  /**
   * Construct a ConstantVariableImpl RNG that returns zero every sample
   */
  ConstantVariable();
  
  /**
   * Construct a ConstantVariableImpl RNG that returns the specified value
   * every sample.
   * \param c Unchanging value for this RNG.
   */
  ConstantVariable(double c);


  ConstantVariable(const ConstantVariable& c) ;

  /**
   * \brief Specify a new constant RNG for this generator.
   * \param c New constant value for this RNG.
   */
  void SetConstant(double c);

  /**
   * \return The constant value specified
   */
  virtual double  GetValue();
  virtual uint32_t GetIntValue();
  virtual RandomVariable*   Copy() const;
private:
  double m_const;
};

/**

 * increases for a period, then wraps around to the low value 
 * and begins monotonicaly increasing again.
 */
class SequentialVariable : public RandomVariable 
{
public:
  /**
   * \brief Constructor for the SequentialVariableImpl RNG.
   *
   * The four parameters define the sequence.  For example
   * SequentialVariableImpl(0,5,1,2) creates a RNG that has the sequence
   * 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 0, 0 ...
   * \param f First value of the sequence.
   * \param l One more than the last value of the sequence.

  SequentialVariable(double f, double l, double i = 1, uint32_t c = 1);

  /**
   * \brief Constructor for the SequentialVariableImpl RNG.
   *
   * Differs from the first only in that the increment parameter is a
   * random variable
   * \param f First value of the sequence.
   * \param l One more than the last value of the sequence.
   * \param i Reference to a RandomVariableBase for the sequence increment
   * \param c Number of times each member of the sequence is repeated
   */
  SequentialVariable(double f, double l, const RandomVariable& i, uint32_t c = 1);

  SequentialVariable(const SequentialVariable& c);
  
  ~SequentialVariable();
  /**
   * \return The next value in the Sequence
   */
  virtual double GetValue();
  virtual RandomVariable*  Copy() const;
private:
  double m_min;
  double m_max;
  RandomVariable*  m_increment;
  uint32_t  m_consecutive;
  double m_current;
  uint32_t  m_currentConsecutive;
};

/**

 * \f$ \left\{ \begin{array}{cl} \alpha  e^{-\alpha x} & x < bound \\ bound & x > bound \end{array}\right. \f$
 * 
 * \code
 * ExponentialVariableImpl x(3.14);
 * x.GetValue();  //will always return with mean 3.14
 * ExponentialVariableImpl::GetSingleValue(20.1); //returns with mean 20.1
 * ExponentialVariableImpl::GetSingleValue(108); //returns with mean 108
 * \endcode
 *
 */
class ExponentialVariable : public RandomVariable 
{ 
public:
  /**
   * Constructs an exponential random variable  with a mean

   */
  ExponentialVariable(double m, double b);

  ExponentialVariable(const ExponentialVariable& c);
  
  /**
   * \return A random value from this exponential distribution
   */
  virtual double GetValue();
  virtual RandomVariable* Copy() const;
public:
  /**
   * \param m The mean of the distribution from which the return value is drawn
   * \param b The upper bound value desired, beyond which values get clipped
   * \return A random number from an exponential distribution with mean m
   */
  static double GetSingleValue(double m, double b=0);
private:
  double m_mean;  // Mean value of RV
  double m_bound; // Upper bound on value (if non-zero)
};

/**
 * \brief ParetoVariableImpl distributed random var
 * \ingroup randomvariable
 *
 * This class supports the creation of objects that return random numbers

 * with the equation \f$ x_m = mean \frac{k-1}{k},  k > 1\f$.
 *
 * \code
 * ParetoVariableImpl x(3.14);
 * x.GetValue();  //will always return with mean 3.14
 * ParetoVariableImpl::GetSingleValue(20.1); //returns with mean 20.1
 * ParetoVariableImpl::GetSingleValue(108); //returns with mean 108
 * \endcode
 */
class ParetoVariable : public RandomVariable
{
public:
  /**
   * Constructs a pareto random variable with a mean of 1 and a shape
   * parameter of 1.5
   */
  ParetoVariable ();

  /**
   * Constructs a pareto random variable with specified mean and shape

   */
  ParetoVariable(double m, double s, double b);

  ParetoVariable(const ParetoVariable& c);
  
  /**
   * \return A random value from this Pareto distribution
   */
  virtual double GetValue();
  virtual RandomVariable* Copy() const;
public:
  /**
   * \param m The mean value of the distribution from which the return value
   * is drawn.

   * parameter s.
   */
  static double GetSingleValue(double m, double s, double b=0);
private:
  double m_mean;  // Mean value of RV
  double m_shape; // Shape parameter
  double m_bound; // Upper bound on value (if non-zero)
};

/**
 * \brief WeibullVariableImpl distributed random var
 * \ingroup randomvariable
 *
 * This class supports the creation of objects that return random numbers

   /**
   * \brief Constructs a weibull random variable with the specified mean
   * \brief value, shape (alpha), and upper bound.
   * Since WeibullVariableImpl distributions can theoretically return unbounded values,
   * it is sometimes usefull to specify a fixed upper limit.  Note however
   * that when the upper limit is specified, the true mean of the distribution
   * is slightly smaller than the mean value specified.

   * \param b Upper limit on returned values
   */
  WeibullVariable(double m, double s, double b);

  WeibullVariable(const WeibullVariable& c);
  
  /**
   * \return A random value from this Weibull distribution
   */
  virtual double GetValue();
  virtual RandomVariable* Copy() const;
public:
  /**
   * \param m Mean value for the distribution.
   * \param s Shape (alpha) parameter for the distribution.

   * \return Random number from a distribution specified by m,s, and b
   */
  static double GetSingleValue(double m, double s, double b=0);
private:
  double m_mean;  // Mean value of RV
  double m_alpha; // Shape parameter
  double m_bound; // Upper bound on value (if non-zero)
};

/**
 * \brief Class NormalVariableImpl defines a random variable with a
 * normal (Gaussian) distribution.
 * \ingroup randomvariable
 * 

 * where \f$ mean = \mu \f$ and \f$ variance = \sigma^2 \f$
 *
 */
class NormalVariable : public RandomVariable
{
public:
   static const double INFINITE_VALUE;
  /**

   * \brief Construct a normal random variable with specified mean and variance
   * \param m Mean value
   * \param v Variance
   * \param b Bound.  The NormalVariableImpl is bounded within +-bound.
   */ 
  NormalVariable(double m, double v, double b = INFINITE_VALUE);

  NormalVariable(const NormalVariable& c);
  
  /**
   * \return A value from this normal distribution
   */
  virtual double GetValue();
  virtual RandomVariable* Copy() const;
public:
  /**
   * \param m Mean value
   * \param v Variance
   * \param b Bound.  The NormalVariableImpl is bounded within +-bound.
   * \return A random number from a distribution specified by m,v, and b.
   */ 
  static double GetSingleValue(double m, double v, double b = INFINITE_VALUE);
private:
  double m_mean;      // Mean value of RV
  double m_variance;  // Mean value of RV
  double m_bound;     // Bound on value (absolute value)
  bool   m_nextValid; // True if next valid
  double m_next;      // The algorithm produces two values at a time
  static bool   m_static_nextValid;
  static double m_static_next;
};

/**
 * \brief EmpiricalVariableImpl distribution random var
 * \ingroup randomvariable
 *
 * Defines a random variable  that has a specified, empirical 

class EmpiricalVariable : public RandomVariable {
public:
  /**
   * Constructor for the EmpiricalVariableImpl random variables.
   */
  explicit EmpiricalVariable();

  virtual ~EmpiricalVariable();
  EmpiricalVariable(const EmpiricalVariable& c);
  /**
   * \return A value from this empirical distribution
   */
  virtual double GetValue();
  virtual RandomVariable* Copy() const;
  /**
   * \brief Specifies a point in the empirical distribution
   * \param v The function value for this point
   * \param c Probability that the function is less than or equal to v
   */
  void CDF(double v, double c);  // Value, prob <= Value
protected:
  EmpiricalVariable (const RandomVariableBase &variable);
  class ValueCDF {
  public:
    ValueCDF();
    ValueCDF(double v, double c);
    ValueCDF(const ValueCDF& c);
    double value;
    double    cdf;
  };
  virtual void Validate();  // Insure non-decreasing emiprical values
  virtual double Interpolate(double, double, double, double, double);
  bool validated; // True if non-decreasing validated
  std::vector<ValueCDF> emp;       // Empicical CDF
};

/**

 * \ingroup randomvariable
 *
 * Defines an empirical distribution where all values are integers.
 * Indentical to EmpiricalVariableImpl, but with slightly different
 * interpolation between points.
 */
class IntEmpiricalVariable : public EmpiricalVariable 
{
public:

  IntEmpiricalVariable();
  
  virtual RandomVariable* Copy() const;
  /**
   * \return An integer value from this empirical distribution
   */
  virtual uint32_t GetIntValue();
  virtual double Interpolate(double, double, double, double, double);
};

/**

 * the RNG to return a known sequence, perhaps to
 * compare NS-3 to some other simulator
 */
class DeterministicVariable : public RandomVariable
{
public:
  /**
   * \brief Constructor

   * on successive calls to ::Value().  Note that the d pointer is copied
   * for use by the generator (shallow-copy), not its contents, so the 
   * contents of the array d points to have to remain unchanged for the use 
   * of DeterministicVariableImpl to be meaningful.
   * \param d Pointer to array of random values to return in sequence
   * \param c Number of values in the array
   */
  explicit DeterministicVariable(double* d, uint32_t c);

  virtual ~DeterministicVariable();
  /**
   * \return The next value in the deterministic sequence
   */
  virtual double GetValue();
  virtual RandomVariable* Copy() const;
private:
  uint32_t   count;
  uint32_t   next;
  double* data;
};



 * \brief Log-normal Distributed random var
 * \ingroup randomvariable
 *
 * LogNormalVariableImpl defines a random variable with log-normal
 * distribution.  If one takes the natural logarithm of random
 * variable following the log-normal distribution, the obtained values
 * follow a normal distribution.

 * \f$ \mu = ln(mean) - \frac{1}{2}ln\left(1+\frac{stddev}{mean^2}\right)\f$, and,
 * \f$ \sigma = \sqrt{ln\left(1+\frac{stddev}{mean^2}\right)}\f$
 */
class LogNormalVariable : public RandomVariable 
{
public:
  /**
   * \param mu mu parameter of the lognormal distribution

  LogNormalVariable (double mu, double sigma);

  /**
   * \return A random value from this distribution
   */
  virtual double GetValue ();
  virtual RandomVariable* Copy() const;
public:
  /**
   * \param mu mu parameter of the underlying normal distribution
   * \param sigma sigma parameter of the underlying normal distribution
   * \return A random number from the distribution specified by mu and sigma
   */
  static double GetSingleValue(double mu, double sigma);
private:
  double m_mu;
  double m_sigma;
};

/**

 * This distribution is a triangular distribution.  The probablility density
 * is in the shape of a triangle.
 */
class TriangularVariable : public RandomVariable 
{
public:
  /**
   * Creates a triangle distribution random number generator in the

   * \param mean mean of the distribution
   */
  TriangularVariable(double s, double l, double mean);

  TriangularVariable(const TriangularVariable& c);
  
  /**
   * \return A value from this distribution
   */
  virtual double GetValue();
  virtual RandomVariable*  Copy() const;
public:
  /**
   * \param s Low end of the range
   * \param l High end of the range

   * \return A triangularly distributed random number between s and l
   */
  static double GetSingleValue(double s, double l, double mean);
private:
  double m_min;
  double m_max;
  double m_mode;  //easier to work with the mode internally instead of the mean
                  //they are related by the simple: mean = (min+max+mode)/3
};

}//namespace ns3




}

RandomPropagationDelayModel::RandomPropagationDelayModel ()
  : m_variable (g_random.Get ())
{}

RandomPropagationDelayModel::RandomPropagationDelayModel (const RandomVariable &variable)
  : m_variable (variable)
{}
RandomPropagationDelayModel::~RandomPropagationDelayModel ()
{}
  delete m_variable;
}
Time 
RandomPropagationDelayModel::GetDelay (Ptr<MobilityModel> a, Ptr<MobilityModel> b) const
{
  return Seconds (m_variable.GetValue ());
}

ConstantSpeedPropagationDelayModel::ConstantSpeedPropagationDelayModel (double speed)




#include "ns3/ptr.h"
#include "ns3/object.h"
#include "ns3/nstime.h"
#include "ns3/random-variable.h"

namespace ns3 {

class MobilityModel;

class RandomVariable;

/**
 * \brief calculate a propagation delay.

  virtual ~RandomPropagationDelayModel ();
  virtual Time GetDelay (Ptr<MobilityModel> a, Ptr<MobilityModel> b) const;
private:
  RandomVariable m_variable;
};

/**




  }
}
RandomPropagationLossModel::RandomPropagationLossModel ()
  : m_variable (g_random.Get ())
{}

RandomPropagationLossModel::RandomPropagationLossModel (const RandomVariable &variable)
  : m_variable (variable)
{}
RandomPropagationLossModel::~RandomPropagationLossModel ()
{}
  delete m_variable;
}

double 
RandomPropagationLossModel::GetRxPower (double txPowerDbm,
					Ptr<MobilityModel> a,
					Ptr<MobilityModel> b) const
{
  double rxPower = txPowerDbm - m_variable.GetValue ();
  NS_LOG_DEBUG ("tx power="<<txPowerDbm<<"dbm, rx power="<<rxPower<<"Dbm");
  return rxPower;
}




#define PROPAGATION_LOSS_MODEL_H

#include "ns3/object.h"
#include "ns3/random-variable.h"

namespace ns3 {

class MobilityModel;

class RandomVariable;

/**
 * \brief Modelize the propagation loss through a transmission medium

			     Ptr<MobilityModel> a,
			     Ptr<MobilityModel> b) const;
private:
  RandomVariable m_variable;
};

/**





RandomDirection2dMobilityModelParameters::RandomDirection2dMobilityModelParameters ()
  : m_bounds (g_bounds.GetValue ()),
    m_speedVariable (g_speedVariable.Get ()),
    m_pauseVariable (g_pauseVariable.Get ())
    
{}
RandomDirection2dMobilityModelParameters::RandomDirection2dMobilityModelParameters 

 const RandomVariable &speedVariable,
 const RandomVariable &pauseVariable)
  : m_bounds (bounds),
    m_speedVariable (speedVariable),
    m_pauseVariable (pauseVariable)
{}

RandomDirection2dMobilityModelParameters::~RandomDirection2dMobilityModelParameters ()
{}
  delete m_speedVariable;
  delete m_pauseVariable;
  m_speedVariable = 0;
  m_pauseVariable = 0;
}

void 
RandomDirection2dMobilityModelParameters::SetSpeed (const RandomVariable &speedVariable)
{
  m_speedVariable = speedVariable;
  m_speedVariable = speedVariable.Copy ();
}
void 
RandomDirection2dMobilityModelParameters::SetPause (const RandomVariable &pauseVariable)
{
  m_pauseVariable = pauseVariable;
  m_pauseVariable = pauseVariable.Copy ();
}
void 
RandomDirection2dMobilityModelParameters::SetBounds (const Rectangle &bounds)

void
RandomDirection2dMobilityModel::BeginPause (void)
{
  Time pause = Seconds (m_parameters->m_pauseVariable.GetValue ());
  m_helper.Pause ();
  m_event = Simulator::Schedule (pause, &RandomDirection2dMobilityModel::ResetDirectionAndSpeed, this);
  NotifyCourseChange ();

RandomDirection2dMobilityModel::SetDirectionAndSpeed (double direction)
{
  NS_LOG_FUNCTION;
  double speed = m_parameters->m_speedVariable.GetValue ();
  const Vector vector (std::cos (direction) * speed,
                       std::sin (direction) * speed,
                       0.0);




#include "ns3/nstime.h"
#include "ns3/event-id.h"
#include "ns3/rectangle.h"
#include "ns3/random-variable.h"
#include "mobility-model.h"
#include "static-speed-helper.h"

namespace ns3 {

class RandomVariable;

/**
 * \brief the parameters to control a RandomDirection mobility model.

  static Ptr<RandomDirection2dMobilityModelParameters> GetCurrent (void);

  Rectangle m_bounds;
  RandomVariable m_speedVariable;
  RandomVariable m_pauseVariable;
};

/**




}

RandomRectanglePosition::RandomRectanglePosition ()
  : m_x (g_rectangleX.Get ()),
    m_y (g_rectangleY.Get ())
{}
RandomRectanglePosition::RandomRectanglePosition (const RandomVariable &x,
						  const RandomVariable &y)
  : m_x (x),
    m_y (y)
{}
RandomRectanglePosition::~RandomRectanglePosition ()
{}
  delete m_x;
  delete m_y;
  m_x = 0;
  m_y = 0;
}
Vector
RandomRectanglePosition::Get (void) const
{
  double x = m_x.GetValue ();
  double y = m_y.GetValue ();
  return Vector (x, y, 0.0);
}


}   

RandomDiscPosition::RandomDiscPosition ()
  : m_theta (g_discTheta.Get ()),
    m_rho (g_discRho.Get ()),
    m_x (g_discX.GetValue ()),
    m_y (g_discY.GetValue ())
{}
RandomDiscPosition::RandomDiscPosition (const RandomVariable &theta,
					const RandomVariable &rho,
					double x, double y)
  : m_theta (theta),
    m_rho (rho),
    m_x (0.0),
    m_y (0.0)
{}
RandomDiscPosition::~RandomDiscPosition ()
{}
  delete m_theta;
  delete m_rho;
  m_theta = 0;
  m_rho = 0;
}
Vector
RandomDiscPosition::Get (void) const
{
  double theta = m_theta.GetValue ();
  double rho = m_rho.GetValue ();
  double x = m_x + std::cos (theta) * rho;
  double y = m_y + std::sin (theta) * rho;
  NS_LOG_DEBUG ("Disc position x=" << x << ", y=" << y);




#define RANDOM_POSITION_H

#include "ns3/object.h"
#include "ns3/random-variable.h"
#include "vector.h"

namespace ns3 {

class RandomVariable;

/**
 * \brief choose a position at random.

  virtual ~RandomRectanglePosition ();
  virtual Vector Get (void) const;
private:
  RandomVariable m_x;
  RandomVariable m_y;
};

/**

  virtual ~RandomDiscPosition ();
  virtual Vector Get (void) const;
private:
  RandomVariable m_theta;
  RandomVariable m_rho;
  double m_x;
  double m_y;
};




  : m_mode (g_mode.GetValue ()),
    m_modeDistance (g_modeDistance.GetValue ()),
    m_modeTime (g_modeTime.GetValue ()),
    m_speed (g_speed.Get ()),
    m_direction (g_direction.Get ()),
    m_bounds (g_rectangle.GetValue ())
{}

RandomWalk2dMobilityModelParameters::~RandomWalk2dMobilityModelParameters ()
{}
  delete m_speed;
  delete m_direction;
  m_speed = 0;
  m_direction = 0;
}

void 
RandomWalk2dMobilityModelParameters::SetSpeed (const RandomVariable &speed)
{
  m_speed = speed;
  m_speed = speed.Copy ();
}
void 
RandomWalk2dMobilityModelParameters::SetDirection (const RandomVariable &direction)
{
  m_direction = direction;
  m_direction = direction.Copy ();
}
void 
RandomWalk2dMobilityModelParameters::SetModeDistance (double distance)

void
RandomWalk2dMobilityModel::Start (void)
{
  double speed = m_parameters->m_speed.GetValue ();
  double direction = m_parameters->m_direction.GetValue ();
  Vector vector (std::cos (direction) * speed,
                 std::sin (direction) * speed,
                 0.0);




#include "ns3/nstime.h"
#include "ns3/event-id.h"
#include "ns3/rectangle.h"
#include "ns3/random-variable.h"
#include "mobility-model.h"
#include "static-speed-helper.h"

namespace ns3 {

class RandomVariable;

/**
 * \brief parameters to control a random walk 2d model

  enum Mode m_mode;
  double m_modeDistance;
  Time m_modeTime;
  RandomVariable m_speed;
  RandomVariable m_direction;
  Rectangle m_bounds;
};







RandomWaypointMobilityModelParameters::RandomWaypointMobilityModelParameters ()
  : m_speed (g_speed.Get ()),
    m_pause (g_pause.Get ())
{
  m_position = g_position.GetValue ().CreateObject ()->GetObject<RandomPosition> ();
}
RandomWaypointMobilityModelParameters::RandomWaypointMobilityModelParameters (Ptr<RandomPosition> randomPosition,
									      const RandomVariable &speed,
									      const RandomVariable &pause)
  : m_speed (speed),
    m_pause (pause),
    m_position (randomPosition)
{}
void 

void 
RandomWaypointMobilityModelParameters::SetSpeed (const RandomVariable &speed)
{
  m_speed = speed;
  m_speed = speed.Copy ();
}
void 
RandomWaypointMobilityModelParameters::SetPause (const RandomVariable &pause)
{
  m_pause = pause;
  m_pause = pause.Copy ();
}
void 
RandomWaypointMobilityModelParameters::DoDispose (void)
{
  m_position = 0;
  delete m_pause;
  delete m_speed;
  m_pause = 0;
  m_speed = 0;  
}

Ptr<RandomWaypointMobilityModelParameters>

{
  Vector m_current = m_helper.GetCurrentPosition ();
  Vector destination = m_parameters->m_position->Get ();
  double speed = m_parameters->m_speed.GetValue ();
  double dx = (destination.x - m_current.x);
  double dy = (destination.y - m_current.y);
  double dz = (destination.z - m_current.z);

void
RandomWaypointMobilityModel::Start (void)
{
  Time pause = Seconds (m_parameters->m_pause.GetValue ());
  m_helper.Pause ();
  NotifyCourseChange ();
  m_event = Simulator::Schedule (pause, &RandomWaypointMobilityModel::BeginWalk, this);




#include "mobility-model.h"
#include "random-position.h"
#include "ns3/ptr.h"
#include "ns3/random-variable.h"

namespace ns3 {

class RandomVariable;

/**
 * \brief the parameters which control the behavior of a random waypoint

  friend class RandomWaypointMobilityModel;
  static Ptr<RandomWaypointMobilityModelParameters> GetCurrent (void);
  virtual void DoDispose (void);
  RandomVariable m_speed;
  RandomVariable m_pause;
  Ptr<RandomPosition> m_position;
};






void Application::Start(const RandomVariable& startVar)
{
  RandomVariable v = startVar;
  ScheduleStart (Seconds (v.GetValue ()));
  delete v;
}

   


void Application::Stop(const RandomVariable& stopVar)
{
  RandomVariable v = stopVar;
  ScheduleStop (Seconds (v.GetValue ()));
  delete v;
}
  
Ptr<Node> Application::GetNode() const

Return to bug 133