Generate a sequence of random numbers that sum up to 1?

[Anthony Liu]

I am at my wit's end.

I want to generate a certain number of random numbers.
This is easy, I can repeatedly do uniform(0, 1) for
example.

But, I want the random numbers just generated sum up
to 1 .

I am not sure how to do this. Any idea? Thanks.

_______________ _______________ _______________ _____
Do You Yahoo!?
Tired of spam? Yahoo! Mail has the best spam protection around
http://mail.yahoo.com

[Mel Wilson]

Anthony Liu wrote:

I am at my wit's end.

I want to generate a certain number of random numbers.
This is easy, I can repeatedly do uniform(0, 1) for
example.

But, I want the random numbers just generated sum up
to 1 .

I am not sure how to do this. Any idea? Thanks.
numbers.append (random.uniform (0, 1.0-sum(numbers)))

might help, perhaps.

or

scaled = [x/sum(numbers) for x in numbers]

Mel.

[Edward Elliott]

Anthony Liu wrote:

But, I want the random numbers just generated sum up
to 1 .

This seems like an odd request. Might I ask what it's for?

Generating random numbers in [0,1) that are both uniform and sum to 1 looks
like an unsatisfiable task. Each number you generate restricts the
possibilities for future numbers. E.g. if the first number is 0.5, all
future numbers must be < 0.5 (indeed, must *sum* to 0.5). You'll end up
with a distribution increasingly skewed towards smaller numbers the more
you generate. I can't imagine what that would be useful for.

If that's not a problem, do this: generate the numbers, add them up, and
divide each by the sum.

nums = [random.uniform( 0,1) for x in range(0,100)]
sum = reduce(lambda x,y: x+y, nums)
norm = [x/sum for x in nums]

Of course now the numbers aren't uniform over [0,1) anymore.

Also note that the sum of the normalized numbers will be very close to 1,
but slightly off due to representation issues. If that level of accuracy
matters, you might consider generating your rands as integers and then
fp-dividing by the sum (or just store them as integers/fractions).

[Felipe Almeida Lessa]

Em Sáb, 2006-04-22 Ã*s 03:16 +0000, Edward Elliott escreveu:

If that level of accuracy
matters, you might consider generating your rands as integers and then
fp-dividing by the sum (or just store them as integers/fractions).

Or using decimal module: http://docs.python.org/lib/module-decimal.html

--
Felipe.

[Alex Martelli]

Anthony Liu <an***********@ yahoo.com> wrote:
...

As a matter of fact, given that we have to specify the
number of states for an HMM, I would like to create a
specified number of random floating numbers whose sum
is 1.0.

def forAL(N):
N_randoms = [random.random() for x in xrange(N)]
total = sum(N_randoms)
return [x/total for x in N_randoms]
Does this do what you want? Of course, the resulting numbers are not
independent, but then the constraints you pose would contradict that.
Alex

[Gerard Flanagan]

Anthony Liu wrote:

I am at my wit's end.

I want to generate a certain number of random numbers.
This is easy, I can repeatedly do uniform(0, 1) for
example.

But, I want the random numbers just generated sum up
to 1 .

I am not sure how to do this. Any idea? Thanks.

--------------------------------------------------------------
import random

def partition(start =0,stop=1,eps=5 ):
d = stop - start
vals = [ start + d * random.random() for _ in range(2*eps) ]
vals = [start] + vals + [stop]
vals.sort()
return vals

P = partition()

intervals = [ P[i:i+2] for i in range(len(P)-1) ]

deltas = [ x[1] - x[0] for x in intervals ]

print deltas

print sum(deltas)
---------------------------------------------------------------

Gerard

[Gerard Flanagan]

Gerard Flanagan wrote:

Anthony Liu wrote:

I am at my wit's end.

I want to generate a certain number of random numbers.
This is easy, I can repeatedly do uniform(0, 1) for
example.

But, I want the random numbers just generated sum up
to 1 .

I am not sure how to do this. Any idea? Thanks.

--------------------------------------------------------------
import random

