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

#include <cstdlib>

#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 <vector>

#include "assert.h"

#include "random-variable.h"

#include "rng-seed-manager.h"

#include "rng-stream.h"

#include "fatal-error.h"

namespace ns3 {

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

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

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

  RngStream *GetStream(void);

private:

  RngStream* m_generator;  // underlying generator being wrapped

};

RandomVariableBase::RandomVariableBase ()

  : m_generator (0)

{

}

RandomVariableBase::RandomVariableBase (const RandomVariableBase& r)

  : m_generator (0)

{

  if (r.m_generator != 0)

    {

      m_generator = new RngStream (RngSeedManager::GetSeed (),

                                   RngSeedManager::GetNextStreamIndex (),

                                   RngSeedManager::GetRun ());

    }

}

RandomVariableBase::~RandomVariableBase ()

{

  delete m_generator;

}

uint32_t RandomVariableBase::GetInteger ()

{

  return (uint32_t)GetValue ();

}

RngStream *

RandomVariableBase::GetStream (void)

{

  if (m_generator == 0)

    {

      m_generator = new RngStream (RngSeedManager::GetSeed (),

                                   RngSeedManager::GetNextStreamIndex (),

                                   RngSeedManager::GetRun ());

    }

  return m_generator;

}

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

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 ()

{

  RngStream *generator = GetStream ();

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

}

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

{

  RngStream *generator = GetStream ();

  return s + 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);

}

uint32_t UniformVariable::GetInteger (uint32_t s, uint32_t l)

{

  NS_ASSERT (s <= l);

  return static_cast<uint32_t> ( GetValue (s, l + 1) );

}

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

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

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