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 ();

  NS_DEPRECATED
  double GetMean (void) const;

  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_mean;

  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_next;

};  // 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_next;

};  // 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 CDF (double v, double c);  // Value, prob <= Value

  virtual double GetValue (void);

  virtual uint32_t GetInteger (void);

private:
  class ValueCDF
  {
public:
    ValueCDF ();
    ValueCDF (double v, double c);
    ValueCDF (const ValueCDF& c);

    double value;
    double    cdf;
  };
  virtual void Validate ();
  virtual double Interpolate (double c1, double c2,
                              double v1, double v2, double r);
  
  bool m_validated;
  std::vector<ValueCDF> m_emp;

};  // class EmpiricalRandomVariable
  

} // namespace ns3

#endif /* RANDOM_VARIABLE_STREAM_H */