Warp <war### [at] tagpovrayorg> wrote:
> I have discussed with the team about the idea of adding alternative,
> higher-quality random number generators to POV-Ray 3.7. The current generator
> would be kept for backwards compatibility, but alternatives would be offered.
>
>   The only thing which is a bit open is the exact syntax for this. So far
> this is the best idea:
>
>   Enhance seed() so that it will take an optional second parameter, which
> would specify the RNG algorithm used. It would default to the current RNG.
> The rand() function would remain unchanged (internally it smartly selects
> the proper RNG from the type of seed given to it). In other words, you would
> be able to do, for example, like this:
>
> #declare S1 = seed(1234); // Use the current RNG
> #declare S2 = seed(1234, 1); // Identical to the above.
> #declare S3 = seed(1234, 2); // Use second RNG algorithm.
>
>   Additional algorithms might be added in the future. As mentioned, rand()
> would be unchanged, so its usage would be the same:
>
> #declare RandomValue1 = rand(S1);
> #declare RandomValue2 = rand(S3);
>
>   The current RNG uses a 32-bit seed, so a single parameter to seed() is
> enough to get all possible streams. However, higher-quality random number
> generators usually support much longer seeds, so it would be possible to
> choose among a vastly larger amount of RNG streams. Thus it would be very
> nice if larger seeds could be specified.
>
>   The problem here is one of syntax. How to do this? Here are the ideas
> so far:
>
> 1) Simply don't support seeds larger than 32-bit. This would work, but would
>    be a bit of a bummer because the capabilities of higher-quality RNGs
>    wouldn't be fully utilized.
>
>    Alternatively, since seed() actually takes a (64-bit) float rather than
>    a 32-bit integer, the seed range could be somewhat enlarged by taking
>    the entire float range into account. This would allow using seeds of
>    about 52 bits. (But it's still a long shot from the thousands of bits
>    supported by higher-quality RNGs.)
>
> 2) Make it possible to give either a regular float (as now), or an array
>    of floats as the first parameter of seed(). This way larger seeds can
>    be specified as an array.
>
>    While a bit cumbersome, it's not as bad as it may sound at first, because
>    it's possible to do eg. this:
>
>      #declare S = seed(array[4] { 1, 2, 3, 4 }, 2);
>
>    It would still be nicer if something less cumbersome could be used,
>    though...
>
> 3) Use an alternative function for long seeds. For example:
>
>      #declare S = longseed(2, 1, 2, 3, 4);
>
>    (where the first parameter specifies the RNG type used.)
>
>    One small cosmetic problem with this is, however, that it's a bit
>    inconsistent with the seed() function. seed() takes the RNG type as
>    the second parameter, while longseed() would take it as the first
>    parameter. This can be a bit confusing.
>
> 4) Create an entirely new syntax for specifying a group of values. This,
>    however, would be laborious and should preferably be avoided.
>
>
>   Opinions and additional ideas will be appreciated.
>
> --
>                                                           - Warp

Offhand, if the length of the array of floats that the higher quality RNG
requires is less than or equal to 5, could the existing vector syntax be used?
Of course, feeding a vector to the seed() function would implicitly select the
better RNG:
#declare S1 = seed(1234);         // Use the current RNG
#declare S2 = seed(1234, 1);      // Identical to the above.
#declare S3 = seed(<1,2,3,4>, 2); // Use second RNG algorithm.
#declare S4 = seed(<1,2,3,4>);    // short hand for second RNG algorithm,
                                  //  same as above

Or something.

-Reactor

Post a reply to this message