algorithm shit

Random/generators.py

 ## Various Random Generators ##
 import random
-
+import numpy as np
 
 class RandomNumberGenerator:
     def __init__(self):
@@ -29,7 +29,7 @@ class RandomNumberGenerator:
         """
         return n normalized values
         """
-        return [self.random() for i in range(n)] / self.max
+        return np.divide(np.array([self.random() for i in range(n)]),self.max)
 
 
 class LCG(RandomNumberGenerator):
@@ -62,7 +62,7 @@ class ParkMiller(LCG):
     """
 
     def __init__(self):
-        super().__init__(16807, 0, 2147483647)
+        super().__init__(16807, 0, (2**31) - 1)
 
 
 class KnuthLewis(LCG):
@@ -71,7 +71,7 @@ class KnuthLewis(LCG):
     """
 
     def __init__(self):
-        super().__init__(1664525, 1013904223, 4294967296)
+        super().__init__(1664525, 1013904223, 2**32)
 
 
 class Marsaglia(LCG):
@@ -80,7 +80,7 @@ class Marsaglia(LCG):
     """
 
     def __init__(self):
-        super().__init__(69069, 0, 4294967296)
+        super().__init__(69069, 0, 2**32)
 
 
 class LavauxJenssens(LCG):
@@ -89,7 +89,7 @@ class LavauxJenssens(LCG):
     """
 
     def __init__(self):
-        super().__init__(31167285, 1, 281474976710656)
+        super().__init__(31167285, 1, 2**48)
 
 
 class Haynes(LCG):
@@ -98,7 +98,7 @@ class Haynes(LCG):
     """
 
     def __init__(self):
-        super().__init__(6364136223846793005, 1, 18446744073709552000)
+        super().__init__(6364136223846793005, 1, 2**64)
 
 
 class LaggedFibonnaci(RandomNumberGenerator):
@@ -157,6 +157,9 @@ class MersenneTwister(RandomNumberGenerator):
     def random(self):
         return self.randomNorm()
 
+    def batchRandomNormalized(self,n):
+        return np.array([self.random() for i in range(n)])
+
 
 class CNS(RandomNumberGenerator):
     """

Random/graph.py

+"""
+Module for graphing
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+import seaborn as sns
+
+def hist_distributivity_graph(N,RESOLUTION,seed,data):
+    """
+    graphs histograms
+    see values function in main module
+    """
+    for name in data:
+        print("building "+str(name)+" histogram...")
+        xlabel= "Value"
+        ylabel="Count"
+        title_name= name +"\n N = "+str(N)+"\n seed = "+str(seed) 
+        graph=sns.displot(data[name], kde=True)
+        graph.set(title=title_name)
+        graph.set_axis_labels(xlabel,ylabel)
+        graph.savefig(name+'_hist.png', bbox_inches='tight')
+    return
+
+def ecdf_graph(N,RESOLUTION,seed,data):
+    """
+    graphs histograms
+    see values function in main module
+    """
+    plt.clf()
+    for name in data:
+        print("building "+str(name)+" ecdf...")
+        xlabel= "Value"
+        ylabel="Cumulative Probability"
+        title_name= name +"\n N = "+str(N)+"\n seed = "+str(seed) 
+        graph=sns.displot(data[name], kind="ecdf")
+        graph.set(title=title_name)
+        graph.set_axis_labels(xlabel,ylabel)
+        graph.savefig(name+'_ecdf.png', bbox_inches='tight')
+    return
+
+def compare(N, RESOLUTION, seed, data):
+    """
+    Create graphs superposing two, already generated,
+    distributivity
+    """
+    plt.clf()
+    BW = 0.337
+    name = "compare_"
+    for e in data:
+        name += e+"_"
+    
+    #subdata = {k : data[k] for k in names}  
+    print("graphing "+str(name)+"...")
+    
+    xlabel = "Value"
+    ylabel = "Density"
+    title_name="N = "+str(N)+"\n seed = "+str(seed)
+    if N == 0:
+        title_name = "seed = "+str(seed)
+    graph=sns.kdeplot(data,legend=True,bw_adjust=BW,common_norm=False)
+    graph.set(title=title_name)
+    plt.xlabel(xlabel)
+    plt.ylabel(ylabel)
+    plt.savefig(name+'.png', bbox_inches='tight')    
+    return

Random/main.py

 from generators import *
+import graph
 from datetime import datetime
 import matplotlib.pyplot as plt
 import numpy as np
 import seaborn as sns
 
-if __name__=="__main__":
+#shut up stupid warnings from not "the-most-up-to-date" libraries
+import warnings
+warnings.simplefilter(action='ignore', category=FutureWarning)
 
-    ##INIT PARAMS##
-    N = 1000000
-    RESOLUTION = 100
-    #set seaborn params
-    sns.set_theme(style="darkgrid")
-    
-    #bandwidth for smooth density
-    #https://en.wikipedia.org/wiki/Kernel_density_estimation#Bandwidth_selection
-    BW = 0.337
-    
-    #init generators
-    generators = [ParkMiller(), KnuthLewis(), Marsaglia()
-                  , LavauxJenssens(), Haynes(), MitchelMoore()
-                  , MersenneTwister(), BlumBlumShub()]
-    
-    #init seed on timesystem 
-    seed = datetime.now().timestamp()
-    
+def subdict(keys,dictio):
+    return {k : dictio[k] for k in keys} 
+
+def values(N, seed, generators):
+    """
+    random values N elements and given seed.
+    Returns a dictionnary with values
+    """ 
+    results = {}  
     #generate each diagrams for each random func
     for e in generators:
         name = type(e).__name__
@@ -31,14 +25,48 @@ if __name__=="__main__":
         print("processing "+name+"...")
         e.seed(seed)
         res = e.batchRandomNormalized(N)
-        results.append(results)
+        results[name] = res
+    return results
+
+def iteratives(N, seed, generator):
+    """
+    Random values iteratively with same seed and list N
+    """ 
+    results = {}  
+    #generate each diagrams for each random func
+    for n in N:
+        name = type(generator).__name__+"_"+str(n)
         
-        print("building histograms..") 
-        fig, ax = plt.subplots()
-        sns.displot(res, kde=True)
-        ax.set_xlabel('Value')
-        ax.set_ylabel('Probability density')
-        ax.set_title(type(e).__name__)
-        plt.savefig(type(e).__name__+'.png')
+        print("processing "+name+"...")
+        generator.seed(seed)
+        res = generator.batchRandomNormalized(n)
+        results[name] = res
+    return results
 
-    #generate diagrams with all randoms
+if __name__=="__main__":
+    ##INIT PARAMS##
+    N = 100
+    RESOLUTION = 1000
+    
+    #init generators
+    generators = [ParkMiller(), KnuthLewis(), Marsaglia()
+                  , LavauxJenssens(), Haynes(), MitchelMoore()
+                  , MersenneTwister(), BlumBlumShub()]
+    
+    #init seed on timesystem 
+    seed = int(datetime.now().timestamp())
+    
+    #set seaborn params
+    sns.set_theme(style="darkgrid")
+     
+    #generate all diagrams
+    data = values(N,seed,generators)
+    
+    #graph.hist_distributivity_graph(N,RESOLUTION,seed,data)
+    #graph.compare(N, RESOLUTION, seed
+    #           , subdict(["ParkMiller","KnuthLewis","Haynes"], data))
+    
+    #graph.ecdf_graph(N,RESOLUTION,seed,data)
+    
+    graph.compare(0, RESOLUTION, seed
+                  , iteratives([1000, 100000, 100000000], seed, ParkMiller()))