Generate Float Random Values (also negative) - c

Question

How can i generate float random values in C? (also negative)

Answer 1

In general to generate random numbers from an arbitrary distribution you'd first generate uniform random numbers and then pass them to the inverse of the cumulative distribution function.
Assume for example that you want random numbers with uniform distribution on the interval [-10.0, 10.0] and all you've got is random numbers from [0.0, 1.0]. Cumulative distribution function of the uniform distribution on [-10.0, 10.0] is:
cdf(x) = 0.05 * x + 0.5 for x in [-10.0, 10.0]
This expresses the probability that a random number generated is smaller than x. The inverse is
icdf(y) = 20.0 * y - 10.0 for y in [0.0, 1.0]
(You can obtain this easily on paper by switching the x and y axis).
Hence to obtain random numbers uniformly distributed on [-10.0, 10.0] you can use the following code:
#include <stdlib.h>
// Returns uniformly distributed random numbers from [0.0, 1.0].
double uniform0to1Random() {
double r = random();
return r / ((double)RAND_MAX + 1);
}
// Returns uniformly distributed random numbers from [-10.0, 10.0].
double myRandom() {
return 20.0 * uniform0to1Random() - 10.0;
}
In fact, you don't need uniform0to1Random() since there are already a lot of good uniform random numbers generators from [0.0, 1.0] (e.g. in the boost library).
You can use the method to generate random numbers with nearly any probability distribution you want by sampling the inverse cumulative distribution as shown above.
See http://en.wikipedia.org/wiki/Inverse_transform_sampling for more details.

Answer 2

Following will give you a float in range between -max/2 up to +max/2:
float max = 5000;
float r = max * ((float)rand()/(float)RAND_MAX - 0.5);

Answer 3

Edit Since the question was edited for C only:
This page is pretty helpful: http://www.geekpedia.com/tutorial39_Random-Number-Generation.html
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
//use this first function to seed the random number generator,
//call this before any of the other functions
void initrand()
{
srand((unsigned)(time(0)));
}
//generates a psuedo-random float between 0.0 and 0.999...
float randfloat()
{
return rand()/(float(RAND_MAX)+1);
}
//generates a psuedo-random float between 0.0 and max
float randfloat(float max)
{
return randfloat()*max;
}
//generates a psuedo-random float between min and max
float randfloat(float min, float max)
{
if (min>max)
return randfloat()*(min-max)+max;
else
return randfloat()*(max-min)+min;
}
//generates a psuedo-random double between 0.0 and 0.999...
double randdouble()
{
return rand()/(double(RAND_MAX)+1);
}
//generates a psuedo-random double between 0.0 and max
double randdouble(double max)
{
return randdouble()*max;
}
//generates a psuedo-random double between min and max
double randdouble(double min, double max)
{
if (min>max)
return randdouble()*(min-max)+max;
else
return randdouble()*(max-min)+min;
}
int main()
{
for (int i=0; i<10; i++)
printf("%f\n", randdouble(-1,3));
}
Output sample:
2.360751
0.577532
2.132397
2.193760
2.646589
-0.209795
0.340891
2.072918
0.111099
1.215880
(note the range: -1..3)

Answer 4

The GNU scientific library has a few methods.
http://www.gnu.org/s/gsl/manual/html_node/Random-number-generator-algorithms.html
Even if you can't use it due to licensing it should give you the names of a few too google for.
The boost random library (C++) uses lagged fibonacci and ranlux algorithms for doubles and floats, so they may be another option for you. (The methods not the boost library as it is C++ )
These techniques usually give you results in the range 0 -- 1. By using R = rmin + v* (rmax-rmin) where v is in 0 -- 1 you will get R in rmin -- rmax

Answer 5

Take a look at Boost.Random:
http://www.boost.org/doc/libs/1_47_0/doc/html/boost_random.html
You can get float random values doing this way:
boost::mt19937 base_rng;
boost::uniform_01<> u01;
boost::variate_generator<boost::mt19937&, boost::uniform_01<> > rng(base_rng, u01);
rng(); // draws a random number
Please note that random number generation facilities are now available in the new C++ standard:
http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01617.html

Answer 6

You can use
rand() / (double)RAND_MAX /* 0 <= random number <= 1 */
rand() / (RAND_MAX + 1.0) /* 0 <= random number < 1 */
for a random number between 0 and 1.
Then multiply by your desired range and add for the initial value.
For instance, to get random numbers 0 <= X < 4.2
double tmp = rand() / (RAND_MAX + 1.0)
X = tmp * 4.2;
to get random numbers -21.1 <= X <= 37.5
double tmp = rand() / (double)RAND_MAX
X = tmp * (37.5 + 21.1);
X = X - 21.1;

Answer 7

The simplest method I know:
int randNum = rand();
float floatRand = randNum/RAND_MAX;
floatRand is a random float in [0,1]. However, the resolution of this method is limited by RAND_MAX..
[EDIT]:
to get negative values, generate another random number and if its greater than RAND_MAX/2, multiply the former by (-1).

Answer 8

This will generate random [any representable float]:
#include <stdio.h>
float randfdev(void)
{
float tmp;
int fd = open("/dev/urandom",O_RDONLY);
read(fd,&tmp,sizeof tmp);
return tmp;
}
Note:
no error checking
assumes IEEE floating point, although other formats should work
will produce NaNs, subnormals, infinitys, etc