JLB_Random

The basic generator produces a random sequence of integers in the range from 0 to 2147483647, inclusive. Note that 2147483647 is the largest positive integer in UF.
To use, first call Init(seed) with seed an odd positive integer. This initializes the sequence. If the call to init is omitted, the default seed (1245) is used. Then i = RandomInt(0) provides successive numbers in the sequence. Also, i = RandomInt(j) with j non-zero will first reset the sequence using j as the new seed.

To produce a random integer in [1, N], inclusive, use RandomIntInRange, which uses RandomInt(). First set N with SetRange(). If the call to SetRange is omitted, the default N (16) is used.

To produce a random float in [0, 1), use RandomFloat(), which uses RandomInt(). It works by dividing the integer returned by RandomInt() by 2147483648.0 (which is a float equal to 2^31). The value 0 can be obtained, but not the value 1. This is sometimes useful. <> The random number generator is robust, probably the simplest robust generator. It uses the same algorithm as a routine in the NIST math library.
Original version: br> Blue, James L., Applied and Computational Mathematics Division, NIST
Kahaner, David K., Applied and Computational Mathematics Division, NIST
Marsaglia, George, Florida State University
Reference: Marsaglia G., "a Current View of Random Number Generators," Proceedings Computer Science and Statistics: 16th Symposium on the Interface, Elsevier, Amsterdam, 1985.

 class JLB_Random(common.ulb:Generic) {
   ; This class provides a robust pseudo-random number generator for UF. <p>
   ; The basic generator produces a random sequence of integers in the range
   ; from 0 to 2147483647, inclusive. Note that 2147483647 is the largest
   ; positive integer in UF. <br>
   ;
   ; To use, first call Init(seed) with seed an odd positive integer. This
   ; initializes the sequence. If the call to init is omitted, the default seed
   ; (1245) is used.
   ; Then i = RandomInt(0) provides successive numbers in the sequence.
   ; Also, i = RandomInt(j) with j non-zero will first reset the sequence
   ; using j as the new seed.  <p>
 
   ; To produce a random integer in [1, N], inclusive, use RandomIntInRange,
   ; which uses RandomInt(). First set N with SetRange(). If the call to
   ; SetRange is omitted, the default N (16) is used.  <p>
   ;
   ; To produce a random float in [0, 1), use RandomFloat(), which uses
   ; RandomInt(). It works by dividing the integer returned by RandomInt()
   ; by 2147483648.0 (which is a float equal to 2^31). The value
   ; 0 can be obtained, but not the value 1. This is sometimes useful.  <>
   ;
   ; The random number generator is robust, probably the simplest robust
   ; generator. It uses the same algorithm as a routine in the NIST math
   ; library.   <br>
   ;
   ; Original version: br>
   ;    Blue, James L., Applied and Computational Mathematics Division, NIST  <br>
   ;    Kahaner, David K., Applied and Computational Mathematics Division, NIST  <br>
   ;    Marsaglia, George, Florida State University   <br>
   ;
   ; Reference: Marsaglia G., "a Current View of Random Number Generators,"
   ;           Proceedings Computer Science and Statistics: 16th
   ;           Symposium on the Interface, Elsevier, Amsterdam, 1985.
   ;
 public:
   import "common.ulb"
   
   ; Constructor
   func JLB_Random(Generic pparent)
      Generic.Generic(pparent)
     ;
     ; Init with default seed.
     ;
     Init(@p_seed)
     ;
     ; Set default range maximum
     ;
     m_Nmax = 16
   endfunc
   
   ; Call to this to initialize the random number generator.
   ; @param seed an odd positive integer
   func Init(int seed)
     ; Fix up seed if Init is improperly called
     if (seed < 0)
       seed = seed + 2147483647
     endif
     if (seed % 2 == 0)
       seed = 2147483647 - seed
     endif
 
     ; Initialize the history array with a simple linear congruential generator.
     float x = seed
     int i = 0
     ; Note: floats in UF have enough range so that 9069*2147483647
     ; is exactly representable.
     repeat
       x = (9069.0 * x) % 2147483648.0
       m_hist[i] = round(x)             ; x is exactly an integer
       i = i + 1
     until (i == 17)  
     m_i =  4
     m_j = 16
   endfunc  
   
   ; @param pn If non-zero, initialize with seed = pn. If zero, just get next value
   ; @return the next value in the integer sequence. Values are from 0 to 2147483647, inclusive
   int func RandomInt(const int pn)
     
     if (pn != 0)                 ;reset seed
       Init(pn)
     endif
 
     int k = m_hist[m_i] - m_hist[m_j]
     if (k < 0)
       k = k + 2147483647
     endif
     m_hist[m_j] = k
 
     m_i = m_i - 1
     if (m_i < 0)
       m_i = 16
     endif
     
     m_j = m_j - 1
     if (m_j < 0)
       m_j = 16
     endif
     
     return k
   endfunc
   
   ; Set the maximum integer for the range version.
   ; @param Nmax maximum integer (set to 16 if Nmax <= 0)
   ; @return true if Nmax > 0, false if Nmax <= 0
   bool func SetNmax(const int Nmax)
     if (Nmax <= 0)     ; bad, so use default value
       m_Nmax = 16
       return false
     endif
     m_Nmax = Nmax
     return true
   endfunc
   
   ; Produce the next value in the sequence - range version
   ;
   ; @param pn If non-zero, initialize with seed = pn. If zero, just get next value
   ; @return the next value in the sequence. Values are from 1 to Nmax, inclusive.
   int func RandomIntInRange(const int pn)
 
     ; In general the high-order bits have better random properties than
     ; the low-order bits, so do it this way instead of RandomInt(pn)%m_Nmax.
     ;
     float x = RandomInt(pn) / 2147483648.0
     return (1 + trunc( x * m_Nmax))
   endfunc
   
   ; Produce the next value in the sequence - float version
   ;
   ; @param pn If non-zero, initialize with seed = pn. If zero, just get next value
   ; @return the next value in the sequence. Values are from 0.0 to 1.0, including 0.0 but not including 1.0.
   float func RandomFloat(const int pn)       
     return (RandomInt(pn) / 2147483648.0)
   endfunc
   
 protected:
   int m_hist[17]        ; history array
   int m_i               ; index 1 into array
   int m_j               ; index 2 into array
   int m_Nmax            ; maximum integer for range version
 
 default:
   title = "Random"
   
   int param p_seed
     caption = "Seed"
     default = 12345
     hint = "Sets the seed for the random number generator. \
     Each different seed produces a different sequence of random values."
   endparam
 }

Method Summary
`void`	`Init(int seed)` Call to this to initialize the random number generator.
`float`	`RandomFloat(int pn)` Produce the next value in the sequence - float version
`int`	`RandomInt(int pn)`
`int`	`RandomIntInRange(int pn)` Produce the next value in the sequence - range version
`boolean`	`SetNmax(int Nmax)` Set the maximum integer for the range version.

Constructor Summary
`JLB_Random()`
`JLB_Random(Generic pparent)` Constructor

jlb Class JLB_Random

JLB_Random

JLB_Random

Init

RandomInt

SetNmax

RandomIntInRange

RandomFloat

jlb
Class JLB_Random