Random.h
Classes
- RNG -- Base class for random number generators (full description)
- ACG -- Additive number generator (full description)
- MLCG -- Multiplicative linear congruential generator (full description)
- Random -- Base class for random number distributions (full description)
- Binomial -- Binomial distribution (full description)
- DiscreteUniform -- Discrete uniform distribution (full description)
- Erlang -- Erlang distribution (full description)
- Geometric -- Discrete geometric distribution (full description)
- HyperGeometric -- Hypergeometric distribution (full description)
- Normal -- Normal or Gaussian distribution (full description)
- LogNormal -- Logarithmic normal distribution (full description)
- NegativeExpntl -- Negative exponential distribution (full description)
- Poisson -- Poisson distribution (full description)
- Uniform -- Uniform distribution (full description)
- Weibull -- Weibull distribution (full description)
Interface
- Public Members
- virtual ~RNG()
- virtual void reset() = 0
- virtual uInt asuInt() = 0
- Float asFloat()
- Double asDouble()
Review Status
- Date Reviewed:
- yyyy/mm/dd
Prerequisite
- A knowledge of C++, in particular inheritance
- College level mathematics
Etymology
RNG stands for "Random Number Generator"
Synopsis
General Structure of the Classes
The two base classes RNG and
Random are used together to generate a variety
of random number distributions. A distinction must be made between
random number generators, implemented by class derived from
RNG, and random number distributions. A random number
generator produces a series of randomly ordered bits. These bits can be
used directly, or cast to another representation, such as a floating point
value. A random number generator should produce a uniform
distribution. A random number distribution, on the other hand, uses the
randomly generated bits of a generator to produce numbers from a
distribution with specific properties. Each instance of Random
uses an instance of class RNG to provide the raw, uniform
distribution used to produce the specific distribution. Several instances
of Random classes can share the same instance of RNG,
or each instance can use its own copy.
RNG
Random distributions are constructed from classes derived from
RNG, the actual random number generators. The RNG
class contains no data; it only serves to define the interface to random
number generators. The RNG::asuInt member returns a 32-bit
unsigned integer of random bits. Applications that require a number of
random bits can use this directly. More often, these random bits are
transformed to a uniformly distributed floating point number using either
asFloat or asDouble. These functions return differing
precisions and the asDouble function will use two different
random 32-bit integers to get a legal double, while
asFloat will use a single integer. These members are used by
classes derived fro the Random base class to implement a variety
of random number distributions.
Currently, the following subclasses are provided:
- MLCG:
Multiplicative Linear Congruential Generator.
A reasonable generator for most purposes.
- ACG: Additive Number Generator.
A high quality generator that uses more memory and computation time.
This class assumes that IEEE floating point
representation is used for the floating point numbers and that the integer
and unsigned integer type is exactly 32 bits long.
Example
Motivation
Random numbers are used everywhere, particularly in simulations.
Thrown Exceptions
- AipsError: If a programming error or unexpected numeric size is
detected. Should not occur in normal usage.
To Do
Member Description
virtual ~RNG()
A virtual destructor is needed to ensure that the destructor of derived
classes gets used.
virtual void reset() = 0
Resets the random number generator. After calling this function the random
numbers generated will be the same as if the object had just been
constructed.
virtual uInt asuInt() = 0
Return the 32-random bits as an unsigned integer
Return random bits converted to either a Float or a Double. The returned
value x is in the range 1.0 > x >= 0.0
class ACG : public RNG
Interface
- explicit ACG(uInt seed = 0, Int size = 55)
- virtual ~ACG()
- virtual void reset()
- virtual uInt asuInt()
Review Status
- Date Reviewed:
- yyyy/mm/dd
Prerequisite
- A knowledge of C++, in particular inheritance
- College level mathematics
Etymology
ACG stands for "Additive Congruential Generator"
Synopsis
This class implements the additive number generator as presented in Volume
II of The Art of Computer Programming by Knuth. I have coded the algorithm
and have added the extensions by Andres Nowatzyk of CMU to randomize the
result of algorithm M a bit by using an LCG & a spatial permutation table.
The version presented uses the same constants for the LCG that Andres uses
(chosen by trial & error). The spatial permutation table is the same size
(it is based on word size). This is for 32-bit words.
The auxillary table used by the LCG table varies in size, and is
chosen to be the the smallest power of two which is larger than twice the
size of the state table.
Class ACG is a variant of a Linear Congruential Generator
(Algorithm M) described in Knuth, "Art of Computer Programming, Vol III".
This result is permuted with a Fibonacci Additive Congruential Generator to
get good independence between samples. This is a very high quality random
number generator, although it requires a fair amount of memory for each
instance of the generator.
The constructor takes two parameters: the seed and the size. The seed can
be any number. The performance of the generator depends on having a
distribution of bits through the seed. If you choose a number in the range
of 0 to 31, a seed with more bits is chosen. Other values are
deterministically modified to give a better distribution of bits. This
provides a good random number generator while still allowing a sequence to
be repeated given the same initial seed.
The size parameter determines the size of two tables used in the
generator. The first table is used in the Additive Generator; see the
algorithm in Knuth for more information. In general, this table contains
size integers. The default value, used in the algorithm in Knuth,
gives a table of 55 integers (220 bytes). The table size affects the period
of the generators; smaller values give shorter periods and larger tables
give longer periods. The smallest table size is 7 integers, and the longest
is 98. The size parameter also determines the size of the table
used for the Linear Congruential Generator. This value is chosen implicitly
based on the size of the Additive Congruential Generator table. It is two
powers of two larger than the power of two that is larger than
size. For example, if size is 7, the ACG table
contains 7 integers and the LCG table contains 128 integers. Thus, the
default size (55) requires 55 + 256 integers, or 1244 bytes. The largest
table requires 2440 bytes and the smallest table requires 100 bytes.
Applications that require a large number of generators or applications that
are not so fussy about the quality of the generator may elect to use the
MLCG generator.
This class assumes that the integer and unsigned integer
type is exactly 32 bits long.
Example
Thrown Exceptions
- AipsError: If a programming error or unexpected numeric size is
detected. Should not occur in normal usage.
To Do
Member Description
explicit ACG(uInt seed = 0, Int size = 55)
The constructor allows you to specify seeds. The seed should be a big
random number and size must be between 7 and 98. See the synopsis for more
details.
virtual ~ACG()
The destructor cleans up memory allocated by this class
virtual void reset()
Resets the random number generator. After calling this function the random
numbers generated will be the same as if the object had just been
constructed.
virtual uInt asuInt()
Return the 32-random bits as an unsigned integer
class MLCG : public RNG
Interface
- explicit MLCG(Int seed1 = 0, Int seed2 = 1)
- virtual ~MLCG()
- virtual uInt asuInt()
- virtual void reset()
- Int seed1() const
- void seed1(Int s)
- Int seed2() const
- void seed2(Int s)
- void reseed(Int s1, Int s2)
Review Status
- Date Reviewed:
- yyyy/mm/dd
Prerequisite
- A knowledge of C++, in particular inheritance
- College level mathematics
Etymology
MLCG stands for "Multiplicative Linear Congruential Generator"
Synopsis
The MLCG class implements a Multiplicative Linear
Congruential Generator. In particular, it is an implementation of the
double MLCG described in Efficient and Portable Combined Random Number
Generators by Pierre L'Ecuyer, appearing in Communications of the
ACM, Vol. 31. No. 6. This generator has a fairly long period, and has
been statistically analyzed to show that it gives good inter-sample
independence.
The constructor has two parameters, both of which are seeds for the
generator. As in the ACG generator, both seeds are modified to
give a "better" distribution of seed digits. Thus, you can safely use values
such as 0 or 1 for the seeds. The MLCG
generator used much less state than the ACG generator; only two
integers (8 bytes) are needed for each generator.
This class assumes that the integer and unsigned integer
type is exactly 32 bits long.
Example
Thrown Exceptions
- AipsError: If a programming error or unexpected numeric size is
detected. Should not occur in normal usage.
To Do
Member Description
explicit MLCG(Int seed1 = 0, Int seed2 = 1)
The constructor allows you to specify seeds.
The destructor is trivial
virtual uInt asuInt()
Return the 32-random bits as an unsigned integer
virtual void reset()
Resets the random number generator. After calling this function the random
numbers generated will be the same as if the object had just been
constructed.
Int seed1() const
void seed1(Int s)
Int seed2() const
void seed2(Int s)
void reseed(Int s1, Int s2)
Functions that allow the user to retrieve or change the seed integers. The
seeds returned are not the user supplied values but the values obtained
after some deterministic modification to produce a more uniform bit
distribution.
Types
- BINOMIAL
-
2 parameters. The binomial distribution models successfully drawing
items from a pool. Specify n and p. n is the number of items in the
pool, and p, is the probability of each item being successfully drawn.
It is required that n > 0 and 0 <= p <= 1
- DISCRETEUNIFORM
-
2 parameters. Model a uniform random variable over the closed
interval. Specify the values low and high. The low parameter is the
lowest possible return value and the high parameter is the highest. It
is required that low < high.
- ERLANG
-
2 parameters, mean and variance. It is required that the mean is
non-zero and the variance is positive.
- GEOMETRIC
-
1 parameters, the mean. It is required that 0 <= probability < 1
- HYPERGEOMETRIC
-
2 parameters, mean and variance. It is required that the variance is
positive and that the mean is non-zero and not bigger than the
square-root of the variance.
- NORMAL
-
2 parameters, the mean and variance. It is required that the variance is
positive.
- LOGNORMAL
-
2 parameters, mean and variance. It is required that the supplied
variance is positive and that the mean is non-zero
- NEGATIVEEXPONENTIAL
-
1 parameter, the mean.
- POISSON
-
1 parameter, the mean. It is required that the mean is non-negative
- UNIFORM
-
2 parameters, low and high. Model a uniform random variable over the
closed interval. The low parameter is the lowest possible return value
and the high parameter can never be returned. It is required that low <
high.
- WEIBULL
-
2 parameters, alpha and beta. It is required that the alpha parameter is
not zero.
- UNKNOWN
-
An non-predefined random number distribution
- NUMBER_TYPES
-
Number of distributions
Interface
- virtual ~Random()
- virtual Double operator()() = 0
- RNG* generator()
- void generator(RNG* p)
- static String asString(Random::Types type)
- static Random::Types asType(const String& str)
- static Random* construct(Random::Types type, RNG* gen)
- virtual void setParameters(const Vector<Double>& parms) = 0
- virtual Vector<Double> parameters() const = 0
- virtual Bool checkParameters(const Vector<Double>& parms) const = 0
- static Vector<Double> defaultParameters (Random::Types type)
Protected Members
- Random(RNG* generator)
Review Status
- Date Reviewed:
- yyyy/mm/dd
Prerequisite
- A knowledge of C++, in particular inheritance
- College level mathematics
Synopsis
A random number generator may be declared by first constructing a
RNG object and then a Random. For example,
ACG gen(10, 20);
NegativeExpntl rnd (1.0, &gen);
declares an additive congruential generator with seed 10 and table size 20,
that is used to generate exponentially distributed values with mean of 1.0.
The virtual member Random::operator() is the common way of
extracting a random number from a particular distribution. The base class,
Random does not implement operator(). This is
performed by each of the derived classes. Thus, given the above declaration
of rnd, new random values may be obtained via, for example,
Double nextExpRand = rnd();
Currently, the following subclasses are provided:
Example
Thrown Exceptions
No exceptions are thrown directly from this class.
To Do
Member Description
This enumerator lists all the predefined random number distributions.
A virtual destructor is needed to ensure that the destructor of derived
classes gets used. Not that this destructor does NOT delete the pointer to
the RNG object
virtual Double operator()() = 0
This function returns a random number from the appropriate distribution.
Functions that allow you to access and change the class that generates the
random bits.
Convert the enumerator to a lower-case string.
Convert the string to enumerator. The parsing of the string is case
insensitive. Returns the Random::UNKNOWN value if the string does not
cotrtrespond to any of the enumerators.
static Random* construct(Random::Types type, RNG* gen)
Convert the Random::Type enumerator to a specific object (derived from
Random but upcast to a Random object). Returns a null pointer if the
object could not be constructed. This will occur is the enumerator is
UNKNOWN or NUMBER_TYPES or there is insufficient memory. The caller of
this function is responsible for deleting the pointer.
virtual void setParameters(const Vector<Double>& parms) = 0
virtual Vector<Double> parameters() const = 0
virtual Bool checkParameters(const Vector<Double>& parms) const = 0
These function allow you to manipulate the parameters (mean variance etc.)
of random number distribution. The parameters() function returns the
current value, the setParameters function allows you to change the
parameters and the checkParameters function will return False if the
supplied parameters are not appropriate for the distribution.
returns the default parameters for the specified distribution. Returns an
empty Vector if a non-predifined distribution is used.
Interface
Public Members
- Binomial(RNG* gen, uInt n=1, Double p=0.5)
- virtual ~Binomial()
- virtual Double operator()()
- uInt asInt()
- uInt n() const
- void n(uInt newN)
- void n(Double newN)
- Double p() const
- void p(Double newP)
- virtual void setParameters(const Vector<Double>& parms)
- virtual Vector<Double> parameters() const
- virtual Bool checkParameters(const Vector<Double>& parms) const
Synopsis
The binomial distribution models successfully drawing items from a pool.
n is the number of items in the pool, and p, is the
probability of each item being successfully drawn. The
operator() functions returns an integral value indicating the
number of items actually drawn from the pool. It is possible to get this
same value as an integer using the asInt function.
It is assumed that n > 0 and 0 <= p <= 1 an AipsError
exception thrown if it is not true. The remaining members allow you to read
and set the parameters.
Example
Thrown Exceptions
- AipsError: if bad values for the arguments are given, as specified
above.
To Do
Member Description
Binomial(RNG* gen, uInt n=1, Double p=0.5)
Construct a random number generator for a binomial distribution. The first
argument is a class that produces random bits. This pointer is NOT taken
over by this class and the user is responsible for deleting it. The second
and third arguments are the parameters are the Binomial distribution as
described in the synopsis.
The destructor is trivial
Returns a value from the Binomial distribution. The returned value is a
non-negative integer and using the asInt function bypasses the conversion
to a floating point number.
uInt n() const
void n(uInt newN)
void n(Double newN)
Double p() const
void p(Double newP)
Functions that allow you to query and change the parameters of the
binomial distribution.
These function allow you to manipulate the parameters (n & p) described
above through the base class. The Vectors must always be of length two.
Interface
- DiscreteUniform(RNG* gen, Int low=-1, Int high=1)
- virtual ~DiscreteUniform()
- virtual Double operator()()
- Int asInt()
- Int low() const
- void low(Int x)
- Int high() const
- void high(Int x)
- void range(Int low, Int high)
- virtual void setParameters(const Vector<Double>& parms)
- virtual Vector<Double> parameters() const
- virtual Bool checkParameters(const Vector<Double>& parms) const
Private Members
- static Double calcDelta(Int low, Int high)
Synopsis
The DiscreteUniform class implements a quantized uniform random
variable over the closed interval ranging from [low..high]. The
low parameter is the lowest possible return value and the
high parameter is the highest. The operator()
functions returns a value from this distribution. It is possible to get this
same value as an integer using the asInt function.
It is assumed that low limit is less than the high limit and an AipsError
exception thrown if this is not true. The remaining members allow you to
read and set the parameters.
Example
Thrown Exceptions
- AipsError: if bad values for the arguments are given, as specified
above.
To Do
Member Description
Construct a random number generator for a discrete uniform
distribution. The first argument is a class that produces random
bits. This pointer is NOT taken over by this class and the user is
responsible for deleting it. The second and third arguments define the
range of possible return values for this distribution as described in the
synopsis.
The destructor is trivial
Returns a value from the discrete uniform distribution. The returned
value is a integer and using the asInt function bypasses the conversion to
a floating point number.
Int low() const
void low(Int x)
Int high() const
void high(Int x)
void range(Int low, Int high)
Functions that allow you to query and change the parameters of the
discrete uniform distribution.
These function allow you to manipulate the parameters (low & high)
described above through the base class. The Vectors must always be of
length two.
static Double calcDelta(Int low, Int high)
Interface
Public Members
- Erlang(RNG* gen, Double mean=1.0, Double variance=1.0)
- virtual ~Erlang()
- virtual Double operator()()
- Double mean() const
- void mean(Double x)
- Double variance() const
- void variance(Double x)
- virtual void setParameters(const Vector<Double>& parms)
- virtual Vector<Double> parameters() const
- virtual Bool checkParameters(const Vector<Double>& parms) const
Private Members
- void setState()
Synopsis
The Erlang class implements an Erlang distribution with mean
mean and variance variance.
It is assumed that the mean is non-zero and the variance is positive an
AipsError exception thrown if this is not true. The remaining members allow
you to read and set the parameters.
Example
Thrown Exceptions
- AipsError: if bad values for the arguments are given, as specified
above.
To Do
Member Description
Erlang(RNG* gen, Double mean=1.0, Double variance=1.0)
Construct a random number generator for an Erlang distribution. The first
argument is a class that produces random bits. This pointer is NOT taken
over by this class and the user is responsible for deleting it. The second
and third arguments define the parameters for this distribution as
described in the synopsis.
The destructor is trivial
Returns a value from the Erlang distribution.
Double mean() const
void mean(Double x)
Double variance() const
void variance(Double x)
Functions that allow you to query and change the parameters of the
discrete uniform distribution.
These function allow you to manipulate the parameters (mean & variance)
described above through the base class. The Vectors must always be of
length two.
Interface
Public Members
- Geometric(RNG* gen, Double probability=0.5)
- virtual ~Geometric()
- virtual Double operator()()
- uInt asInt()
- Double probability() const
- void probability(Double x)
- virtual void setParameters(const Vector<Double>& parms)
- virtual Vector<Double> parameters() const
- virtual Bool checkParameters(const Vector<Double>& parms) const
Synopsis
The Geometric class implements a discrete geometric distribution.
The probability is the only parameter. The operator()
functions returns an non-negative integral value indicating the number of
uniform random samples actually drawn before one is obtained that is larger
than the given probability. To get this same value as an integer use the
asInt function.
It is assumed that the probability is between zero and one
(0 <= probability < 1) and and AipsError exception thrown if this
is not true. The remaining function allow you to read and set the
parameters.
Example
Thrown Exceptions
- AipsError: if bad values for the arguments are given, as specified
above.
To Do
Member Description
Geometric(RNG* gen, Double probability=0.5)
Construct a random number generator for a geometric uniform
distribution. The first argument is a class that produces random
bits. This pointer is NOT taken over by this class and the user is
responsible for deleting it. The second argument defines the range of
possible return values for this distribution as described in the synopsis.
The destructor is trivial
Returns a value from the geometric uniform distribution. The returned
value is a non-negative integer and using the asInt function bypasses the
conversion to a floating point number.
Functions that allow you to query and change the parameters of the
geometric uniform distribution.
These function allow you to manipulate the parameter (probability)
described above through the base class. The Vectors must always be of
length one.
Interface
- HyperGeometric(RNG* gen, Double mean=0.5, Double variance=1.0)
- virtual ~HyperGeometric()
- virtual Double operator()()
- Double mean() const
- void mean(Double x)
- Double variance() const
- void variance(Double x)
- virtual void setParameters(const Vector<Double>& parms)
- virtual Vector<Double> parameters() const
- virtual Bool checkParameters(const Vector<Double>& parms) const
Private Members
- void setState()
Synopsis
The HyperGeometric class implements the hypergeometric
distribution. The mean and variance are the
parameters of the distribution. The operator() functions returns
a value from this distribution
It is assumed the variance is positive and that the mean is non-zero and not
bigger than the square-root of the variance. An AipsError exception is
thrown if this is not true. The remaining members allow you to read and set
the parameters.
Example
Thrown Exceptions
- AipsError: if bad values for the arguments are given, as specified
above.
To Do
Member Description
HyperGeometric(RNG* gen, Double mean=0.5, Double variance=1.0)
Construct a random number generator for an hypergeometric
distribution. The first argument is a class that produces random
bits. This pointer is NOT taken over by this class and the user is
responsible for deleting it. The second and third arguments define the
parameters for this distribution as described in the synopsis.
The destructor is trivial
Returns a value from the hypergeometric distribution.
Double mean() const
void mean(Double x)
Double variance() const
void variance(Double x)
Functions that allow you to query and change the parameters of the
hypergeometric distribution.
These function allow you to manipulate the parameters (mean & variance)
described above through the base class. The Vectors must always be of
length two.
Interface
Public Members
- Normal(RNG* gen, Double mean=0.0, Double variance=1.0)
- virtual ~Normal()
- virtual Double operator()()
- virtual Double mean() const
- virtual void mean(Double x)
- virtual Double variance() const
- virtual void variance(Double x)
- virtual void setParameters(const Vector<Double>& parms)
- virtual Vector<Double> parameters() const
- virtual Bool checkParameters(const Vector<Double>& parms) const
Synopsis
The Normal class implements the normal or Gaussian distribution.
The mean and variance are the parameters of the
distribution. The operator() functions returns a value from this
distribution
It is assumed that the supplied variance is positive and an AipsError
exception is thrown if this is not true. The remaining members allow you to
read and set the parameters. The LogNormal class is derived from
this one.
Example
Thrown Exceptions
- AipsError: if bad values for the arguments are given, as specified
above.
To Do
Member Description
Normal(RNG* gen, Double mean=0.0, Double variance=1.0)
Construct a random number generator for a normal distribution. The first
argument is a class that produces random bits. This pointer is NOT taken
over by this class and the user is responsible for deleting it. The second
and third arguments define the parameters for this distribution as
described in the synopsis.
The destructor is trivial
Returns a value from the normal distribution.
virtual Double mean() const
virtual void mean(Double x)
virtual Double variance() const
virtual void variance(Double x)
Functions that allow you to query and change the parameters of the
normal distribution.
These function allow you to manipulate the parameters (mean & variance)
described above through the base class. The Vectors must always be of
length two.
Interface
- LogNormal(RNG* gen, Double mean=1.0, Double variance=1.0)
- virtual ~LogNormal()
- virtual Double operator()()
- virtual Double mean() const
- virtual void mean(Double x)
- virtual Double variance() const
- virtual void variance(Double x)
- virtual void setParameters(const Vector<Double>& parms)
- virtual Vector<Double> parameters() const
- virtual Bool checkParameters(const Vector<Double>& parms) const
Private Members
- void setState()
Synopsis
The LogNormal class implements the logaraithmic normal
distribution. The mean and variance are the
parameters of the distribution. The operator() functions returns
a value from this distribution
It is assumed that the supplied variance is positive and an AipsError
exception is thrown if this is not true. The remaining members allow you to
read and set the parameters.
Example
Thrown Exceptions
- AipsError: if bad values for the arguments are given, as specified
above.
To Do
Member Description
LogNormal(RNG* gen, Double mean=1.0, Double variance=1.0)
Construct a random number generator for a log-normal distribution. The
first argument is a class that produces random bits. This pointer is NOT
taken over by this class and the user is responsible for deleting it. The
second and third arguments define the parameters for this distribution as
described in the synopsis.
The destructor is trivial
Returns a value from the log-normal distribution.
virtual Double mean() const
virtual void mean(Double x)
virtual Double variance() const
virtual void variance(Double x)
Functions that allow you to query and change the parameters of the
log-normal distribution.
These function allow you to manipulate the parameters (mean & variance)
described above through the base class. The Vectors must always be of
length two.
Interface
Public Members
- NegativeExpntl(RNG* gen, Double mean=1.0)
- virtual ~NegativeExpntl()
- virtual Double operator()()
- Double mean() const
- void mean(Double x)
- virtual void setParameters(const Vector<Double>& parms)
- virtual Vector<Double> parameters() const
- virtual Bool checkParameters(const Vector<Double>& parms) const
Synopsis
The NegativeExpntl class implements a negative exponential
distribution. The mean parameter, is the only parameter of this
distribution. The operator() functions returns a value from this
distribution. The remaining members allow you to inspect and change the
mean.
Example
Thrown Exceptions
- No exceptions are thrown by this class.
To Do
Member Description
Construct a random number generator for a negative exponential
distribution. The first argument is a class that produces random
bits. This pointer is NOT taken over by this class and the user is
responsible for deleting it. The second argument defines the parameters
for this distribution as described in the synopsis.
The destructor is trivial
Returns a value from the negative exponential distribution.
Double mean() const
void mean(Double x)
Functions that allow you to query and change the parameters of the
negative exponential distribution.
These function allow you to manipulate the parameters (mean)
described above through the base class. The Vectors must always be of
length one.
Interface
- Poisson(RNG* gen, Double mean=0.0)
- virtual ~Poisson()
- virtual Double operator()()
- uInt asInt()
- Double mean() const
- void mean(Double x)
- virtual void setParameters(const Vector<Double>& parms)
- virtual Vector<Double> parameters() const
- virtual Bool checkParameters(const Vector<Double>& parms) const
Synopsis
The Poisson class implements a Poisson distribution. The
mean parameter, is the only parameter of this distribution. The
operator() functions returns a value from this distribution. The
remaining members allow you to inspect and change the mean.
It is assumed that the supplied mean is non-negative and an AipsError
exception is thrown if this is not true. The remaining members allow you to
read and set the parameters.
Example
Thrown Exceptions
- No exceptions are thrown by this class.
To Do
Member Description
Poisson(RNG* gen, Double mean=0.0)
Construct a random number generator for a Poisson distribution. The first
argument is a class that produces random bits. This pointer is NOT taken
over by this class and the user is responsible for deleting it. The second
argument defines the parameters for this distribution as described in the
synopsis.
The destructor is trivial
Returns a value from the Poisson distribution. The returned value is a
non-negative integer and using the asInt function bypasses the conversion
to a floating point number.
Double mean() const
void mean(Double x)
Functions that allow you to query and change the parameters of the
Poisson distribution.
These function allow you to manipulate the parameters (mean)
described above through the base class. The Vectors must always be of
length one.
Interface
- Uniform(RNG* gen, Double low=-1.0, Double high=1.0)
- virtual ~Uniform()
- virtual Double operator()()
- Double low() const
- void low(Double x)
- Double high() const
- void high(Double x)
- void range(Double low, Double high)
- virtual void setParameters(const Vector<Double>& parms)
- virtual Vector<Double> parameters() const
- virtual Bool checkParameters(const Vector<Double>& parms) const
Private Members
- static Double calcDelta(Double low, Double high)
Synopsis
The Uniform class implements a uniform random variable over the
copen interval ranging from [low..high). The low
parameter is the lowest possible return value and the high
parameter can never be returned. The operator() functions
returns a value from this distribution.
It is assumed that low limit is less than the high limit and an AipsError
exception is thrown if this is not true. The remaining members allow you to
read and set the parameters.
Example
Thrown Exceptions
- AipsError: if bad values for the arguments are given, as specified
above.
To Do
Member Description
Uniform(RNG* gen, Double low=-1.0, Double high=1.0)
Construct a random number generator for a uniform distribution. The first
argument is a class that produces random bits. This pointer is NOT taken
over by this class and the user is responsible for deleting it. The
remaining arguments define the parameters for this distribution as
described in the synopsis.
The destructor is trivial
Returns a value from the uniform distribution.
Double low() const
void low(Double x)
Double high() const
void high(Double x)
void range(Double low, Double high)
Functions that allow you to query and change the parameters of the
uniform distribution.
These function allow you to manipulate the parameters (low & high)
described above through the base class. The Vectors must always be of
length two.
static Double calcDelta(Double low, Double high)
Interface
Public Members
- Weibull(RNG* gen, Double alpha=1.0, Double beta=1.0)
- virtual ~Weibull()
- virtual Double operator()()
- Double alpha() const
- void alpha(Double x)
- Double beta() const
- void beta(Double x)
- virtual void setParameters(const Vector<Double>& parms)
- virtual Vector<Double> parameters() const
- virtual Bool checkParameters(const Vector<Double>& parms) const
Private Members
- void setState()
Synopsis
The Weibull class implements a weibull distribution with
parameters alpha and beta. The first parameter to the
class constructor is alpha, and the second parameter is
beta. It is assumed that the alpha parameter is not zero and an
AipsError exception is thrown if this is not true. The remaining members
allow you to read and set the parameters.
Example
Thrown Exceptions
- AipsError: if bad values for the arguments are given, as specified
above.
To Do
Member Description
Weibull(RNG* gen, Double alpha=1.0, Double beta=1.0)
Construct a random number generator for a uniform distribution. The first
argument is a class that produces random bits. This pointer is NOT taken
over by this class and the user is responsible for deleting it. The
remaining arguments define the parameters for this distribution as
described in the synopsis.
The destructor is trivial
Returns a value from the Weiball distribution.
Double alpha() const
void alpha(Double x)
Double beta() const
void beta(Double x)
Functions that allow you to query and change the parameters of the
Weiball distribution.
These function allow you to manipulate the parameters (alpha & beta)
described above through the base class. The Vectors must always be of
length two.