@Namespace(value="cv") @NoOffset @Properties(inherit=opencv_core.class) public class RNG extends Pointer
Random number generator. It encapsulates the state (currently, a 64-bit
integer) and has methods to return scalar random values and to fill
arrays with random values. Currently it supports uniform and Gaussian
(normal) distributions. The generator uses Multiply-With-Carry
algorithm, introduced by G. Marsaglia (
Pointer.CustomDeallocator, Pointer.Deallocator, Pointer.NativeDeallocator, Pointer.ReferenceCounter
Modifier and Type | Field and Description |
---|---|
static int |
NORMAL
enum cv::RNG::
|
static int |
UNIFORM
enum cv::RNG::
|
Constructor and Description |
---|
RNG()
\brief constructor
|
RNG(int state)
\overload
|
RNG(Pointer p)
Pointer cast constructor.
|
Modifier and Type | Method and Description |
---|---|
void |
_fill(GpuMat mat,
int distType,
GpuMat a,
GpuMat b) |
void |
_fill(GpuMat mat,
int distType,
GpuMat a,
GpuMat b,
boolean saturateRange) |
void |
_fill(Mat mat,
int distType,
Mat a,
Mat b) |
void |
_fill(Mat mat,
int distType,
Mat a,
Mat b,
boolean saturateRange)
\brief Fills arrays with random numbers.
|
void |
_fill(UMat mat,
int distType,
UMat a,
UMat b) |
void |
_fill(UMat mat,
int distType,
UMat a,
UMat b,
boolean saturateRange) |
int |
apply()
\brief returns a random integer sampled uniformly from [0, N).
|
int |
apply(int N)
\overload
|
byte |
asByte()
Each of the methods updates the state using the MWC algorithm and
returns the next random number of the specified type.
|
double |
asDouble()
\overload
|
float |
asFloat()
\overload
|
int |
asInt()
\overload
|
short |
asShort()
\overload
|
boolean |
equals(RNG other) |
double |
gaussian(double sigma)
\brief Returns the next random number sampled from the Gaussian distribution
|
int |
next()
The method updates the state using the MWC algorithm and returns the
next 32-bit random number.
|
int |
state() |
RNG |
state(int setter) |
double |
uniform(double a,
double b)
\overload
|
float |
uniform(float a,
float b)
\overload
|
int |
uniform(int a,
int b)
\brief returns uniformly distributed integer random number from [a,b) range
|
address, asBuffer, asByteBuffer, availablePhysicalBytes, calloc, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, formatBytes, free, hashCode, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, parseBytes, physicalBytes, position, position, put, realloc, referenceCount, releaseReference, retainReference, setNull, sizeof, toString, totalBytes, totalPhysicalBytes, withDeallocator, zero
public static final int UNIFORM
public static final int NORMAL
public RNG(Pointer p)
Pointer.Pointer(Pointer)
.public RNG()
These are the RNG constructors. The first form sets the state to some pre-defined value, equal to 2\*\*32-1 in the current implementation. The second form sets the state to the specified value. If you passed state=0 , the constructor uses the above default value instead to avoid the singular random number sequence, consisting of all zeros.
@Cast(value="unsigned") public int next()
@Cast(value="uchar") @Name(value="operator uchar") public byte asByte()
@Cast(value="unsigned") @Name(value="operator ()") public int apply()
The methods transform the state using the MWC algorithm and return the next random number. The first form is equivalent to RNG::next . The second form returns the random number modulo N , which means that the result is in the range [0, N) .
@Cast(value="unsigned") @Name(value="operator ()") public int apply(@Cast(value="unsigned") int N)
N
- upper non-inclusive boundary of the returned random number.public int uniform(int a, int b)
The methods transform the state using the MWC algorithm and return the next uniformly-distributed random number of the specified type, deduced from the input parameter type, from the range [a, b) . There is a nuance illustrated by the following sample:
{.cpp}
RNG rng;
// always produces 0
double a = rng.uniform(0, 1);
// produces double from [0, 1)
double a1 = rng.uniform((double)0, (double)1);
// produces float from [0, 1)
float b = rng.uniform(0.f, 1.f);
// produces double from [0, 1)
double c = rng.uniform(0., 1.);
// may cause compiler error because of ambiguity:
// RNG::uniform(0, (int)0.999999)? or RNG::uniform((double)0, 0.99999)?
double d = rng.uniform(0, 0.999999);
The compiler does not take into account the type of the variable to which you assign the result of RNG::uniform . The only thing that matters to the compiler is the type of a and b parameters. So, if you want a floating-point random number, but the range boundaries are integer numbers, either put dots in the end, if they are constants, or use explicit type cast operators, as in the a1 initialization above.
a
- lower inclusive boundary of the returned random number.b
- upper non-inclusive boundary of the returned random number.public float uniform(float a, float b)
public double uniform(double a, double b)
@Name(value="fill") public void _fill(@ByVal Mat mat, int distType, @ByVal Mat a, @ByVal Mat b, @Cast(value="bool") boolean saturateRange)
mat
- 2D or N-dimensional matrix; currently matrices with more than
4 channels are not supported by the methods, use Mat::reshape as a
possible workaround.distType
- distribution type, RNG::UNIFORM or RNG::NORMAL.a
- first distribution parameter; in case of the uniform
distribution, this is an inclusive lower boundary, in case of the normal
distribution, this is a mean value.b
- second distribution parameter; in case of the uniform
distribution, this is a non-inclusive upper boundary, in case of the
normal distribution, this is a standard deviation (diagonal of the
standard deviation matrix or the full standard deviation matrix).saturateRange
- pre-saturation flag; for uniform distribution only;
if true, the method will first convert a and b to the acceptable value
range (according to the mat datatype) and then will generate uniformly
distributed random numbers within the range [saturate(a), saturate(b)),
if saturateRange=false, the method will generate uniformly distributed
random numbers in the original range [a, b) and then will saturate them,
it means, for example, that
theRNG().fill(mat_8u, RNG::UNIFORM, -DBL_MAX, DBL_MAX) will likely
produce array mostly filled with 0's and 255's, since the range (0, 255)
is significantly smaller than [-DBL_MAX, DBL_MAX).
Each of the methods fills the matrix with the random values from the specified distribution. As the new numbers are generated, the RNG state is updated accordingly. In case of multiple-channel images, every channel is filled independently, which means that RNG cannot generate samples from the multi-dimensional Gaussian distribution with non-diagonal covariance matrix directly. To do that, the method generates samples from multi-dimensional standard Gaussian distribution with zero mean and identity covariation matrix, and then transforms them using transform to get samples from the specified Gaussian distribution.
@Name(value="fill") public void _fill(@ByVal Mat mat, int distType, @ByVal Mat a, @ByVal Mat b)
@Name(value="fill") public void _fill(@ByVal UMat mat, int distType, @ByVal UMat a, @ByVal UMat b, @Cast(value="bool") boolean saturateRange)
@Name(value="fill") public void _fill(@ByVal UMat mat, int distType, @ByVal UMat a, @ByVal UMat b)
@Name(value="fill") public void _fill(@ByVal GpuMat mat, int distType, @ByVal GpuMat a, @ByVal GpuMat b, @Cast(value="bool") boolean saturateRange)
@Name(value="fill") public void _fill(@ByVal GpuMat mat, int distType, @ByVal GpuMat a, @ByVal GpuMat b)
public double gaussian(double sigma)
sigma
- standard deviation of the distribution.
The method transforms the state using the MWC algorithm and returns the next random number from the Gaussian distribution N(0,sigma) . That is, the mean value of the returned random numbers is zero and the standard deviation is the specified sigma .
public RNG state(int setter)
Copyright © 2020. All rights reserved.