Merge pull request #18 from schmouk/optimize-code

Optimize code

Author: schmouk

PyRandLib/README.md

@@ -9,7 +9,7 @@ If you decide to use this library,  please add the copyright notice to  your
 software as stated in the LICENSE file.
 
 ```
-Copyright (c) 2016-2021 Philippe Schmouker, schmouk (at) typee.ovh
+Copyright (c) 2016-2021 Philippe Schmouker, <ph.schmouker (at) gmail.com>
 
 Permission is hereby granted,  free of charge,  to any person obtaining a copy
 of this software and associated documentation files (the "Software"),  to deal
@@ -106,12 +106,21 @@ implemented in PyRabdLib, as provided in [1].
 
 
 ## Implementation
-Current implementation of PyRandLib uses Python 3.x with no Cython version.  
-It has been tested with Python 3.8 but should run with most of Python 3 suvbversions.
+Current implementation of PyRandLib uses Python 3.x with no Cython  version.  
+It  has  been  tested  with  Python 3.8 but should run with all of Python 3.
 
-Python 2.7 could be later available,  if asked for.  Cython  implementations
-could also be later available.
+Note 1: PyRandLib version 1.1 and below should work  with  all  versions  of
+Python 3.  In  version 1.2, we have added underscores in numerical constants
+for the better readability of the code.  This feature has been introduced in
+Python 3.6.  If  you  want to use PyRandLib version 1.2 or above with Python
+3.5 or below,  removing these underscores should be sufficient to  have  the
+library running correctly. 
 
+Note 2:  no version or PyRandLib will ever be provided for Python 2 which is 
+a no more maintained version of the Python language.
+
+Note 3:  a Cython version of PyRandLib might be delivered in a next release.
+Up today, no date is planned for this.
 
 
 ## Architecture overview

PyRandLib/baselfib64.py

@@ -24,7 +24,7 @@
 
 #=============================================================================
 from .baserandom import BaseRandom
-from .fastrand63 import FastRand63
+from .fastrand32 import FastRand32
 from .types      import SeedStateType, StateType
 
 
@@ -59,7 +59,7 @@ class BaseLFib64( BaseRandom ):
     See LFib78,  LFib116,  LFib668 and LFib1340 for long period LFib generators (resp. 
     2^78,  2^116,  2^668 and 2^1340 periods, i.e. resp. 3.0e+23, 8.3e+34, 1.2e+201 and 
     2.4e+403 periods) while same computation time and far  higher  precision  (64-bits  
-    calculations)  then  MRGs,  but  memory  consumption  (resp. 17,  55, 607 and 1279 
+    calculations) than MRGs,  but more memory consumption (resp. 17,  55, 607 and 1279 
     integers).
     
     Please notice that this class and all its  inheriting  sub-classes  are  callable.
@@ -151,17 +151,24 @@ def setstate(self, _seedState: StateType) -> None:
         (e.g. None) then the shuffling  of  the  local  current  time
         value is used as such an initial seed.
         """
-        if not isinstance( _seedState, tuple ):
-            self._initIndex( 0 )
-            self._initList( _seedState )
+        try:
+            count = len( _seedState )
 
-        elif len( _seedState ) < 2:
+            if count == 0:
+                self._initIndex( 0 )
+                self._initList()
+                
+            elif count == 1:
+                self._initIndex( 0 )
+                self._initList( _seedState[0] )
+                
+            else:
+                self._initIndex( _seedState[1] )
+                self._list = _seedState[0][:]
+                
+        except:
             self._initIndex( 0 )
-            self._initList( _seedState[0] )
-            
-        else:
-            self._initIndex( _seedState[1] )
-            self._list = _seedState[0][:]
+            self._initList( _seedState )
 
 
     #------------------------------------------------------------------------=
@@ -183,15 +190,8 @@ def _initList(self, _initialSeed: StateType = None) -> None:
         [0.0, 1.0).  Should it be None or anything  else  then  the
         current local time value is used as initial seed value.
         """
-        myRand = FastRand63( _initialSeed )
-        #-----------------------------------------------------------------
-        def _getValue( _dummy ):
-            myRand()
-            v = myRand._value << 1
-            return v + (1 if myRand() >= 0.5 else 0)
-        #-----------------------------------------------------------------
-        self._list = list( map( _getValue, range(self._LIST_SIZE) ) )
+        myRand = FastRand32( _initialSeed )
+        self._list = [ (int(myRand(0x1_0000_0000)) << 32) + int(myRand(0x1_0000_0000)) for _ in range(self._LIST_SIZE) ]        
 
- 
 #=====   end of module   baselfib64.py   =====================================
 

PyRandLib/basemrg.py

@@ -147,17 +147,24 @@ def setstate(self, _seedState: StateType) -> None:
         (e.g. None) then the shuffling  of  the  local  current  time
         value is used as such an initial seed.
         """
-        if not isinstance( _seedState, tuple ):
-            self._initIndex( 0 )
-            self._initList( _seedState )
+        try:
+            count = len( _seedState )
 
-        elif len( _seedState ) < 2:
+            if count == 0:
+                self._initIndex( 0 )
+                self._initList()
+                
+            elif count == 1:
+                self._initIndex( 0 )
+                self._initList( _seedState[0] )
+                
+            else:
+                self._initIndex( _seedState[1] )
+                self._list = _seedState[0][:]
+                
+        except:
             self._initIndex( 0 )
-            self._initList( _seedState[0] )
-            
-        else:
-            self._initIndex( _seedState[1] )
-            self._list = _seedState[0][:]
+            self._initList( _seedState )
 
 
     #------------------------------------------------------------------------=
@@ -181,8 +188,7 @@ def _initList(self, _initialSeed: StateType = None) -> None:
         """
         # feeds the list according to an initial seed and the value+1 of the modulo.
         myRand = FastRand32( _initialSeed )
-        my_list = list( map( lambda _ : int(myRand(self._MODULO+1)), range(self._LIST_SIZE) ) )
-        self._list = my_list
+        self._list = [ int(myRand(self._MODULO+1)) for _ in range(self._LIST_SIZE) ]
 
 
 #=====   end of module   basemrg.py   ========================================

PyRandLib/baserandom.py

@@ -24,6 +24,7 @@
 
 #=============================================================================
 from random import Random
+from typing import Any
 
 from .types import Numeric, SeedStateType
 
@@ -217,12 +218,20 @@ class BaseRandom( Random ):
     def __init__(self, _seed: SeedStateType = None) -> None:
         """Constructor.
         
-        Should _seed be None or not an integer then the 
-        local time is used (with its shuffled value) as a seed.
+        Should _seed be None or not an integer then the local 
+        time is used (with its shuffled value) as a seed.
         """
         super().__init__( _seed )  ## this call creates attribute self._value and sets it
 
 
+    #------------------------------------------------------------------------=
+    @property
+    def value(self) -> Any:
+        """Read-only wrapper to built-in attribute '._value'
+        """
+        return self._value
+        
+        
     #------------------------------------------------------------------------=
     def seed(self, _seed: SeedStateType = None) -> None:
         """Initiates the internal state of this pseudo-random generator.

PyRandLib/fastrand32.py

@@ -108,8 +108,8 @@ def random(self) -> float:
         
         Returned values are within [0.0, 1.0).
         """
-        self._value = (69069 * self._value + 1) & 0xffffffff
-        return self._value / 4294967296.0
+        self._value = (69069 * self._value + 1) & 0xffff_ffff
+        return self._value / 4_294_967_296.0
 
 
     #------------------------------------------------------------------------=
@@ -123,23 +123,23 @@ def setstate(self, _state: Numeric) -> None:
         """
         if isinstance( _state, int ):
             # passed initial seed is an integer, just uses it
-            self._value = _state & 0xffffffff
+            self._value = _state & 0xffff_ffff
 
         elif isinstance( _state, float ):
             # transforms passed initial seed from float to integer
             if _state < 0.0 :
                 _state = -_state
             if _state >= 1.0:
-                self._value = int( _state + 0.5 ) & 0xffffffff
+                self._value = int( _state + 0.5 ) & 0xffff_ffff
             else:
-                self._value = int( _state * 0x100000000) & 0xffffffff
+                self._value = int( _state * 0x1_0000_0000) & 0xffff_ffff
 
         else:
             # uses local time as initial seed
             t = int( time.time() * 1000.0 )
-            self._value = ( ((t & 0xff000000) >> 24) +
-                            ((t & 0x00ff0000) >>  8) +
-                            ((t & 0x0000ff00) <<  8) +
-                            ((t & 0x000000ff) << 24)   )
+            self._value = ( ((t & 0xff00_0000) >> 24) +
+                            ((t & 0x00ff_0000) >>  8) +
+                            ((t & 0x0000_ff00) <<  8) +
+                            ((t & 0x0000_00ff) << 24)   )
 
 #=====   end of module   fastrand32.py   =====================================

PyRandLib/fastrand63.py

@@ -98,8 +98,8 @@ def random(self) -> float:
         
         Returned values are within [0.0, 1.0).
         """
-        self._value = (9219741426499971445 * self._value + 1) & 0x7fffffffffffffff
-        return self._value / 9223372036854775808.0
+        self._value = (9_219_741_426_499_971_445 * self._value + 1) & 0x7fff_ffff_ffff_ffff
+        return self._value / 9_223_372_036_854_775_808.0
 
 
     #------------------------------------------------------------------------=
@@ -112,24 +112,24 @@ def setstate(self, _state: Numeric) -> None:
         setstate() was called.
         """
         if isinstance( _state, int ):
-            self._value = _state & 0x7fffffffffffffff
+            self._value = _state & 0x7fff_ffff_ffff_ffff
 
         elif isinstance( _state, float ):
             # transforms passed initial seed from float to integer
             if _state < 0.0 :
                 _state = -_state
 
             if _state >= 1.0:
-                self._value = int(_state+0.5) & 0x7fffffffffffffff
+                self._value = int(_state+0.5) & 0x7fff_ffff_ffff_ffff
             else:
-                self._value = int(_state*0x8000000000000000) & 0x7fffffffffffffff
+                self._value = int(_state*0x8000_0000_0000_0000) & 0x7fff_ffff_ffff_ffff
 
         else:
             t = int(time.time() * 1000.0)
-            self._value = t & 0xffffffff
-            self._value += (t & 0xff000000) <<  8
-            self._value += (t & 0x00ff0000) << 24
-            self._value += (t & 0x0000ff00) << 40
-            self._value += (t & 0x000000fe) << 63
+            self._value = t & 0xffff_ffff
+            self._value += (t & 0xff00_0000) <<  8
+            self._value += (t & 0x00ff_0000) << 24
+            self._value += (t & 0x0000_ff00) << 40
+            self._value += (t & 0x0000_00fe) << 63
 
 #=====   end of module   fastrand63.py   =====================================

PyRandLib/lfib116.py

@@ -126,14 +126,14 @@ def random(self) -> float:
             k24 += LFib116._LIST_SIZE
 
         # then evaluates current value
-        myValue = (self._list[k24] + self._list[self._index]) & 18446744073709551615
+        myValue = (self._list[k24] + self._list[self._index]) & 18_446_744_073_709_551_615
         self._list[self._index] = myValue
 
         # next index
         self._index = (self._index+1) % LFib116._LIST_SIZE
 
         # then returns float value within [0.0, 1.0)
-        return  myValue / 18446744073709551616.0
+        return  myValue / 18_446_744_073_709_551_616.0
 
 
 #=====   end of module   lfib116.py   ========================================

PyRandLib/lfib1340.py

@@ -127,14 +127,14 @@ def random(self) -> float:
             k861 += LFib1340._LIST_SIZE
 
         # then evaluates current value
-        myValue = (self._list[k861] + self._list[self._index]) & 0xffffffffffffffff
+        myValue = (self._list[k861] + self._list[self._index]) & 0xffff_ffff_ffff_ffff
         self._list[self._index] = myValue
 
         # next index
         self._index = (self._index+1) % LFib1340._LIST_SIZE
 
         # then returns float value within [0.0, 1.0)
-        return  myValue / 18446744073709551616.0
+        return  myValue / 18_446_744_073_709_551_616.0
 
 
 #=====   end of module   lfib1340.py   ======================================

PyRandLib/lfib668.py

@@ -126,14 +126,14 @@ def random(self) -> float:
             k273 += LFib668._LIST_SIZE
 
         # then evaluates current value
-        myValue = (self._list[k273] + self._list[self._index]) & 18446744073709551615
+        myValue = (self._list[k273] + self._list[self._index]) & 18_446_744_073_709_551_615
         self._list[self._index] = myValue
 
         # next index
         self._index = (self._index+1) % LFib668._LIST_SIZE
 
         # then returns float value within [0.0, 1.0)
-        return  myValue / 18446744073709551616.0
+        return  myValue / 18_446_744_073_709_551_616.0
 
 
 #=====   end of module   lfib668.py   =======================================

PyRandLib/lfib78.py

@@ -125,14 +125,14 @@ def random(self) -> float:
             k5 += LFib78._LIST_SIZE
 
         # then evaluates current value
-        myValue = (self._list[k5] + self._list[self._index]) & 18446744073709551615
+        myValue = (self._list[k5] + self._list[self._index]) & 18_446_744_073_709_551_615
         self._list[self._index] = myValue
 
         # next index
         self._index = (self._index+1) % LFib78._LIST_SIZE
 
         # then returns float value within [0.0, 1.0)
-        return  myValue / 18446744073709551616.0
+        return  myValue / 18_446_744_073_709_551_616.0
 
 
 #=====   end of module   lfib78.py   =========================================