inet::httptools::rdZipf Class Reference

Zipf distribution random object. More...

#include <HttpRandom.h>

Inheritance diagram for inet::httptools::rdZipf:

Public Member Functions
	rdZipf (int n, double alpha, bool baseZero=false)
	rdZipf (cXMLAttributeMap attributes)
virtual double	draw () override
virtual std::string	toString () override
void	setN (int n)
int	getN ()
void	setAlpha (double alpha)
double	getAlpha ()
Public Member Functions inherited from inet::httptools::rdObject
virtual	~rdObject ()
DISTR_TYPE	getType ()
std::string	typeStr ()

Protected Attributes
double	m_alpha = NaN
int	m_number = 0
double	m_c = NaN
bool	m_baseZero = false
Protected Attributes inherited from inet::httptools::rdObject
DISTR_TYPE	m_type = dt_normal

Private Member Functions
void	__initialize (int n, double alpha, bool baseZero)
void	__setup_c ()

Additional Inherited Members
Protected Member Functions inherited from inet::httptools::rdObject
bool	_hasKey (cXMLAttributeMap attributes, std::string key)

Detailed Description

Zipf distribution random object.

Returns a random value from a zipf distribution (1/n^a), where a is the constant alpha and n is a order of popularity. See more details on http://en.wikipedia.org/wiki/Zipf.

Constructor & Destructor Documentation

inet::httptools::rdZipf::rdZipf	(	int	n,
		double	alpha,
		bool	baseZero = false
	)

{
    m_type = dt_zipf;
    __initialize(n, alpha, baseZero);
}

inet::httptools::rdZipf::rdZipf

(

cXMLAttributeMap

attributes

)

{
    m_type = dt_zipf;

    if (!_hasKey(attributes, "n"))
        throw "Undefined parameter for zipf distribution. n must be defined for an exponential distribution";
    if (!_hasKey(attributes, "alpha"))
        throw "Undefined parameter for zipf distribution. alpha must be defined for an exponential distribution";

    int n;
    double alpha;
    bool baseZero = false;

    if (_hasKey(attributes, "zeroBased"))
        baseZero = strcmp(attributes["zeroBased"].c_str(), "true") == 0;

    try {
        n = atoi(attributes["n"].c_str());
    }
    catch (...) {
        n = 1;
    }
    try {
        alpha = atof(attributes["alpha"].c_str());
    }
    catch (...) {
        alpha = 1.0;
    }
    __initialize(n, alpha, baseZero);
}

Member Function Documentation

void inet::httptools::rdZipf::__initialize ( int  n, double  alpha, bool  baseZero  )

private

{
    m_number = n;
    m_alpha = alpha;
    m_baseZero = baseZero;
    __setup_c();
}

void inet::httptools::rdZipf::__setup_c ( )

private

{
    m_c = 0.0;
    for (int i = 1; i <= m_number; i++)
        m_c += (1.0 / pow((double)i, m_alpha));
    m_c = 1.0 / m_c;
}

double inet::httptools::rdZipf::draw ( )

overridevirtual

Implements inet::httptools::rdObject.

{
    double sum_prob = 0;
    double z = RNGCONTEXT uniform(0.0001, 0.9999);
    int i;
    for (i = 1; i <= m_number; i++) {
        sum_prob += m_c / pow((double)i, m_alpha);
        if (sum_prob >= z)
            break;
    }
    if (m_baseZero)
        return i - 1;
    else
        return i;
}

double inet::httptools::rdZipf::getAlpha ( )

inline

{ return m_alpha; }

int inet::httptools::rdZipf::getN ( )

inline

{ return m_number; }

void inet::httptools::rdZipf::setAlpha ( double  alpha )

inline

{ m_alpha = alpha; __setup_c(); }

void inet::httptools::rdZipf::setN ( int  n )

inline

{ m_number = n; __setup_c(); }

std::string inet::httptools::rdZipf::toString ( )

overridevirtual

Reimplemented from inet::httptools::rdObject.

{
    std::ostringstream str;
    str << "Zipf probability distribution. n=" << m_number << ", alpha=" << m_alpha;
    if (m_baseZero)
        str << " Zero-based";
    str << endl;
    return str.str();
}

Member Data Documentation

double inet::httptools::rdZipf::m_alpha = NaN

protected

bool inet::httptools::rdZipf::m_baseZero = false

protected

double inet::httptools::rdZipf::m_c = NaN

protected

int inet::httptools::rdZipf::m_number = 0

protected

---

The documentation for this class was generated from the following files:

• HttpRandom.h
• HttpRandom.cc