def partition(start =0,stop=1,eps=5 ):
d = stop - start
vals = [ start + d * random.random() for _ in range(2*eps) ]
vals = [start] + vals + [stop]
vals.sort()
return vals

P = partition()

intervals = [ P[i:i+2] for i in range(len(P)-1) ]

deltas = [ x[1] - x[0] for x in intervals ]

print deltas

print sum(deltas)
---------------------------------------------------------------

def partition(N=5):
vals = sorted( random.random() for _ in range(2*N) )
vals = [0] + vals + [1]
for j in range(2*N+1):
yield vals[j:j+2]

deltas = [ x[1]-x[0] for x in partition() ]

print deltas

print sum(deltas)

[0.1027196668699 4982, 0.1382657649104 2208, 0.0641469135551 32801,
0.1190645245446 7387, 0.1050119845609 1299, 0.0117324238307 68779,
0.1178536925644 2912, 0.0659271655201 02249, 0.0983513058781 76198,
0.0777867470762 05365, 0.0991398106892 26726]
1.0

[Gerard Flanagan]

Gerard Flanagan wrote:

Gerard Flanagan wrote:

Anthony Liu wrote:

I am at my wit's end.

I want to generate a certain number of random numbers.
This is easy, I can repeatedly do uniform(0, 1) for
example.

But, I want the random numbers just generated sum up
to 1 .

I am not sure how to do this. Any idea? Thanks.

--------------------------------------------------------------
import random

def partition(start =0,stop=1,eps=5 ):
d = stop - start
vals = [ start + d * random.random() for _ in range(2*eps) ]
vals = [start] + vals + [stop]
vals.sort()
return vals

P = partition()

intervals = [ P[i:i+2] for i in range(len(P)-1) ]

deltas = [ x[1] - x[0] for x in intervals ]

print deltas

print sum(deltas)
---------------------------------------------------------------

def partition(N=5):
vals = sorted( random.random() for _ in range(2*N) )
vals = [0] + vals + [1]
for j in range(2*N+1):
yield vals[j:j+2]

deltas = [ x[1]-x[0] for x in partition() ]

print deltas

print sum(deltas)

finally:

---------------------------------------------------------------
def distribution(N= 2):
p = [0] + sorted( random.random() for _ in range(N-1) ) + [1]
for j in range(N):
yield p[j+1] - p[j]

spread = list(distributi on(10))

print spread
print sum(spread)
---------------------------------------------------------------
Gerard

[Nick Craig-Wood]

Gerard Flanagan <gr********@yah oo.co.uk> wrote:

def distribution(N= 2):
p = [0] + sorted( random.random() for _ in range(N-1) ) + [1]
for j in range(N):
yield p[j+1] - p[j]

spread = list(distributi on(10))

print spread
print sum(spread)

This is simpler, easier to prove correct and most likely quicker.

def distribution(N= 2):
L = [ random.uniform( 0,1) for _ in xrange(N) ]
sumL = sum(L)
return [ l/sumL for l in L ]

spread = distribution(10 )
print spread
print sum(spread)

--
Nick Craig-Wood <ni**@craig-wood.com> -- http://www.craig-wood.com/nick

[Gerard Flanagan]

Nick Craig-Wood wrote:

Gerard Flanagan <gr********@yah oo.co.uk> wrote:

def distribution(N= 2):
p = [0] + sorted( random.random() for _ in range(N-1) ) + [1]
for j in range(N):
yield p[j+1] - p[j]

spread = list(distributi on(10))

print spread
print sum(spread)

This is simpler, easier to prove correct and most likely quicker.

def distribution(N= 2):
L = [ random.uniform( 0,1) for _ in xrange(N) ]
sumL = sum(L)
return [ l/sumL for l in L ]

simpler:- ok

easier to prove correct:- in what sense?

quicker:- slightly slower in fact (using xrange in both functions).
This must be due to 'uniform' - using random() rather than uniform(0,1)
then yes, it's quicker. Roughly tested, I get yours (and Alex
Martelli's) to be about twice as fast. (2<=N<1000, probably greater
difference as N increases).

All the best.

Gerard