Added specification for RandomUniform operation.

[popovaan]

Details:

• Specification of the operation RandomUniform.

Tickets:

• 56591

Algorithm description

RandomUniform operation generates random numbers from a uniform distribution in the range [minval, maxval).
The generation algorithm is based on underlying random integer generator that uses Philox algorithm. Philox algorithm
is counter based pseudo random generator, which produces uint32 values. Single invocation of Philox algorithm returns
four result random values, depending on the given key and counter values. Key and counter are initialized
with seed and seed2 attributes respectively.

key = seed
counter = seed2

Link to the original paper [Parallel Random Numbers: As Easy as 1, 2, 3]
(https://www.thesalmons.org/john/random123/papers/random123sc11.pdf)

The result of Philox is calculated by applying a fixed number of key and counter updating, so-called "rounds".
This implementation uses 4x32_10 version of Philox algorithm, where number of rounds = 10.

Suppose we have n which determines n-th 4 elements of random sequence.
In each round key, counter and n are splitted to pairs of uint32 values:

where cast_to_uint32 - static cast to uint32, value - uint64 input value, L, R - uint32
result values, >> - bitwise right shift.

Then n and counter are updated with the following formula:

where - bitwise xor, k = R_key for updating counter, k = L_key for updating n,
M = 0xD2511F53 for updating n, M = 0xCD9E8D57 for updating counter.

After each round key is raised by summing with another pair of const values:

L += 0x9E3779B9
R += 0xBB67AE85

Values L'_n, R'_n, L'_counter, R'_counter are resulting four random numbers.

Float values between [0..1) are obtained from 32-bit integers by the following rules.

Float16 is formatted as follows: sign(1 bit) exponent(5 bits) mantissa(10 bits). The value is interpreted
using following formula:

so to obtain float16 values sign, exponent and mantissa are set as follows:

sign = 0
exponent = 15 - representation of a zero exponent.
mantissa = 10 right bits from generated uint32 random value.

So the resulting float16 value is:

x_uint16 = x // Truncate the upper 16 bits.
val = ((exponent << 10) | x_uint16 & 0x3ffu) - 1.0,

where x is uint32 generated random value.

Float32 is formatted as follows: sign(1 bit) exponent(8 bits) mantissa(23 bits). The value is interpreted
using following formula:

so to obtain float values sign, exponent and mantissa are set as follows:

sign = 0
exponent = 127 - representation of a zero exponent.
mantissa = 23 right bits from generated uint32 random value.

So the resulting float value is:

val = ((exponent << 23) | x & 0x7fffffu) - 1.0,

where x is uint32 generated random value.

Double is formatted as follows: sign(1 bit) exponent(11 bits) mantissa(52 bits). The value is interpreted
using following formula:

so to obtain double values sign, exponent and mantissa are set as follows:

sign = 0
exponent = 1023 - representation of a zero exponent.
mantissa = 52 right bits from two concatenated uint32 values from random integer generator.

So the resulting double is obtained as follows:

mantissa_h = x0 & 0xfffffu;  // upper 20 bits of mantissa
mantissa_l = x1;             // lower 32 bits of mantissa
mantissa = (mantissa_h << 32) | mantissa_l;
val = ((exponent << 52) | mantissa) - 1.0,

where x0, x1 are uint32 generated random values.

To obtain a value in a specified range each value is processed with the following formulas:

For float values:

where x is random float or double value between [0..1).

For integer values:

where x is uint32 random value.

[pavel-esir]

Left one comment other looks good to me

[lazarevevgeny]

Add plugin owners to the review

[lazarevevgeny]

Please, add the rendered version of formulas to the PR description.

[lazarevevgeny]

Looks good. Let's pass the review from the technical writers and then merge the spec.