random-variable-stream.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2006 Georgia Tech Research Corporation
 * Copyright (c) 2011 Mathieu Lacage
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Authors: Rajib Bhattacharjea<raj.b@gatech.edu>
 *          Hadi Arbabi<marbabi@cs.odu.edu>
 *          Mathieu Lacage <mathieu.lacage@gmail.com>
 *
 * Modified by Mitch Watrous <watrous@u.washington.edu>
 *
 */
#ifndef RANDOM_VARIABLE_STREAM_H
#define RANDOM_VARIABLE_STREAM_H
 
#include "type-id.h"
#include "object.h"
#include "attribute-helper.h"
#include <stdint.h>
 
namespace ns3 {
 
class RngStream;
 
class RandomVariableStream : public Object
{
public:
  static TypeId GetTypeId (void);
  RandomVariableStream ();
  virtual ~RandomVariableStream ();
 
  void SetStream (int64_t stream);
 
  int64_t GetStream (void) const;
 
  void SetAntithetic (bool isAntithetic);
 
  bool IsAntithetic (void) const;
 
  virtual double GetValue (void) = 0;
 
  virtual uint32_t GetInteger (void) = 0;
 
protected:
  RngStream * Peek (void) const;
 
private:
  RandomVariableStream (const RandomVariableStream &o);
  RandomVariableStream &operator = (const RandomVariableStream &o);
 
  RngStream *m_rng;
 
  bool m_isAntithetic;
 
  int64_t m_stream;
 
};  // class RandomVariableStream
 
 
class UniformRandomVariable : public RandomVariableStream
{
public:
  static TypeId GetTypeId (void);
 
  UniformRandomVariable ();
 
  double GetMin (void) const;
 
  double GetMax (void) const;
 
  double GetValue (double min, double max);
 
  uint32_t GetInteger (uint32_t min, uint32_t max);
 
  // Inherited from RandomVariableStream
  virtual double GetValue (void);
  virtual uint32_t GetInteger (void);
 
private:
  double m_min;
 
  double m_max;
 
};  // class UniformRandomVariable
 
 
class ConstantRandomVariable : public RandomVariableStream
{
public:
  static TypeId GetTypeId (void);
 
  ConstantRandomVariable ();
 
  double GetConstant (void) const;
 
  double GetValue (double constant);
  uint32_t GetInteger (uint32_t constant);
 
  // Inherited from RandomVariableStream
  /* \note This RNG always returns the same value. */
  virtual double GetValue (void);
  /* \note This RNG always returns the same value. */
  virtual uint32_t GetInteger (void);
 
private:
  double m_constant;
 
};  // class ConstantRandomVariable
 
 
class SequentialRandomVariable : public RandomVariableStream
{
public:
  static TypeId GetTypeId (void);
 
  SequentialRandomVariable ();
 
  double GetMin (void) const;
 
  double GetMax (void) const;
 
  Ptr<RandomVariableStream> GetIncrement (void) const;
 
  uint32_t GetConsecutive (void) const;
 
  // Inherited from RandomVariableStream
  virtual double GetValue (void);
  virtual uint32_t GetInteger (void);
 
private:
  double m_min;
 
  double m_max;
 
  Ptr<RandomVariableStream> m_increment;
 
  uint32_t m_consecutive;
 
  double m_current;
 
  uint32_t m_currentConsecutive;
 
  bool m_isCurrentSet;
 
};  // class SequentialRandomVariable
 
 
class ExponentialRandomVariable : public RandomVariableStream
{
public:
  static TypeId GetTypeId (void);
 
  ExponentialRandomVariable ();
 
  double GetMean (void) const;
 
  double GetBound (void) const;
 
  double GetValue (double mean, double bound);
 
  uint32_t GetInteger (uint32_t mean, uint32_t bound);
 
  // Inherited from RandomVariableStream
  virtual double GetValue (void);
  virtual uint32_t GetInteger (void);
 
private:
  double m_mean;
 
  double m_bound;
 
};  // class ExponentialRandomVariable
 
 
class ParetoRandomVariable : public RandomVariableStream
{
public:
  static TypeId GetTypeId (void);
 
  ParetoRandomVariable ();
 
  double GetScale (void) const;
 
  double GetShape (void) const;
 
  double GetBound (void) const;
 
  double GetValue (double scale, double shape, double bound);
 
  uint32_t GetInteger (uint32_t scale, uint32_t shape, uint32_t bound);
 
  virtual double GetValue (void);
 
  virtual uint32_t GetInteger (void);
 
private:
  double m_scale;
 
  double m_shape;
 
  double m_bound;
 
};  // class ParetoRandomVariable
 
 
class WeibullRandomVariable : public RandomVariableStream
{
public:
  static TypeId GetTypeId (void);
 
  WeibullRandomVariable ();
 
  double GetScale (void) const;
 
  double GetShape (void) const;
 
  double GetBound (void) const;
 
  double GetValue (double scale, double shape, double bound);
 
  uint32_t GetInteger (uint32_t scale, uint32_t shape, uint32_t bound);
 
  virtual double GetValue (void);
 
  virtual uint32_t GetInteger (void);
 
private:
  double m_scale;
 
  double m_shape;
 
  double m_bound;
 
};  // class WeibullRandomVariable
 
 
class NormalRandomVariable : public RandomVariableStream
{
public:
  static const double INFINITE_VALUE;
 
  static TypeId GetTypeId (void);
 
  NormalRandomVariable ();
 
  double GetMean (void) const;
 
  double GetVariance (void) const;
 
  double GetBound (void) const;
 
