Merge branch 'master' of https://github.com/schmouk/PyRandLib

schmouk · schmouk · commit 161d21701811 · 2019-05-04T11:44:48.000+02:00
diff --git a/PyRandLib/__init__.py b/PyRandLib/__init__.py
@@ -3,7 +3,7 @@
 It is provided under MIT License.
 Please see files README.md and LICENSE.
 
-Copyright (c) 2017-2019 Philippe Schmouker
+Copyright (c) 2016-2019 Philippe Schmouker
 """
 
 from .baselcg        import BaseLCG
diff --git a/PyRandLib/baselcg.py b/PyRandLib/baselcg.py
@@ -32,9 +32,8 @@ class BaseLCG( BaseRandom ):
     """
     Definition of the base class for all LCG pseudo-random generators.
     This module is part of library PyRandLib.
-    
-    Copyright (c) 2017-2019 Philippe Schmouker
 
+    Copyright (c) 2016-2019 Philippe Schmouker
 
     LCG models evaluate pseudo-random numbers suites x(i) as a simple mathem-
     atical function of 
diff --git a/PyRandLib/baselfib64.py b/PyRandLib/baselfib64.py
@@ -35,8 +35,7 @@ class BaseLFib64( BaseRandom ):
     on 64-bits generated numbers.
     This module is part of library PyRandLib.
     
-    Copyright (c) 2017-2019 Philippe Schmouker
-
+    Copyright (c) 2016-2019 Philippe Schmouker
 
     Lagged Fibonacci generators LFib( m, r, k, op) use the recurrence
     
diff --git a/PyRandLib/basemrg.py b/PyRandLib/basemrg.py
@@ -34,8 +34,7 @@ class BaseMRG( BaseRandom ):
     Definition of the base class for all MRG pseudo-random generators.
     This module is part of library PyRandLib.
     
-    Copyright (c) 2017-2019 Philippe Schmouker
-
+    Copyright (c) 2016-2019 Philippe Schmouker
 
     Multiple Recursive Generators (MRGs) uses  recurrence  to  evaluate  pseudo-random
     numbers suites. Recurrence is of the form:
diff --git a/PyRandLib/baserandom.py b/PyRandLib/baserandom.py
@@ -33,8 +33,7 @@ class BaseRandom( Random ):
     This is the base class for all pseudo-random numbers generators.
     This module is part of library PyRandLib.
     
-    Copyright (c) 2017-2019 Philippe Schmouker
-
+    Copyright (c) 2016-2019 Philippe Schmouker
 
     See FastRand32 for a 2^32 (i.e. 4.3e+9) period LC-Generator and  FastRand63  for a  
     2^63 (i.e. about 9.2e+18) period LC-Generator with low computation time.
diff --git a/PyRandLib/fastrand32.py b/PyRandLib/fastrand32.py
@@ -36,13 +36,12 @@ class FastRand32( BaseLCG ):
     short time computation.
     This module is part of library PyRandLib.
     
-    Copyright (c) 2017-2019 Philippe Schmouker
-
+    Copyright (c) 2016-2019 Philippe Schmouker
 
     LCG models evaluate pseudo-random numbers suites x(i) as a simple mathem-
     atical function of 
     
-        x(i-1): x(i) = (a*x(i-1) + c) mod m 
+        x(i) = (a * x(i-1) + c) mod m 
      
     Results  are  nevertheless  considered  to  be  poor  as  stated  in  the 
     evaluation done by Pierre L'Ecuyer and Richard Simard (Universite de 
@@ -65,7 +64,7 @@ class FastRand32( BaseLCG ):
       print( rand(a) )   # prints a uniform pseudo-random value within [0.0, a)
       print( rand(a,b) ) # prints a uniform pseudo-random value within [a  , b)
 
-    Please notice that for simulating the roll of a dice you should program:
+    Notice that for simulating the roll of a dice you should program:
       diceRoll = FastRand32()
       print( int(diceRoll(1, 7)) ) # prints a uniform roll within set {1, 2, 3, 4, 5, 6}
 
@@ -125,8 +124,8 @@ def setstate(self, _state):
         elif isinstance( _state, float ):
             # transforms passed initial seed from float to integer
             if _state < 0.0 :
