random-variable.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
//
// 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
//
// Author: Rajib Bhattacharjea<raj.b@gatech.edu>
// Author: Hadi Arbabi<marbabi@cs.odu.edu>
//

#ifndef NS3_RANDOM_VARIABLE_H
#define NS3_RANDOM_VARIABLE_H

#include <vector>
#include <algorithm>
#include <stdint.h>
#include <istream>
#include <ostream>
#include "attribute.h"
#include "attribute-helper.h"
#include "rng-seed-manager.h"

namespace ns3 {

class RandomVariableBase;

class RandomVariable
{
public:
  RandomVariable ();
  RandomVariable (const RandomVariable&o);
  RandomVariable &operator = (const RandomVariable &o);
  ~RandomVariable ();

  double GetValue (void) const;

  uint32_t GetInteger (void) const;

private:
  friend std::ostream & operator << (std::ostream &os, const RandomVariable &var);
  friend std::istream & operator >> (std::istream &os, RandomVariable &var);

  RandomVariableBase *m_variable;
protected:
  RandomVariable (const RandomVariableBase &variable);
  RandomVariableBase * Peek (void) const;
};

class UniformVariable : public RandomVariable
{
public:
  UniformVariable ();

  UniformVariable (double s, double l);

  double GetValue (void) const;

  double GetValue (double s, double l);

  uint32_t GetInteger (uint32_t s, uint32_t l);
};

class ConstantVariable : public RandomVariable
{

public:
  ConstantVariable ();

  ConstantVariable (double c);

  void SetConstant (double c);

};

class SequentialVariable : public RandomVariable
{
public:
  SequentialVariable (double f, double l, double i = 1, uint32_t c = 1);

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

};

class ExponentialVariable : public RandomVariable
{
public:
  ExponentialVariable ();

  explicit ExponentialVariable (double m);

  ExponentialVariable (double m, double b);

};

class ParetoVariable : public RandomVariable
{
public:
  ParetoVariable ();

  explicit ParetoVariable (double m);

  ParetoVariable (double m, double s);

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

  ParetoVariable (std::pair<double, double> params);

  ParetoVariable (std::pair<double, double> params, double b);

};

class WeibullVariable : public RandomVariable
{
public:
  WeibullVariable ();


  WeibullVariable (double m);

  WeibullVariable (double m, double s);

  WeibullVariable (double m, double s, double b);

};

class NormalVariable : public RandomVariable
{
public:
  NormalVariable ();

  NormalVariable (double m, double v);

  NormalVariable (double m, double v, double b);
};

class EmpiricalVariable : public RandomVariable
{
public:
  explicit EmpiricalVariable ();

  void CDF (double v, double c);  // Value, prob <= Value
protected:
  EmpiricalVariable (const RandomVariableBase &variable);
};

class IntEmpiricalVariable : public EmpiricalVariable
{
public:
  IntEmpiricalVariable ();
};

class DeterministicVariable : public RandomVariable
{
public:
  explicit DeterministicVariable (double* d, uint32_t c);
};

class LogNormalVariable : public RandomVariable
{
public:
  LogNormalVariable (double mu, double sigma);
};

class GammaVariable : public RandomVariable
{
public:
  GammaVariable ();

  GammaVariable (double alpha, double beta);

  double GetValue (void) const;

  double GetValue (double alpha, double beta) const;
};

class ErlangVariable : public RandomVariable
{
public:
  ErlangVariable ();

  ErlangVariable (unsigned int k, double lambda);

  double GetValue (void) const;

  double GetValue (unsigned int k, double lambda) const;
};

class ZipfVariable : public RandomVariable
{
public:
  ZipfVariable (long N, double alpha);
  ZipfVariable ();
};

class ZetaVariable : public RandomVariable
{
public:
  ZetaVariable (double alpha);
  ZetaVariable ();
};

class TriangularVariable : public RandomVariable
{
public:
  TriangularVariable ();

  TriangularVariable (double s, double l, double mean);

};

std::ostream & operator << (std::ostream &os, const RandomVariable &var);
std::istream & operator >> (std::istream &os, RandomVariable &var);

ATTRIBUTE_VALUE_DEFINE (RandomVariable);
ATTRIBUTE_CHECKER_DEFINE (RandomVariable);
ATTRIBUTE_ACCESSOR_DEFINE (RandomVariable);

} // namespace ns3

#endif /* NS3_RANDOM_VARIABLE_H */