«

Hi..

I'm programming a Monte Carlo problem where i need to show that my
results are reproducible - that is I need to prove this by running by
program with seeded random numbers.

The program is build up of a main method and a lot of other sub-
routines. How can I create a random number generator, from which I can
get my seeded random numbers. It shall be possible to get one random
number at a time a lot times (some millions), and I need to call the
random number generator from any of the subroutines and get the same
sequence of numbers no matter from which routines i call them (also
shifting between the sub-routines for example 5 calls from routine 1
followed by 5 from the main routine should give the same numbers as if
I called the generator 4 times from the main routine followed by 5
times from routine number 10 followed by one call from the main
routine again)

I hope the description can be understood - it is a bit difficult to
explain..

Can anybody help me to solve this?

/Peter

(-Peter-) wrote:
> Hi..
>
> I'm programming a Monte Carlo problem where i need to show that my
> results are reproducible - that is I need to prove this by running by
> program with seeded random numbers.
>
> The program is build up of a main method and a lot of other sub-
> routines. How can I create a random number generator, from which I can
> get my seeded random numbers. It shall be possible to get one random
> number at a time a lot times (some millions), and I need to call the
> random number generator from any of the subroutines and get the same
> sequence of numbers no matter from which routines i call them (also
> shifting between the sub-routines for example 5 calls from routine 1
> followed by 5 from the main routine should give the same numbers as if
> I called the generator 4 times from the main routine followed by 5
> times from routine number 10 followed by one call from the main
> routine again)

Create as many different java.util.Random objects as you
need, using the same seed value for each:

long seed = 123456789; // or whatever
Random rmain = new Random(seed);
Random rsub1 = new Random(seed);
...

Devote one Random object to each "subroutine" or group of
related subroutines, so each "subroutine" obtains values only
from its own Random object.

... but I may have misunderstood just what you mean by "the
same sequence." If it seems I have, please try to explain it
more clearly.

--

On 20 Feb., 22:34, Eric Sosman <Eric.Sos...@sun.com> wrote:
> (-Peter-) wrote:
> > Hi..
>
> > I'm programming a Monte Carlo problem where i need to show that my
> > results are reproducible - that is I need to prove this by running by
> > program with seeded random numbers.
>
> > The program is build up of a main method and a lot of other sub-
> > routines. How can I create a random number generator, from which I can
> > get my seeded random numbers. It shall be possible to get one random
> > number at a time a lot times (some millions), and I need to call the
> > random number generator from any of the subroutines and get the same
> > sequence of numbers no matter from which routines i call them (also
> > shifting between the sub-routines for example 5 calls from routine 1
> > followed by 5 from the main routine should give the same numbers as if
> > I called the generator 4 times from the main routine followed by 5
> > times from routine number 10 followed by one call from the main
> > routine again)
>
> Create as many different java.util.Random objects as you
> need, using the same seed value for each:
>
> long seed = 123456789; // or whatever
> Random rmain = new Random(seed);
> Random rsub1 = new Random(seed);
> ...
>
> Devote one Random object to each "subroutine" or group of
> related subroutines, so each "subroutine" obtains values only
> from its own Random object.
>
> ... but I may have misunderstood just what you mean by "the
> same sequence." If it seems I have, please try to explain it
> more clearly.
>
> --
> Eric.Sos...@sun.com

I think you have misunderstood it (because of the bad explanation)..

Generally I need ONE sequence (therefore I think I do only need one
generator) of random numbers for example (which are seeded, so I get
the same results every time I run the code)

0.21 0.23 0.1 0.9 0.5 0.7

I will when use the first number (in this example 0.21) to decide
which sub-routine should be run. This sub-routine (call this sub1)
uses the next random number (0.23) and when "decides" to go to another
sub-routine (sub2) which uses the random number (0.1)...

If I seeded the random number generator another way I would for
example get these numbers:

0.7 0.1 0.21 0.81 0.21 0.001

The first number (0.7) is now calling another subroutine(sub4) which
uses the number 0.1 to decide to go back to the main method which uses
the random number (0.21). This calls sub2 which uses 0.81....

That is no matter what the numbers are I will use them in them in the
same order - which numbers are used in which method is "random".

I hope this was a better explanation.. If not please tell me..

/Peter

(-Peter-) wrote:
>
> Generally I need ONE sequence (therefore I think I do only need one
> generator) of random numbers for example (which are seeded, so I get
> the same results every time I run the code)
>
> 0.21 0.23 0.1 0.9 0.5 0.7
>
> I will when use the first number (in this example 0.21) to decide
> which sub-routine should be run. This sub-routine (call this sub1)
> uses the next random number (0.23) and when "decides" to go to another
> sub-routine (sub2) which uses the random number (0.1)...
>
> If I seeded the random number generator another way I would for
> example get these numbers:
>
> 0.7 0.1 0.21 0.81 0.21 0.001
>
> The first number (0.7) is now calling another subroutine(sub4) which
> uses the number 0.1 to decide to go back to the main method which uses
> the random number (0.21). This calls sub2 which uses 0.81....
>
> That is no matter what the numbers are I will use them in them in the
> same order - which numbers are used in which method is "random".

I'm sorry, but I still don't understand your difficulty.
If you create two Random objects using the same seed value,
and if you make the same sequence of method calls on each,
they will deliver identical result streams. So if you run
your program using a Random whose seed is 123456789, and then
you run the program it a second time and again use the seed
value 123456789, you will get the same pseudo-random values
in both executions.

--

