/* -*- 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>

//

#include <iostream>

#include <math.h>

#include <stdlib.h>

#include <sys/time.h>			// for gettimeofday

#include <unistd.h>

#include <iostream>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>       

#include <sstream>

#include "assert.h"

#include "config.h"

#include "integer.h"

#include "random-variable.h"

#include "rng-stream.h"

#include "fatal-error.h"

using namespace std;

namespace ns3{

//-----------------------------------------------------------------------------

// Seed Manager

//-----------------------------------------------------------------------------

uint32_t SeedManager::GetSeed()

{

  uint32_t s[6];

  RngStream::GetPackageSeed (s);

  NS_ASSERT(

              s[0] == s[1] &&

              s[0] == s[2] &&

              s[0] == s[3] &&

              s[0] == s[4] &&

              s[0] == s[5]    

            );

  return s[0];

}

void SeedManager::SetSeed(uint32_t seed)

{

  Config::SetGlobal("RngSeed", IntegerValue(seed));

}

void SeedManager::SetRun(uint32_t run)

{

  Config::SetGlobal("RngRun", IntegerValue(run));

}

uint32_t SeedManager::GetRun()

{

  return RngStream::GetPackageRun ();

}

bool SeedManager::CheckSeed (uint32_t seed)

{

  return RngStream::CheckSeed(seed);

}

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

// RandomVariableBase methods

class RandomVariableBase 

{

public:

  RandomVariableBase ();

  RandomVariableBase (const RandomVariableBase &o);

  virtual ~RandomVariableBase();

  virtual double  GetValue() = 0;

  virtual uint32_t GetInteger();

  virtual RandomVariableBase*   Copy(void) const = 0;

protected:

  RngStream* m_generator;  //underlying generator being wrapped

};

RandomVariableBase::RandomVariableBase() 

  : m_generator(NULL)

{

}

RandomVariableBase::RandomVariableBase(const RandomVariableBase& r)

  :m_generator(0)

{

  if (r.m_generator)

    {

      m_generator = new RngStream(*r.m_generator);

    }

}

RandomVariableBase::~RandomVariableBase()

{

  delete m_generator;

}

uint32_t RandomVariableBase::GetInteger() 

{

  return (uint32_t)GetValue();

}

//-------------------------------------------------------

RandomVariable::RandomVariable()

  : m_variable (0)

{}

RandomVariable::RandomVariable(const RandomVariable&o)

  : m_variable (o.m_variable->Copy ())

{}

RandomVariable::RandomVariable (const RandomVariableBase &variable)

  : m_variable (variable.Copy ())

{}

RandomVariable &

RandomVariable::operator = (const RandomVariable &o)

{

  if (&o == this)

    {

      return *this;

    }

  delete m_variable;

  m_variable = o.m_variable->Copy ();

  return *this;

}

RandomVariable::~RandomVariable()

{

  delete m_variable;

}

double  

RandomVariable::GetValue (void) const

{

  return m_variable->GetValue ();

}

uint32_t 

RandomVariable::GetInteger (void) const

{

  return m_variable->GetInteger ();

}

RandomVariableBase *

RandomVariable::Peek (void) const

{

  return m_variable;

}

ATTRIBUTE_VALUE_IMPLEMENT (RandomVariable);

ATTRIBUTE_CHECKER_IMPLEMENT (RandomVariable);

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

// UniformVariableImpl

class UniformVariableImpl : public RandomVariableBase {

public:

  /**

   * Creates a uniform random number generator in the

   * range [0.0 .. 1.0).

   */

  UniformVariableImpl();

  /**

   * Creates a uniform random number generator with the specified range

   * \param s Low end of the range

   * \param l High end of the range

   */

  UniformVariableImpl(double s, double l);

  UniformVariableImpl(const UniformVariableImpl& c);

  double GetMin (void) const;

  double GetMax (void) const;

  /**

   * \return A value between low and high values specified by the constructor

   */

  virtual double GetValue();

  /**

   * \return A value between low and high values specified by parameters

   */

  virtual double GetValue(double s, double l);

  virtual RandomVariableBase*  Copy(void) const;