  double GetValue (double mean, double variance, double bound = NormalRandomVariable::INFINITE_VALUE);
 
  uint32_t GetInteger (uint32_t mean, uint32_t variance, uint32_t bound);
 
  virtual double GetValue (void);
 
  virtual uint32_t GetInteger (void);
 
private:
  double m_mean;
 
  double m_variance;
 
  double m_bound;
 
  bool m_nextValid;
 
  double m_v2;
  double m_y;
 
};  // class NormalRandomVariable
 
 
class LogNormalRandomVariable : public RandomVariableStream
{
public:
  static TypeId GetTypeId (void);
 
  LogNormalRandomVariable ();
 
  double GetMu (void) const;
 
  double GetSigma (void) const;
 
  double GetValue (double mu, double sigma);
 
  uint32_t GetInteger (uint32_t mu, uint32_t sigma);
 
  virtual double GetValue (void);
 
  virtual uint32_t GetInteger (void);
 
private:
  double m_mu;
 
  double m_sigma;
 
};  // class LogNormalRandomVariable
 
 
class GammaRandomVariable : public RandomVariableStream
{
public:
  static TypeId GetTypeId (void);
 
  GammaRandomVariable ();
 
  double GetAlpha (void) const;
 
  double GetBeta (void) const;
 
  double GetValue (double alpha, double beta);
 
  uint32_t GetInteger (uint32_t alpha, uint32_t beta);
 
  virtual double GetValue (void);
 
  virtual uint32_t GetInteger (void);
 
private:
  double GetNormalValue (double mean, double variance, double bound);
 
  double m_alpha;
 
  double m_beta;
 
  bool m_nextValid;
 
  double m_v2;
  double m_y;
 
};  // class GammaRandomVariable
 
 
class ErlangRandomVariable : public RandomVariableStream
{
public:
  static TypeId GetTypeId (void);
 
  ErlangRandomVariable ();
 
  uint32_t GetK (void) const;
 
  double GetLambda (void) const;
 
  double GetValue (uint32_t k, double lambda);
 
  uint32_t GetInteger (uint32_t k, uint32_t lambda);
 
  virtual double GetValue (void);
 
  virtual uint32_t GetInteger (void);
 
private:
  double GetExponentialValue (double mean, double bound);
 
  uint32_t m_k;
 
  double m_lambda;
 
};  // class ErlangRandomVariable
 
 
class TriangularRandomVariable : public RandomVariableStream
{
public:
  static TypeId GetTypeId (void);
 
  TriangularRandomVariable ();
 
  double GetMean (void) const;
 
  double GetMin (void) const;
 
  double GetMax (void) const;
 
  double GetValue (double mean, double min, double max);
 
  uint32_t GetInteger (uint32_t mean, uint32_t min, uint32_t max);
 
  virtual double GetValue (void);
 
  virtual uint32_t GetInteger (void);
 
private:
  double m_mean;
 
  double m_min;
 
  double m_max;
 
};  // class TriangularRandomVariable
 
 
class ZipfRandomVariable : public RandomVariableStream
{
public:
  static TypeId GetTypeId (void);
 
  ZipfRandomVariable ();
 
  uint32_t GetN (void) const;
 
  double GetAlpha (void) const;
 
  double GetValue (uint32_t n, double alpha);
 
  uint32_t GetInteger (uint32_t n, uint32_t alpha);
 
  virtual double GetValue (void);
 
  virtual uint32_t GetInteger (void);
 
private:
  uint32_t m_n;
 
  double m_alpha;
 
  double m_c;
 
};  // class ZipfRandomVariable
 
 
class ZetaRandomVariable : public RandomVariableStream
{
public:
  static TypeId GetTypeId (void);
 
  ZetaRandomVariable ();
 
  double GetAlpha (void) const;
 
  double GetValue (double alpha);
 
  uint32_t GetInteger (uint32_t alpha);
 
  virtual double GetValue (void);
 
  virtual uint32_t GetInteger (void);
 
private:
  double m_alpha;
 
  double m_b;
 
};  // class ZetaRandomVariable
 
 
class DeterministicRandomVariable : public RandomVariableStream
{
public:
  static TypeId GetTypeId (void);
 
  DeterministicRandomVariable ();
  virtual ~DeterministicRandomVariable ();
 
  void SetValueArray (double* values, std::size_t length);
 
  virtual double GetValue (void);
 
  virtual uint32_t GetInteger (void);
 
private:
  std::size_t   m_count;
 
  std::size_t   m_next;
 
  double* m_data;
 
};  // class DeterministicRandomVariable
 
 
class EmpiricalRandomVariable : public RandomVariableStream
{
public:
  static TypeId GetTypeId (void);
 
  EmpiricalRandomVariable (void);
 
  void CDF (double v, double c);  // Value, prob <= Value
 
  virtual double GetValue (void);
 
  virtual uint32_t GetInteger (void);
 
    virtual double Interpolate (void);
 
  bool SetInterpolate (bool interpolate);
 
private:
  class ValueCDF
  {
  public:
    ValueCDF (void);
    ValueCDF (double v, double c);
 
    double value;
    double    cdf;
  };  // class ValueCDF
 
  void Validate (void);
  bool PreSample (double & value);
  double DoSampleCDF (double r);
  double DoInterpolate (double r);
 
  friend
  bool operator < (ValueCDF a, ValueCDF b);
 
  bool m_validated;
  std::vector<ValueCDF> m_emp;
  bool m_interpolate;
 
};  // class EmpiricalRandomVariable
 
 
} // namespace ns3
 
#endif /* RANDOM_VARIABLE_STREAM_H */