-                inState = -_state
-            if inState >= 1.0:
+                _state = -_state
+            if _state >= 1.0:
                 self._value = int( _state + 0.5 ) & 0xffffffff
             else:
                 self._value = int( _state * 0x100000000) & 0xffffffff
diff --git a/PyRandLib/fastrand63.py b/PyRandLib/fastrand63.py
@@ -36,8 +36,7 @@ class FastRand63( BaseLCG ):
     time computation.
     This module is part of library PyRandLib.
     
-    Copyright (c) 2017-2019 Philippe Schmouker
-
+    Copyright (c) 2016-2019 Philippe Schmouker
 
     LCG models evaluate pseudo-random numbers suites x(i) as a simple mathem-
     atical function of 
@@ -65,7 +64,7 @@ class FastRand63( BaseLCG ):
       print( rand(a) )   # prints a uniform pseudo-random value within [0.0, a)
       print( rand(a,b) ) # prints a uniform pseudo-random value within [a  , b)
 
-    Please notice that for simulating the roll of a dice you should program:
+    Notice that for simulating the roll of a dice you should program:
       diceRoll = FastRand63()
       print( int(diceRoll(1, 7)) ) # prints a uniform roll within set {1, 2, 3, 4, 5, 6}
 
diff --git a/PyRandLib/lfib116.py b/PyRandLib/lfib116.py
@@ -34,8 +34,7 @@ class LFib116( BaseLFib64 ):
     Generator with quite short period (8.3e+34).
     This module is part of library PyRandLib.
     
-    Copyright (c) 2017-2019 Philippe Schmouker
-
+    Copyright (c) 2016-2019 Philippe Schmouker
 
     Lagged Fibonacci generators LFib( m, r, k, op) use the recurrence
     
@@ -45,7 +44,7 @@ class LFib116( BaseLFib64 ):
         + (addition),
         - (substraction),
         * (multiplication),
-        ^(bitwise exclusive-or).
+        ^ (bitwise exclusive-or).
     
     With the + or - operation, such generators are in fact MRGs. They offer very large
     periods  with  the  best  known  results in the evaluation of their randomness, as
@@ -81,7 +80,7 @@ class LFib116( BaseLFib64 ):
       print( rand(a) )   # prints a uniform pseudo-random value within [0.0, a)
       print( rand(a,b) ) # prints a uniform pseudo-random value within [a  , b)
 
-    Please notice that for simulating the roll of a dice you should program:
+    Notice that for simulating the roll of a dice you should program:
 
       diceRoll = LFib116()
       print(int(diceRoll(1, 7))) # prints a uniform roll within set {1, 2, 3, 4, 5, 6}
diff --git a/PyRandLib/lfib1340.py b/PyRandLib/lfib1340.py
@@ -45,7 +45,7 @@ class LFib1340( BaseLFib64 ):
         + (addition),
         - (substraction),
         * (multiplication),
-        ^(bitwise exclusive-or).
+        ^ (bitwise exclusive-or).
     
     With the + or - operation, such generators are in fact MRGs. They offer very large
     periods  with  the  best  known  results in the evaluation of their randomness, as
@@ -69,7 +69,7 @@ class LFib1340( BaseLFib64 ):
     '+'.  We've implemented here the original operator: '+'.
        
     See LFib78,  LFib116 and LFib668 for long  period  LFib  generators  (resp.  2^78,  
-    2^116  and  2^668 periods, i.e. resp. 3.0e+23, 8.3e+34 and 2.4e+403 periods) while 
+    2^116  and  2^668 periods, i.e. resp. 3.0e+23, 8.3e+34 and 1.2e+201 periods) while 
     same computation time and far higher precision (64-bits calculations)  than  MRGs, 
     but memory consumption (resp. 17, 55 and 607 integers).
     
@@ -81,7 +81,7 @@ class LFib1340( BaseLFib64 ):
       print( rand(a) )   # prints a uniform pseudo-random value within [0.0, a)
       print( rand(a,b) ) # prints a uniform pseudo-random value within [a  , b)
 
-    Please notice that for simulating the roll of a dice you should program:
+    Notice that for simulating the roll of a dice you should program:
 
       diceRoll = LFib1340()
       print(int(diceRoll(1, 7))) # prints a uniform roll within set {1, 2, 3, 4, 5, 6}
diff --git a/PyRandLib/lfib668.py b/PyRandLib/lfib668.py
@@ -45,7 +45,7 @@ class LFib668( BaseLFib64 ):
         + (addition),
         - (substraction),
         * (multiplication),