private:

  double m_min;

  double m_max;

};

UniformVariableImpl::UniformVariableImpl() 

  : m_min(0), m_max(1.0) { }

UniformVariableImpl::UniformVariableImpl(double s, double l) 

  : m_min(s), m_max(l) { }

UniformVariableImpl::UniformVariableImpl(const UniformVariableImpl& c) 

  : RandomVariableBase(c), m_min(c.m_min), m_max(c.m_max) { }

double 

UniformVariableImpl::GetMin (void) const

{

  return m_min;

}

double 

UniformVariableImpl::GetMax (void) const

{

  return m_max;

}

double UniformVariableImpl::GetValue()

{

  if(!m_generator)

    {

      m_generator = new RngStream();

    }

  return m_min + m_generator->RandU01() * (m_max - m_min);

}

double UniformVariableImpl::GetValue(double s, double l) 

{

  if(!m_generator)

    {

      m_generator = new RngStream();

    }

    return s + m_generator->RandU01() * (l-s); 

}

RandomVariableBase* UniformVariableImpl::Copy() const

{

  return new UniformVariableImpl(*this);

}

UniformVariable::UniformVariable()

  : RandomVariable (UniformVariableImpl ())

{}

UniformVariable::UniformVariable(double s, double l)

  : RandomVariable (UniformVariableImpl (s, l))

{}

double UniformVariable::GetValue(void) const

{

  return this->RandomVariable::GetValue ();

}

double UniformVariable::GetValue(double s, double l)

{

  return ((UniformVariableImpl*)Peek())->GetValue(s,l);

}

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

// ConstantVariableImpl methods

class ConstantVariableImpl : public RandomVariableBase { 

public:

  /**

   * Construct a ConstantVariableImpl RNG that returns zero every sample

   */

  ConstantVariableImpl();

  /**

   * Construct a ConstantVariableImpl RNG that returns the specified value

   * every sample.

   * \param c Unchanging value for this RNG.

   */

  ConstantVariableImpl(double c);

  ConstantVariableImpl(const ConstantVariableImpl& c) ;

  /**

   * \brief Specify a new constant RNG for this generator.

   * \param c New constant value for this RNG.

   */

  void    NewConstant(double c);

  /**

   * \return The constant value specified

   */

  virtual double  GetValue();

  virtual uint32_t GetInteger();

  virtual RandomVariableBase*   Copy(void) const;

private:

  double m_const;

};

ConstantVariableImpl::ConstantVariableImpl() 

  : m_const(0) { }

ConstantVariableImpl::ConstantVariableImpl(double c) 

  : m_const(c) { };

ConstantVariableImpl::ConstantVariableImpl(const ConstantVariableImpl& c) 

  : RandomVariableBase(c), m_const(c.m_const) { }

void ConstantVariableImpl::NewConstant(double c) 

  { m_const = c;}

double ConstantVariableImpl::GetValue()

{

  return m_const;

}

uint32_t ConstantVariableImpl::GetInteger()

{

  return (uint32_t)m_const;

}

RandomVariableBase* ConstantVariableImpl::Copy() const

{

  return new ConstantVariableImpl(*this);

}

ConstantVariable::ConstantVariable()

  : RandomVariable (ConstantVariableImpl ())

{}

ConstantVariable::ConstantVariable(double c)

  : RandomVariable (ConstantVariableImpl (c))

{}

void 

ConstantVariable::SetConstant(double c)

{

  *this = ConstantVariable (c);

}

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

// SequentialVariableImpl methods

class SequentialVariableImpl : public RandomVariableBase {

public:

  /**

   * \brief Constructor for the SequentialVariableImpl RNG.

   *

   * The four parameters define the sequence.  For example

   * SequentialVariableImpl(0,5,1,2) creates a RNG that has the sequence

   * 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 0, 0 ...

   * \param f First value of the sequence.

   * \param l One more than the last value of the sequence.

   * \param i Increment between sequence values

   * \param c Number of times each member of the sequence is repeated

   */

