ns-3.24: comparison src/core/random-variable.h

equal deleted inserted replaced

-:91b7ad7fa784
+:7bffd987426c
 * \brief Constructor for a random number generator with a random seed.
 */
 RandomVariable();
 /**
+* \brief Copy constructor
+*/
+RandomVariable(const RandomVariable&);
+/**
 * \brief Destructor for a random number generator with a random seed.
 */
 virtual ~RandomVariable();
 /**
 */
 static  void UseDevRandom(bool udr = true);
 /**
 * \brief Use the global seed to force precisely reproducible results.
+*
 * It is often desirable to create a simulation that uses random
 * numbers, while at the same time is completely reproducible.
 * Specifying this set of six random seeds initializes the
 * random number generator with the specified seed.
 * Once this is set, all generators will produce fixed output
 double m_max;
 };
 /**
 * \brief A random variable that returns a constant
+*
 * Class ConstantVariable defines a random number generator that
 * returns the same value every sample.
 */
 class ConstantVariable : public RandomVariable {
 public:
 /**
-* \brief Construct a ConstantVariable RNG that returns zero every sample
+* Construct a ConstantVariable RNG that returns zero every sample
 */
 ConstantVariable();
 /**
 * Construct a ConstantVariable RNG that returns the specified value
 double m_const;
 };
 /**
 * \brief Return a sequential list of values
+*
 * Class SequentialVariable defines a random number generator that
 * returns a sequential sequence.  The sequence monotonically
 * increases for a period, then wraps around to the low value
 * and begins monotonicaly increasing again.
 */
 class SequentialVariable : public RandomVariable {
 public:
 /**
 * \brief Constructor for the SequentialVariable RNG.
+*
 * The four parameters define the sequence.  For example
 * SequentialVariable(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.
 */
 SequentialVariable(double f, double l, double i = 1, uint32_t c = 1);
 /**
 * \brief Constructor for the SequentialVariable 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 Random variable for the sequence increment
+* \param i Reference to a RandomVariable for the sequence increment
 * \param c Number of times each member of the sequence is repeated
 */
 SequentialVariable(double f, double l, const RandomVariable& i, uint32_t c = 1);
 SequentialVariable(const SequentialVariable& c);
+~SequentialVariable();
 /**
 * \return The next value in the Sequence
 */
 virtual double GetValue();
 virtual RandomVariable*  Copy() const;
 uint32_t  m_currentConsecutive;
 };
 /**
 * \brief Exponentially Distributed random var
+*
 * ExponentialVariable defines a random variable with an exponential distribution
 */
 class ExponentialVariable : public RandomVariable {
 public:
 /**
 explicit ExponentialVariable(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
 double    cdf;
 };
 /**
 * \brief EmpiricalVariable distribution random var
+*
 * Defines a random variable  that has a specified, empirical
 * distribution.  The distribution is specified by a
 * series of calls the the CDF member function, specifying a
 * value and the probability that the function value is less than
 * the specified value.  When values are requested,
 std::vector<ValueCDF> emp;       // Empicical CDF
 };
 /**
 * Defines an empirical distribution where all values are integers.
-* Indentical to {\tt EmpiricalVariable}, but with slightly different
+* Indentical to EmpiricalVariable, but with slightly different
 * interpolation between points.
 */
 class IntEmpiricalVariable : public EmpiricalVariable {
 public:
 IntEmpiricalVariable();
 virtual RandomVariable* Copy() const;
 /**
 * \return An integer value from this empirical distribution
 */
 virtual uint32_t GetIntValue();
 class DeterministicVariable : public RandomVariable {
 public:
 /**
 * \brief Constructor
+*
 * Creates a generator that returns successive elements of the d array
 * on successive calls to ::Value().  Note that the d pointer is copied
 * for use by the generator (shallow-copy), not its contents, so the
 * contents of the array d points to have to remain unchanged for the use
 * of DeterministicVariable to be meaningful.

changeset 360	7bffd987426c
parent 346	4a76f247e7dc
child 364	9df87117d468