-        ^(bitwise exclusive-or).
+        ^ (bitwise exclusive-or).
     
     With the + or - operation, such generators are in fact MRGs. They offer very large
     periods  with  the  best  known  results in the evaluation of their randomness, as
@@ -58,7 +58,7 @@ class LFib668( BaseLFib64 ):
     The implementation of this LFib 64-bits model  is  based  on  a  Lagged  Fibonacci 
     generator (LFIB) that uses the recurrence
     
-        x(i) = (x(i-273) + x(i-607)) mod 2^64
+        x(i) = ( x(i-273) + x(i-607) ) mod 2^64
     
     and offers a period of about 2^668 - i.e. 1.2e+201 - with low computation time due
     to the use of a 2^64 modulo but memory space consumption (607 long integers).
@@ -80,7 +80,7 @@ class LFib668( BaseLFib64 ):
       print( rand(a) )   # prints a uniform pseudo-random value within [0.0, a)
       print( rand(a,b) ) # prints a uniform pseudo-random value within [a  , b)
 
-    Please notice that for simulating the roll of a dice you should program:
+    Notice that for simulating the roll of a dice you should program:
 
       diceRoll = LFib668()
       print(int(diceRoll(1, 7))) # prints a uniform roll within set {1, 2, 3, 4, 5, 6}
diff --git a/PyRandLib/lfib78.py b/PyRandLib/lfib78.py
@@ -34,8 +34,7 @@ class LFib78( BaseLFib64 ):
     Generator with quite short period (3.0e+23).
     This module is part of library PyRandLib.
     
-    Copyright (c) 2017-2019 Philippe Schmouker
-
+    Copyright (c) 2016-2019 Philippe Schmouker
 
     Lagged Fibonacci generators LFib( m, r, k, op) use the recurrence
     
@@ -45,7 +44,7 @@ class LFib78( BaseLFib64 ):
         + (addition),
         - (substraction),
         * (multiplication),
-        ^(bitwise exclusive-or).
+        ^ (bitwise exclusive-or).
     
     With the + or - operation, such generators are in fact MRGs. They offer very large
     periods  with  the  best  known  results in the evaluation of their randomness, as
@@ -58,7 +57,7 @@ class LFib78( BaseLFib64 ):
     The implementation of this LFib 64-bits model  is  based  on  a  Lagged  Fibonacci 
     generator (LFIB) that uses the recurrence
     
-        x(i) = (x(i-5) + x(i-17)) mod 2^64
+        x(i) = ( x(i-5) + x(i-17) ) mod 2^64
     
     and offers a period of about 2^78 - i.e. 3.0e+23 - with low computation  time  due
     to the use of a 2^64 modulo and few memory space consumption (17 long integers).
@@ -80,7 +79,7 @@ class LFib78( BaseLFib64 ):
       print( rand(a) )   # prints a uniform pseudo-random value within [0.0, a)
       print( rand(a,b) ) # prints a uniform pseudo-random value within [a  , b)
 
-    Please notice that for simulating the roll of a dice you should program:
+    Notice that for simulating the roll of a dice you should program:
 
       diceRoll = LFib78()
       print(int(diceRoll(1, 7))) # prints a uniform roll within set {1, 2, 3, 4, 5, 6}
diff --git a/PyRandLib/mrgrand1457.py b/PyRandLib/mrgrand1457.py
@@ -58,7 +58,7 @@ class MRGRand1457( BaseMRG ):
 
     See MRGRand287 for a short period  MR-Generator (2^287,  i.e. 2.49e+86)  with  low
     computation time but 256 integers memory consumption.
-    See MRGRand49507 for a far  longer  period  (2^49507,  i.e. 1.2e+14903)  with  low 
+    See MRGRand49507 for a far longer period  (2^49_507,  i.e. 1.2e+14_903)  with  low 
     computation  time  too  (31-bits  modulus)  but  use  of  more  memory space (1597 
     integers).
     
diff --git a/PyRandLib/mrgrand287.py b/PyRandLib/mrgrand287.py
@@ -34,8 +34,7 @@ class MRGRand287( BaseMRG ):
     Generator with a long period (2.49e+86).
     This module is part of library PyRandLib.
     
