random-variable-stream.h

Go to the documentation of this file.

/*
 * 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>
 *          Alessio Bugetti <alessiobugetti98@gmail.com>
 *
 * Modified by Mitch Watrous <watrous@u.washington.edu>
 *
 */
#ifndef RANDOM_VARIABLE_STREAM_H
#define RANDOM_VARIABLE_STREAM_H
 
#include "attribute-helper.h"
#include "object.h"
#include "type-id.h"
 
#include <map>
#include <stdint.h>
 
namespace ns3
{
 
class RngStream;
 
class RandomVariableStream : public Object
{
  public:
    static TypeId GetTypeId();
    RandomVariableStream();
    ~RandomVariableStream() override;
 
    // Delete copy constructor and assignment operator to avoid misuse
    RandomVariableStream(const RandomVariableStream&) = delete;
    RandomVariableStream& operator=(const RandomVariableStream&) = delete;
 
    void SetStream(int64_t stream);
 
    int64_t GetStream() const;
 
    void SetAntithetic(bool isAntithetic);
 
    bool IsAntithetic() const;
 
    virtual double GetValue() = 0;
 
    // The base implementation returns `(uint32_t)GetValue()`
    virtual uint32_t GetInteger();
 
  protected:
    RngStream* Peek() const;
 
  private:
    RngStream* m_rng;
 
    bool m_isAntithetic;
 
    int64_t m_stream;
 
}; // class RandomVariableStream
 
class UniformRandomVariable : public RandomVariableStream
{
  public:
    static TypeId GetTypeId();
 
    UniformRandomVariable();
 
    double GetMin() const;
 
    double GetMax() const;
 
    double GetValue(double min, double max);
 
    uint32_t GetInteger(uint32_t min, uint32_t max);
 
    // Inherited
    double GetValue() override;
 
    uint32_t GetInteger() override;
 
  private:
    double m_min;
 
    double m_max;
 
}; // class UniformRandomVariable
 
class ConstantRandomVariable : public RandomVariableStream
{
  public:
    static TypeId GetTypeId();
 
    ConstantRandomVariable();
 
    double GetConstant() const;
 
    double GetValue(double constant);
    uint32_t GetInteger(uint32_t constant);
 
    // Inherited
    /*
     * \copydoc RandomVariableStream::GetValue()
     * \note This RNG always returns the same value.
     */
    double GetValue() override;
    /* \note This RNG always returns the same value. */
    using RandomVariableStream::GetInteger;
 
  private:
    double m_constant;
 
}; // class ConstantRandomVariable
 
class SequentialRandomVariable : public RandomVariableStream
{
  public:
    static TypeId GetTypeId();
 
    SequentialRandomVariable();
 
    double GetMin() const;
 
    double GetMax() const;
 
    Ptr<RandomVariableStream> GetIncrement() const;
 
    uint32_t GetConsecutive() const;
 
    // Inherited
    double GetValue() override;
    using RandomVariableStream::GetInteger;
 
  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();
 
    ExponentialRandomVariable();
 
    double GetMean() const;
 
    double GetBound() const;
 
    double GetValue(double mean, double bound);
 
    uint32_t GetInteger(uint32_t mean, uint32_t bound);
 
    // Inherited
    double GetValue() override;
    using RandomVariableStream::GetInteger;
 
  private:
    double m_mean;
 
    double m_bound;
 
}; // class ExponentialRandomVariable
 
class ParetoRandomVariable : public RandomVariableStream
{
  public:
    static TypeId GetTypeId();
 
    ParetoRandomVariable();
 
    double GetScale() const;
 
    double GetShape() const;
 
    double GetBound() const;
 
    double GetValue(double scale, double shape, double bound);
 
    uint32_t GetInteger(uint32_t scale, uint32_t shape, uint32_t bound);
 
    // Inherited
    double GetValue() override;
    using RandomVariableStream::GetInteger;
 
  private:
    double m_scale;
 
    double m_shape;
 
    double m_bound;
 
}; // class ParetoRandomVariable
 
class WeibullRandomVariable : public RandomVariableStream
{
  public:
    static TypeId GetTypeId();
 
    WeibullRandomVariable();
 
    double GetScale() const;
 
    double GetShape() const;
 
    double GetBound() const;
 
    double GetValue(double scale, double shape, double bound);
 
    uint32_t GetInteger(uint32_t scale, uint32_t shape, uint32_t bound);
 
    // Inherited
    double GetValue() override;
    using RandomVariableStream::GetInteger;
 
  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();
 
    NormalRandomVariable();
 
    double GetMean() const;
 
    double GetVariance() const;
 
    double GetBound() const;
 
    double GetValue(double mean,
                    double variance,
                    double bound = NormalRandomVariable::INFINITE_VALUE);
 
    uint32_t GetInteger(uint32_t mean, uint32_t variance, uint32_t bound);
 
    // Inherited
    double GetValue() override;
    using RandomVariableStream::GetInteger;
 
  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();
 
    LogNormalRandomVariable();
 
    double GetMu() const;
 
    double GetSigma() const;
 
    double GetValue(double mu, double sigma);
 
    uint32_t GetInteger(uint32_t mu, uint32_t sigma);
 