(-Peter-) schrieb:
> On 20 Feb., 22:34, Eric Sosman <Eric.Sos...@sun.com> wrote:
>> (-Peter-) wrote:
>>> Hi..
>>> I'm programming a Monte Carlo problem where i need to show that my
>>> results are reproducible - that is I need to prove this by running by
>>> program with seeded random numbers.
>>> The program is build up of a main method and a lot of other sub-
>>> routines. How can I create a random number generator, from which I can
>>> get my seeded random numbers. It shall be possible to get one random
>>> number at a time a lot times (some millions), and I need to call the
>>> random number generator from any of the subroutines and get the same
>>> sequence of numbers no matter from which routines i call them (also
>>> shifting between the sub-routines for example 5 calls from routine 1
>>> followed by 5 from the main routine should give the same numbers as if
>>> I called the generator 4 times from the main routine followed by 5
>>> times from routine number 10 followed by one call from the main
>>> routine again)
>> Create as many different java.util.Random objects as you
>> need, using the same seed value for each:
>>
>> long seed = 123456789; // or whatever
>> Random rmain = new Random(seed);
>> Random rsub1 = new Random(seed);
>> ...
>>
>> Devote one Random object to each "subroutine" or group of
>> related subroutines, so each "subroutine" obtains values only
>> from its own Random object.
>>
>> ... but I may have misunderstood just what you mean by "the
>> same sequence." If it seems I have, please try to explain it
>> more clearly.
>>
>> --
>> Eric.Sos...@sun.com
>
> I think you have misunderstood it (because of the bad explanation)..
>
> Generally I need ONE sequence (therefore I think I do only need one
> generator) of random numbers for example (which are seeded, so I get
> the same results every time I run the code)
>
> 0.21 0.23 0.1 0.9 0.5 0.7
>
> I will when use the first number (in this example 0.21) to decide
> which sub-routine should be run. This sub-routine (call this sub1)
> uses the next random number (0.23) and when "decides" to go to another
> sub-routine (sub2) which uses the random number (0.1)...
>
> If I seeded the random number generator another way I would for
> example get these numbers:
>
> 0.7 0.1 0.21 0.81 0.21 0.001
>
> The first number (0.7) is now calling another subroutine(sub4) which
> uses the number 0.1 to decide to go back to the main method which uses
> the random number (0.21). This calls sub2 which uses 0.81....
>
> That is no matter what the numbers are I will use them in them in the
> same order - which numbers are used in which method is "random".
>
> I hope this was a better explanation.. If not please tell me..
>
> /Peter
>
>
It seems to me that it would fit for you to create a single Random
object. Make it accessible to everywhere from the program.
i.e. using static or create a singleton to hold it.

Christian

(-Peter-) wrote:
....
> Generally I need ONE sequence (therefore I think I do only need one
> generator) of random numbers for example (which are seeded, so I get
> the same results every time I run the code)

In that case, construct a single instance of java.util.Random,
specifying the seed on the constructor call, and use it throughout the
program.

Patricia

On Feb 20, 5:54 pm, Patricia Shanahan <p...@acm.org> wrote:
> (-Peter-) wrote:
>
> ...
>
> > Generally I need ONE sequence (therefore I think I do only need one
> > generator) of random numbers for example (which are seeded, so I get
> > the same results every time I run the code)
>
> In that case, construct a single instance of java.util.Random,
> specifying the seed on the constructor call, and use it throughout the
> program.
>
> Patricia

Patricia is right - a single instance across the program is the way to
go. HOWEVER...

The only downside to using java.util.Random is that it tends not to be
"random" enough. So, if you're interested in a "more random" answer,
check into the Mersenne Twister. (There's a good article on
Wikipedia.)

On Wed, 20 Feb 2008 13:24:51 -0800 (PST), "(-Peter-)"
<> wrote, quoted or indirectly quoted someone who
said :

>I'm programming a Monte Carlo problem where i need to show that my
>results are reproducible - that is I need to prove this by running by
>program with seeded random numbers.

see http://mindprod.com/jgloss/pseudorandom.html
--

Roedy Green Canadian Mind Products
The Java Glossary
http://mindprod.com

On Wed, 20 Feb 2008 14:54:08 -0800, Patricia Shanahan <>
wrote, quoted or indirectly quoted someone who said :

>In that case, construct a single instance of java.util.Random,
>specifying the seed on the constructor call, and use it throughout the
>program.

If you have threads this won't work. You would need one generator per
thread to get reproducible results. One generator will suffice so
long as you make calls on it in the same order each time for each
sample you want on a single thread.
--

Roedy Green Canadian Mind Products
The Java Glossary
http://mindprod.com

On 21 Feb., 02:23, Jason Cavett <jason.cav...@gmail.com> wrote:
> On Feb 20, 5:54 pm, Patricia Shanahan <p...@acm.org> wrote:
>
> > (-Peter-) wrote:
>
> > ...
>
> > > Generally I need ONE sequence (therefore I think I do only need one
> > > generator) of random numbers for example (which are seeded, so I get
> > > the same results every time I run the code)
>
> > In that case, construct a single instance of java.util.Random,
> > specifying the seed on the constructor call, and use it throughout the
> > program.
>
> > Patricia
>
> Patricia is right - a single instance across the program is the way to
> go. *HOWEVER...
>
> The only downside to using java.util.Random is that it tends not to be
> "random" enough. *So, if you're interested in a "more random" answer,
> check into the Mersenne Twister. *(There's a good article on
> Wikipedia.)

Okay I will look at that..

How do I create this object?

How would the object know which of the numbers it shall use?

I can not get a idea to construct it..

please help med

/Peter