  SequentialVariableImpl(double f, double l, double i = 1, uint32_t c = 1);

  /**

   * \brief Constructor for the SequentialVariableImpl RNG.

   *

   * Differs from the first only in that the increment parameter is a

   * random variable

   * \param f First value of the sequence.

   * \param l One more than the last value of the sequence.

   * \param i Reference to a RandomVariableBase for the sequence increment

   * \param c Number of times each member of the sequence is repeated

   */

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

  SequentialVariableImpl(const SequentialVariableImpl& c);

  ~SequentialVariableImpl();

  /**

   * \return The next value in the Sequence

   */

  virtual double GetValue();

  virtual RandomVariableBase*  Copy(void) const;

private:

  double m_min;

  double m_max;

  RandomVariable  m_increment;

  uint32_t  m_consecutive;

  double m_current;

  uint32_t  m_currentConsecutive;

};

SequentialVariableImpl::SequentialVariableImpl(double f, double l, double i, uint32_t c)

  : m_min(f), m_max(l), m_increment(ConstantVariable(i)), m_consecutive(c),

    m_current(f), m_currentConsecutive(0)

{}

SequentialVariableImpl::SequentialVariableImpl(double f, double l, const RandomVariable& i, uint32_t c)

  : m_min(f), m_max(l), m_increment(i), m_consecutive(c),

    m_current(f), m_currentConsecutive(0)

{}

SequentialVariableImpl::SequentialVariableImpl(const SequentialVariableImpl& c)

  : RandomVariableBase(c), m_min(c.m_min), m_max(c.m_max),

    m_increment(c.m_increment), m_consecutive(c.m_consecutive),

    m_current(c.m_current), m_currentConsecutive(c.m_currentConsecutive)

{}

SequentialVariableImpl::~SequentialVariableImpl()

{}

double SequentialVariableImpl::GetValue()

{ // Return a sequential series of values

  double r = m_current;

  if (++m_currentConsecutive == m_consecutive)

    { // Time to advance to next

      m_currentConsecutive = 0;

      m_current += m_increment.GetValue();

      if (m_current >= m_max)

        m_current = m_min + (m_current - m_max);

    }

  return r;

}

RandomVariableBase* SequentialVariableImpl::Copy() const

{

  return new SequentialVariableImpl(*this);

}

SequentialVariable::SequentialVariable(double f, double l, double i, uint32_t c)

  : RandomVariable (SequentialVariableImpl (f, l, i, c))

{}

SequentialVariable::SequentialVariable(double f, double l, const RandomVariable& i, uint32_t c)

  : RandomVariable (SequentialVariableImpl (f, l, i, c))

{}

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

// ExponentialVariableImpl methods

class ExponentialVariableImpl : public RandomVariableBase { 

public:

  /**

   * Constructs an exponential random variable  with a mean

   * value of 1.0.

   */

  ExponentialVariableImpl();

  /**

   * \brief Constructs an exponential random variable with a specified mean

   * \param m Mean value for the random variable

   */

  explicit ExponentialVariableImpl(double m);

  /**

   * \brief Constructs an exponential random variable with spefified

   * \brief mean and upper limit.

   *

   * Since exponential distributions can theoretically return unbounded values,

   * it is sometimes useful to specify a fixed upper limit.  Note however when

   * the upper limit is specified, the true mean of the distribution is 

   * slightly smaller than the mean value specified.

   * \param m Mean value of the random variable

   * \param b Upper bound on returned values

   */

  ExponentialVariableImpl(double m, double b);

  ExponentialVariableImpl(const ExponentialVariableImpl& c);

  /**

   * \return A random value from this exponential distribution

   */

  virtual double GetValue();

  virtual RandomVariableBase* Copy(void) const;

private:

  double m_mean;  // Mean value of RV

  double m_bound; // Upper bound on value (if non-zero)

};

ExponentialVariableImpl::ExponentialVariableImpl()