    // Inherited
    double GetValue() override;
    using RandomVariableStream::GetInteger;
 
  private:
    double m_mu;
 
    double m_sigma;
 
    bool m_nextValid;
 
    double m_v2;
 
    double m_normal;
 
}; // class LogNormalRandomVariable
 
class GammaRandomVariable : public RandomVariableStream
{
  public:
    static TypeId GetTypeId();
 
    GammaRandomVariable();
 
    double GetAlpha() const;
 
    double GetBeta() const;
 
    double GetValue(double alpha, double beta);
 
    uint32_t GetInteger(uint32_t alpha, uint32_t beta);
 
    // Inherited
    double GetValue() override;
    using RandomVariableStream::GetInteger;
 
  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();
 
    ErlangRandomVariable();
 
    uint32_t GetK() const;
 
    double GetLambda() const;
 
    double GetValue(uint32_t k, double lambda);
 
    uint32_t GetInteger(uint32_t k, uint32_t lambda);
 
    // Inherited
    double GetValue() override;
    using RandomVariableStream::GetInteger;
 
  private:
    double GetExponentialValue(double mean, double bound);
 
    uint32_t m_k;
 
    double m_lambda;
 
}; // class ErlangRandomVariable
 
class TriangularRandomVariable : public RandomVariableStream
{
  public:
    static TypeId GetTypeId();
 
    TriangularRandomVariable();
 
    double GetMean() const;
 
    double GetMin() const;
 
    double GetMax() const;
 
    double GetValue(double mean, double min, double max);
 
    uint32_t GetInteger(uint32_t mean, uint32_t min, uint32_t max);
 
    // Inherited
    double GetValue() override;
    using RandomVariableStream::GetInteger;
 
  private:
    double m_mean;
 
    double m_min;
 
    double m_max;
 
}; // class TriangularRandomVariable
 
class ZipfRandomVariable : public RandomVariableStream
{
  public:
    static TypeId GetTypeId();
 
    ZipfRandomVariable();
 
    uint32_t GetN() const;
 
    double GetAlpha() const;
 
    double GetValue(uint32_t n, double alpha);
 
    uint32_t GetInteger(uint32_t n, uint32_t alpha);
 
    // Inherited
    double GetValue() override;
    using RandomVariableStream::GetInteger;
 
  private:
    uint32_t m_n;
 
    double m_alpha;
 
    double m_c;
 
}; // class ZipfRandomVariable
 
class ZetaRandomVariable : public RandomVariableStream
{
  public:
    static TypeId GetTypeId();
 
    ZetaRandomVariable();
 
    double GetAlpha() const;
 
    double GetValue(double alpha);
 
    uint32_t GetInteger(uint32_t alpha);
 
    // Inherited
    double GetValue() override;
    using RandomVariableStream::GetInteger;
 
  private:
    double m_alpha;
 
    double m_b;
 
}; // class ZetaRandomVariable
 
class DeterministicRandomVariable : public RandomVariableStream
{
  public:
    static TypeId GetTypeId();
 
    DeterministicRandomVariable();
    ~DeterministicRandomVariable() override;
 
    void SetValueArray(const std::vector<double>& values);
    void SetValueArray(const double* values, std::size_t length);
 
    // Inherited
    double GetValue() override;
    using RandomVariableStream::GetInteger;
 
  private:
    std::size_t m_count;
 
    std::size_t m_next;
 
    double* m_data;
 
}; // class DeterministicRandomVariable
 
class EmpiricalRandomVariable : public RandomVariableStream
{
  public:
    static TypeId GetTypeId();
 
    EmpiricalRandomVariable();
 
    void CDF(double v, double c); // Value, prob <= Value
 
    // Inherited
    double GetValue() override;
    using RandomVariableStream::GetInteger;
 
    virtual double Interpolate();
 
    bool SetInterpolate(bool interpolate);
 
  private:
    void Validate();
    bool PreSample(double& value);
    double DoSampleCDF(double r);
    double DoInterpolate(double r);
 
    bool m_validated;
    std::map<double, double> m_empCdf;
    bool m_interpolate;
 
}; // class EmpiricalRandomVariable
 
class BinomialRandomVariable : public RandomVariableStream
{
  public:
    static TypeId GetTypeId();
 
    BinomialRandomVariable();
 
    double GetValue(uint32_t trials, double probability);
 
    uint32_t GetInteger(uint32_t trials, uint32_t probability);
 
    // Inherited
    double GetValue() override;
    using RandomVariableStream::GetInteger;
 
  private:
    uint32_t m_trials;
 
    double m_probability;
 
}; // class BinomialRandomVariable
 
class BernoulliRandomVariable : public RandomVariableStream
{
  public:
    static TypeId GetTypeId();
 
    BernoulliRandomVariable();
 
    double GetValue(double probability);
 
    uint32_t GetInteger(uint32_t probability);
 
    // Inherited
    double GetValue() override;
    using RandomVariableStream::GetInteger;
 
  private:
    double m_probability;
 
}; // class BernoulliRandomVariable
 
} // namespace ns3
 
#endif /* RANDOM_VARIABLE_STREAM_H */