/*
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 */

#include "statist.H"
#include <math.h>

#define EulerGamma 0.577215664901532

inline double H(int n)
{
    const double x1 = 1/(2*n);
    const double x2 = x1/(6*n);
    const double x3 = x2/(10*n*n);
    return log(double(n))+EulerGamma+x1-x2+x3;
}

zipf::zipf(int size) 
{
    ln_n = log(double(size));
    c = 1/(ln_n+EulerGamma);
}

void zipf::reset(int size) 
{
    ln_n = log(size);
    c = 1/(ln_n+EulerGamma);
}

int zipf::random()
{
    double r = drand48();
    return int(floor(exp(r*ln_n+EulerGamma*(r-1))));
}

double zipf::p(int i)
{
    return c/i;
}

exponential::exponential(double x) : mu(x){};

void exponential::reset(double x)
{
    mu = x;
}

double exponential::random()
{
    return -mu*log(1-drand48());
}

skewed_boolean::skewed_boolean(double skew) : r(skew){};

void skewed_boolean::reset(double skew)
{
    r = skew;
}

int skewed_boolean::random()
{
    return drand48()>r;
}

permutation::permutation(int size) : n(size)
{
    Map = new int[size];
    Inverse = new int[size];
    for (int i=0; i<n; i++)
	Map[i]=Inverse[i]=i;
    randomize();
}

void permutation::randomize()
{
    for (int i=1; i<n; i++)
	swap(i, (int)floor(drand48()*i));
}

permutation::~permutation()
{
    delete [] Map;
    delete [] Inverse;
}