Should Raylib provide a function to generate random floats or doubles?

[barodapride]

Hi, I'm just wondering why Raylib provides a method to get a random int but doesn't provide something similar for random floats or doubles.

I understand it might be easier to provide a random int based on a seed value but if there was a pull request for a random float generator that was solidly implemented would it get rejected? Providing a way to get random floats and doubles seems within the scope of Raylib given that it's so common in game development and Raylib already provides a way to generate random ints.

[orcmid]

@barodapride

Hi, I'm just wondering why Raylib provides a method to get a random int but doesn't provide something similar for random floats or doubles.

What exactly would be the API for a random double generator, including initiation and establishing boundaries?

As a curiosity, what is an example of such usage in game development?

[raysan5]

@barodapride I think it can be managed on user side with the already provided functions.

[barodapride]

It can be managed on the user side but why not provide it out of the box? Here's what I'm doing.

`
#include <limits.h>
#include "raylib.h"

// Returns a random float between 0 and 1.0f (inclusive)
float getRandomFloat() {
return static_cast(GetRandomValue(0, INT_MAX)) / static_cast(INT_MAX);
}

// Returns a random float between min and max (inclusive)
float getRandomFloat(float min, float max) {
return min + (max - min) * getRandomFloat();
}
`

This generates a random float using the seed from Raylib since it's derived from GetRandomValue. You could say the 'resolution' of the float is limited by INT_MAX but practically speaking would anybody care about that? I would guess the vast majority of Raylib users would just use the Raylib provided function instead of implementing something different but I'm open to reasons why this would not be a good idea.

[orcmid]

@barodapride

// Returns a random float between 0 and 1.0f (inclusive)

float getRandomFloat() { return static_cast(GetRandomValue(0, INT_MAX)) / static_cast(INT_MAX); }

// Returns a random float between min and max (inclusive)

 float getRandomFloat(float min, float max) { return min + (max - min) * getRandomFloat(); } 

1. In the first getRandomFloat(), the divisor should be (INTMAX+1) since that is the size of the range. A safe way to get that is to use (INTMAX + 1.0f) though. The result is never 1.0, so the inclusive claim is incorrect.

2. I don't understand the use of the same name for both functions.

3. As well as I can determine, static_cast is a C++ feature and I don't understand its employment here even so.

A consideration/concern has to do with the desired/understood granularity of the first result. That is, what is the desired epsilon between adjacent possible values, since it is no longer simply "1". Is it important to know that it's 1.0/(INTMAX+1.0) under the assumption that float precision is that good? That's a relevant question in the second form as well, but even more difficult to characterize. I am assuming that some degree of smoothness is wanted.

In any event, I concur with @raysan5 that there should be no attempt to have this as a companion of raylib's GetRandomValue().

[barodapride]

@barodapride

// Returns a random float between 0 and 1.0f (inclusive)

float getRandomFloat() { return static_cast(GetRandomValue(0, INT_MAX)) / static_cast(INT_MAX); }

// Returns a random float between min and max (inclusive)

 float getRandomFloat(float min, float max) { return min + (max - min) * getRandomFloat(); } 

1. In the first getRandomFloat(), the divisor should be (INTMAX+1) since that is the size of the range. A safe way to get that is to use (INTMAX + 1.0f) though. The result is never 1.0, so the inclusive claim is incorrect.
2. I don't understand the use of the same name for both functions.
3. As well as I can determine, static_cast is a C++ feature and I don't understand its employment here even so.

A consideration/concern has to do with the desired/understood granularity of the first result. That is, what is the desired epsilon between adjacent possible values, since it is no longer simply "1". Is it important to know that it's 1.0/(INTMAX+1.0) under the assumption that float precision is that good? That's a relevant question in the second form as well, but even more difficult to characterize. I am assuming that some degree of smoothness is wanted.

In any event, I concur with @raysan5 that there should be no attempt to have this as a companion of raylib's GetRandomValue().

I think it's basically correct as it is - for example if GetRandomValue(0, 10) returns 10 (just using 10 instead of INT_MAX for ease of reading) it would cast to a float 10.0f and divide by a float 10.0f which would result in a 1.0f.

In any case it's just an idea of how to implement it, maybe it could use one less static cast or the naming of the functions can be different but if it's not going to be accepted it doesn't matter.

I am just coming from Unity where I used Random.value all the time to quickly get a random float from 0f - 1f. And there are also other convenience methods to get floats in a given range. But maybe in c++ world people prefer to have their own library of such things.

[raysan5]

It can be managed on the user side but why not provide it out of the box?

Because it adds a maintenance cost to raylib that I prefer to avoid.