This is my last resort after 2 days of devouring information from everywhere
My math skills are relatively poor though, but I have a feeling what I'm trying to do simply can't be done.

I am summing random variables that have uniform distribution, once they are summed they are of normal distribution
With only n = 3, the distribution is already extremely poor.
How can I, and is it even possible to make the distribution uniform again?

This is the ultimate example:

[source lang="cpp"]
for (1 ... N) {
X += uniform();
}

X = uniformize(X, N);
[/source]

http://www.johndcook.com/blog/2009/02/12/sums-of-uniform-random-values/
the density function for my final distribution should be a constant 1/N

why not just multiply the variable drawn from the uniform distribution with N

that's just scaling, i need octaves to build a frequency
a real life example would be uniformly distributed whitenoise

I am not sure what you want to accomplish.

If you want a random variable with uniform distribution from 0 to N, and you have a variable uniformly distributed from 0 to 1 well then you just have to scale it with N.
I do not see the point in creating a random variable with some distribution and then wanting to transform it back to uniform, if you actually have a uniform distribution to begin with.

I have a feeling you might be confusing the concept of random variable and probability distribution. Could you tell us exactly in detail what you are trying to do?

If you only have an API that allows you to generate uniform bits (0 or 1), you can generate a random number in the range [0, N] in the following way:

int uniform(); // Returns 0 or 1 uniformly at random.

uint32_t RandomNumber(int N)
{
uint32_t NPow2 = largest power-of-2-number smaller or equal to N.
int i = 1;
uint32_t result = 0;
while(i <= NPow2)
{
if (uniform)
result |= i;
i <<= 1;
}
return (uint32_t)((uint64_t)result * (N+1) / (NPow2 << 1));
}


However, this is most likely not the route you want to go through, unless you somehow have a very special setup where your RNG can only supply individual random bits. That sounds rare, and instead most RNG sources are built-in to produce random integers in range [a,b] and random floats in the range [0,1] (which equals roughly 23 bits of randomness).

However, this is most likely not the route you want to go through, unless you somehow have a very special setup where your RNG can only supply individual random bits. That sounds rare, and instead most RNG sources are built-in to produce random integers in range [a,b] and random floats in the range [0,1] (which equals roughly 23 bits of randomness).

These special setups are not rare at all, though I agree you are more likely to find them in cryptographic settings (entropy pools) than in conventional PRNG's. Also, a small terminology nitpick: a random bit generator is called an RBG (and its pseudorandom counterpart is a PRBG).

What I would find rare is PRNG's directly producing floating-point numbers. As far as I can tell this is usually provided by a helper function which performs the floating-point division along the lines of random(max) / max. I recall a few purely floating-point generators, but in my opinion it's not a very smart way to go about it, integer arithmetic is very well-defined unlike floating-point arithmetic.

I asked a statistician, and I got a final answer: that i couldn't do this due to central limit theorem
When i sum random samples, I am destined to get a skewed probability distribution
nevertheless, interesting conversations above

Well, not if your uniform random distributions are not independent. The central limit theorem does not apply, and you can build a uniform distribution U(0,7) as the sum of seven U(0,1) distributions that happen to be identical.

But I still don't quite understand what you were trying to do, so this conversation feels kind of irrelevant.

i was using the randoms to create octaved frequencies for biomes
i didnt want noise, since gradiented noise has extremely uneven distribution (think of the derivatives on the extremities of a sphere)
i basically wanted to make saw-like linear frequencies

but...
http://www.johndcook...-random-values/