cauldron

Here is my version of this concept, I tried to keep it as simple as possible: https://github.com/camel-cdr/cauldron/blob/main/cauldron/str...

That page ends with "This is the first efficient algorithm for generating random uniform floating-point numbers that can access the entire range of floating point outputs with correct probabilities". I am very skeptical. The same basic idea is described here [1] (though without any pretty pictures, but with a link to working code), and I know others have implemented the same insight [2]. This seems like the kind of thing that is reinvented every time some who cares about random numbers learns how IEEE 754 works. [1] http://mumble.net/~campbell/2014/04/28/uniform-random-float [2] https://github.com/camel-cdr/cauldron/blob/a673553dd7925b0f1...

I've written an algorithm that generates a uniform random float in the range [a,b] that can produce every representable floating-point value with a probability proportional to the covered real number range*: https://github.com/camel-cdr/cauldron/blob/main/cauldron/ran... * Well, almost. I messed up the probability around subnormals slightly and haven't gotten around to fixing it yet. Still, the algorithm it self should works for all other values and it was measurably more accurate than the regular algorithm. In terms of performance it is 10x slower compared to the regular implementation of `(randu32(x)>>8)*(1.0f/(1<<24))` on my Zen1 desktop.

The holy grail of random float generation is a function that takes two bounds and can generate ALL representable floating point numbers within the given bounds with the proper distribution, here uniform (and does so efficiently). I've written such an implementation with explanations [0], but it doesn't handle subnormals correctly. I've yet to find the time to revisit the problem. [0] https://github.com/camel-cdr/cauldron/blob/main/cauldron/ran...

I've previously written an algorithm that generates random floats in any [a,b], which can generate all possible floating point values, including subnormals, with the proper probability, and does so quickly for any choice of a and b. [0] [0] https://github.com/camel-cdr/cauldron/blob/main/cauldron/ran...

Yeah, the amount of times I've seen `rand() % range` and other non-uniform distributions is staggering. I've actually held a presentation on the topic, with a chapter on generating uniform floats [1] There I also describe a simplified algorithm for generating uniform floats where every representable floating point value can occur with the appropriate probability. I'm still not 100% sure that my implementation is correct, but I did all I could think of to test it [2] [1] https://youtube.com/watch?v=VHJUlRiRDCY&t=2774s [2] https://github.com/camel-cdr/cauldron/blob/main/cauldron/ran...

I found that instead of adding format specifiers, one can create a construct that uses occurrences of '\0' in strings to insert values: FMT_BEGIN("a + b = \0 + \0 = \0\n") { FMT(float, (a)); FMT(float, (b)); FMT(float, (a + b)); } FMT_END; FMT_BEGIN("x = \0 = 0x\0 = 0b\0\na = \0\nb = \0\n") { FMT(uint, (x)); FMT(uint_base, ((unsigned)x, 16, "0123456789abcdef")); FMT(uint_base, ((unsigned)x, 2, "01")); FMT(Vec3, (a)); FMT(Vec3, (b)); } FMT_END; The major advantage here is that you don't need to parse a dsl, and you can still have formatting options. A final api would probably use automatic compound literal struct arguments to implement default arguments with names parameters. Type detection should also be possible, although you would need to register all print functions in a global macro. This is just a p