-    Copyright (c) 2017-2019 Philippe Schmouker
-
+    Copyright (c) 2016-2019 Philippe Schmouker
 
     Multiple Recursive Generators (MRGs)  use  recurrence  to  evaluate  pseudo-random
     numbers suites. Recurrence is of the form:
@@ -78,8 +77,8 @@ class MRGRand287( BaseMRG ):
     See MRGRand1457 for a  longer  period  MR-Generator  (2^1457,  i.e. 4.0e+438)  and 
     longer  computation  time  (2^31-1  modulus  calculations)  but  less memory space 
     consumption (47 integers).
-    See MRGRand49507 for a far  longer  period  (2^49507,  i.e. 1.2e+14903)  with  low 
-    computation  time  too  (31-bits  modulus)  but  use  of  more  memory space (1597 
+    See MRGRand49507 for a far longer period  (2^49_507,  i.e. 1.2e+14_903)  with  low 
+    computation  time  too  (31-bits  modulus)  but  use  of  more memory space (1_597 
     integers).
       
     Furthermore this class is callable:
@@ -88,7 +87,7 @@ class MRGRand287( BaseMRG ):
       print( rand(a) )   # prints a uniform pseudo-random value within [0.0, a)
       print( rand(a,b) ) # prints a uniform pseudo-random value within [a  , b)
 
-    Please notice that for simulating the roll of a dice you should program:
+    Notice that for simulating the roll of a dice you should program:
       diceRoll = MRGRand287()
       print( int(diceRoll(1, 7)) ) # prints a uniform roll within set {1, 2, 3, 4, 5, 6}
 
@@ -119,7 +118,7 @@ class MRGRand287( BaseMRG ):
     #=========================================================================
     # 'protected' constant
     _LIST_SIZE = 256        # this 'Marsa-LFIB4' MRG is based on a suite containing 256 integers
-    _MODULO    = 4294967295 # i.e. 0xffffffff, or (1<<31)-1, the modulo for DX-47-3 MRG
+    _MODULO    = 4294967295 # i.e. 0x7fffffff, or (1<<32)-1, the modulo for DX-47-3 MRG
             
  
     #=========================================================================
diff --git a/PyRandLib/mrgrand49507.py b/PyRandLib/mrgrand49507.py
@@ -31,7 +31,7 @@
 class MRGRand49507( BaseMRG ):
     """
     Pseudo-random numbers generator  - Definition of a fast 31-bits Multiple Recursive 
-    Generator with a very long period (1.17e+14903).
+    Generator with a very long period (1.17e+14_903).
     This module is part of library PyRandLib.
 
     Multiple Recursive Generators (MRGs) uses  recurrence  to  evaluate  pseudo-random
@@ -53,18 +53,14 @@ class MRGRand49507( BaseMRG ):
     
         x(i) = (-2^25-2^7) * (x(i-7) + x(i-1597)) mod (2^31-1)
         
-    and  offers  a  period  of  about  2^49507  -  i.e. nearly 1.2e+14903  -  with low 
+    and offers a  period  of  about  2^49_507  -  i.e. nearly 1.2e+14_903  -  with low 
     computation time.
 
     See MRGRand287 for a short period  MR-Generator (2^287,  i.e. 2.49e+86)  with  low
     computation time but 256 integers memory consumption.
     See MRGRand1457 for a  longer  period  MR-Generator  (2^1457,  i.e. 4.0e+438)  and 
     longer  computation  time  (2^31-1  modulus  calculations)  but  less memory space 
     consumption (47 integers).
-    See MRGRand49507 for a far longer period  (2^49507,  i.e. 1.2e+14903)  with  lower 
-    computation  time  too  (32-bits  modulus)  but  use  of  more  memory space (1597 
-    integers).
-
     
     Class random.Random is sub-subclassed here to use a different basic  generator  of  
     our own devising: in that case, overriden methods are:
@@ -76,7 +72,7 @@ class MRGRand49507( BaseMRG ):
       print( rand(a) )   # prints a uniform pseudo-random value within [0.0, a)
       print( rand(a,b) ) # prints a uniform pseudo-random value within [a  , b)
 
-    Please notice that for simulating the roll of a dice you should program:
+    Notice that for simulating the roll of a dice you should program:
       diceRoll = MRGRand49507()
       print( int(diceRoll(1, 7)) ) # prints a uniform roll within set {1, 2, 3, 4, 5, 6}
 
