seqbuild 0.0.52__tar.gz → 0.0.53__tar.gz

{seqbuild-0.0.52 → seqbuild-0.0.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqbuild
-Version: 0.0.52
+Version: 0.0.53
 Summary: A collection of algorithms for pseudo-random number generation.
 Home-page: https://github.com/Changissnz/seqbuild
 Author: Richard Pham

{seqbuild-0.0.52 → seqbuild-0.0.53}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "seqbuild"
-version = "0.0.52"
+version = "0.0.53"
 dependencies = [
 "numpy>=1.22.1",
 "matplotlib>=3.5.3",

{seqbuild-0.0.52 → seqbuild-0.0.53}/seqbuild/desi/approximators.py

@@ -8,17 +8,39 @@ DEFAULT_FIT22_PARTITION_SIZE_RANGE = (5,103)
 DEFAULT_POLYNOMIAL_PARTITION_SIZE_RANGE = (50,1000)
 DEFAULT_POLYNOMIAL_POINT_SIZE_RANGE = (5,21) 
 
+def default_length_outputter(prg_2vec): 
+    x = list(prg_2vec()) + list(prg_2vec()) 
+    q = prg__LCG(x[0],x[1],x[2],x[3])
+    return prg__single_to_int(q) 
+
+def default_range_outputter(prg_2vec): 
+    x = list(prg_2vec()) + list(prg_2vec()) 
+    q = prg__LCG(x[0],x[1],x[2],x[3])
+    return prg__single_to_range_outputter(q)
+
+def default_bool_outputter(prg_2vec): 
+    return wrap_ranged_modulo_over_generator(\
+        default_length_outputter(prg_2vec),[0,2])
+
+def prg__nvec_to_int_type(px): 
+
+    def f(): 
+        return np.array(px(),dtype=int)
+    return f  
+
 class Fit22ValueOutputter(GenericIntSeqOp): 
 
     def __init__(self,px,length_outputter,range_outputter,bool_outputter,\
             point_conn_type:int,adjustment_type:int=1):  
         assert type(px) in {MethodType,FunctionType}
+        assert type(length_outputter) in {type(None),MethodType,FunctionType}
+        assert type(range_outputter) in {type(None),MethodType,FunctionType}
+        assert type(bool_outputter) in {type(None),MethodType,FunctionType}
+
         assert point_conn_type in {1,2}
-        assert type(bool_outputter) in {MethodType,FunctionType}
 
-        self.px = px 
+        self.px = px  
         self.point_conn_type = point_conn_type
-        self.b_out = bool_outputter
 
         self.p0 = None
         self.p1 = None
@@ -29,6 +51,21 @@ class Fit22ValueOutputter(GenericIntSeqOp):
         self.a_ = None
         self.ax = None 
         
+        if type(length_outputter) != type(None): 
+            length_outputter = prg__single_to_int(length_outputter)
+        else: 
+            length_outputter = default_length_outputter(px) 
+
+        if type(range_outputter) == type(None): 
+            range_outputter = default_range_outputter(px)  
+
+        if type(bool_outputter) == type(None): 
+            bool_outputter = default_bool_outputter(px) 
+        else: 
+            bool_outputter = wrap_ranged_modulo_over_generator(\
+                prg__single_to_int(bool_outputter),[0,2]) 
+
+        self.b_out = bool_outputter 
         super().__init__(length_outputter,range_outputter,adjustment_type)
         return
     
@@ -39,10 +76,18 @@ class Fit22ValueOutputter(GenericIntSeqOp):
             self.update_points() 
         else: pass 
 
-        if self.ax: 
-            sx = self.H.f(self.x_)
-        else: 
-            sx = self.H.g(self.x_) 
+        # do check on input before function apply 
+        A = (self.ax + 1) % 2 
+        qmin = np.min(self.H.ps[:,A]) 
+        qmax = np.max(self.H.ps[:,A]) 
+        x_ = modulo_in_range(self.x_,[qmin,qmax]) 
+
+        QF = self.H.f if self.ax else self.H.g 
+        try: 
+            sx = QF(self.x_)
+        except: 
+            sx = QF(x_)
+
         self.x_ += self.a_ 
 
         sx_ = float_to_string(sx,True,True)
@@ -105,11 +150,21 @@ class LPSValueOutputter(GenericIntSeqOp):
         adjustment_type:int=1): 
         
         assert type(px) in {MethodType,FunctionType}
+        assert type(length_outputter) in {type(None),MethodType,FunctionType}
+        assert type(range_outputter) in {type(None),MethodType,FunctionType}
         self.px = px 
 
         self.p0,self.p1 = None,None 
         self.adder_end,self.adder,self.adder_i = None,None,None
 
+        if type(length_outputter) != type(None): 
+            length_outputter = prg__single_to_int(length_outputter)
+        else: 
+            length_outputter = default_length_outputter(px) 
+
+        if type(range_outputter) == type(None): 
+            range_outputter = default_range_outputter(px)  
+
         super().__init__(length_outputter,range_outputter,adjustment_type)
 
     #--------------------------------------------------------------------------

{seqbuild-0.0.52 → seqbuild-0.0.53}/seqbuild/desi/nvec_gen.py

@@ -1,6 +1,7 @@
 from ..mini_dm.affine_ops import * 
 from math import ceil 
-from morebs2.numerical_generator import prg_partition_for_sz__n_rounds
+from morebs2.numerical_generator import prg_partition_for_sz__n_rounds,prg__single_to_int
+from intigers.extraneous import prg__single_to_range_outputter
 from types import MethodType,FunctionType
 
 DEFAULT_POINTSET_PARTSIZE_RATIO_RANGE = (0.15,0.23)
@@ -20,10 +21,16 @@ class PointSetGen__TypeAffine:
 
     def __init__(self,num_points,prg,ro_prg,ro_prg2,ro_prg3=None):
         assert type(prg) in {FunctionType,MethodType}
-        assert type(ro_prg) in {FunctionType,MethodType}
-        assert type(ro_prg2) in {FunctionType,MethodType}
+        assert type(ro_prg) in {FunctionType,MethodType,type(None)}
+        assert type(ro_prg2) in {FunctionType,MethodType,type(None)} 
         assert type(ro_prg3) in {FunctionType,MethodType,type(None)}
 
+        if type(ro_prg) == type(None): 
+            ro_prg = prg__single_to_range_outputter(deepcopy(prg))
+        if type(ro_prg2) == type(None): 
+            ro_prg2 = prg__single_to_range_outputter(deepcopy(prg)) 
+        
+
         self.num_points = None 
         self.set_num_points(num_points)
         # outputs single integers 
@@ -65,7 +72,7 @@ class PointSetGen__TypeAffine:
         rx = int(ceil(n * r))
         var = 0.5 
         num_rounds = 5 
-        prt = prg_partition_for_sz__n_rounds(n,rx,self.prg,var,num_rounds)
+        prt = prg_partition_for_sz__n_rounds(n,rx,prg__single_to_int(self.prg),var,num_rounds)
         return prt 
     
     def set_num_points(self,n): 
@@ -92,7 +99,7 @@ class PointSetGen__TypeAffine:
         self.gen_ad_parameters = [None,None,None]
 
     def one_new_AffineDelta(self):
-        return AffineDelta.one_instance_(self.prg,\
+        return AffineDelta.one_instance_(prg__single_to_int(self.prg),\
             self.ro_prg,self.ro_prg2,dim_range=self.gen_ad_parameters[0],\
             ma_order=self.gen_ad_parameters[1])
     
@@ -100,7 +107,7 @@ class PointSetGen__TypeAffine:
         assert is_valid_range(size_range,inclusive=False)   
         
         ad = self.one_new_AffineDelta()
-        num_points = modulo_in_range(self.prg(), size_range)
+        num_points = modulo_in_range(int(self.prg()), size_range)
         L = []
         L0 = [] 
         for _ in range(num_points):
@@ -162,9 +169,12 @@ class PointSetGen__TypeAffine:
         lx = len(self.point_seq) 
         for i in range(self.num_points): 
             adi = modulo_in_range(int(self.prg()),index_range)
-            p = self.ad_seq[adi].fit(self.prg())
-            p = self.modulate_point(p) 
-            self.point_seq.append(p) 
+
+            x,q = self.one_io_pair(self.ad_seq[adi]) 
+            q = self.modulate_point(q) 
+
+            self.input_seq.append(x)
+            self.point_seq.append(q)  
             self.ad_indices_seq[adi].append(i+lx)
             
         return

seqbuild-0.0.53/seqbuild/seqgen/fit22_gen.py

@@ -0,0 +1,65 @@
+from ..desi.approximators import * 
+
+DEFAULT_FIT22GEN_ADJTYPE_RATE_CHANGE = [13,69] 
+DEFAULT_FIT22GEN_ADJTYPE_RATE_CHANGE_2 = [9,95] 
+
+
+class Fit22Gen(Fit22ValueOutputter): 
+
+    def __init__(self,prg1,prg2,prg3,prg4,adjtype1_rate_change_range = DEFAULT_FIT22GEN_ADJTYPE_RATE_CHANGE,\
+        adjtype2_rate_change_range= DEFAULT_FIT22GEN_ADJTYPE_RATE_CHANGE_2): 
+        assert type(prg1) in {MethodType,FunctionType} 
+
+        assert is_valid_range(adjtype1_rate_change_range,True,False)
+        assert adjtype1_rate_change_range[0] > 0
+
+        assert is_valid_range(adjtype2_rate_change_range,True,False)
+        assert adjtype2_rate_change_range[0] > 0
+
+        prg1 = prg__single_to_nvec(prg1,2) 
+
+        if type(prg3) in {MethodType,FunctionType}: 
+            prg3 = prg__single_to_range_outputter(prg3) 
+
+        super().__init__(prg1,prg2,prg3,prg4,\
+            point_conn_type=1,adjustment_type=1)
+
+        self.atr_crange = adjtype1_rate_change_range
+        self.atr2_crange = adjtype2_rate_change_range
+        self.change1_threshold = self.atr_crange[0]  
+        self.change2_threshold = self.atr2_crange[0]  
+
+        self.c1 = 0 
+        self.c2 = 0 
+
+    def next_change_threshold(self,v,type_number):
+        assert type_number in {1,2}
+
+        if type_number == 1: 
+            self.change1_threshold = modulo_in_range(int(v),self.atr_crange)
+        else: 
+            self.change2_threshold = modulo_in_range(int(v),self.atr2_crange)
+
+    def switch_mode(self,x,type_number):
+        if type_number == 1:  
+            if self.c1 >= self.change1_threshold: 
+                self.c1 = 0 
+                self.adj_type = modulo_in_range((self.adj_type + 1),[1,3])
+                self.next_change_threshold(x,type_number) 
+            return 
+
+        if self.c2 >= self.change2_threshold: 
+            self.c2 = 0 
+            self.point_conn_type = modulo_in_range((self.point_conn_type + 1),[1,3])
+            self.next_change_threshold(x,type_number) 
+
+    def __next__(self):
+
+        x = super().__next__() 
+
+        self.c1 += 1 
+        self.c2 += 1 
+
+        self.switch_mode(x,1)
+        self.switch_mode(x,2)
+        return x 

{seqbuild-0.0.52 → seqbuild-0.0.53}/seqbuild/seqgen/gg_gen.py

@@ -220,12 +220,7 @@ class GaugeGuidedGen:
         scp = SeqCoveragePermuter(V,coverage_delta,\
             DEFAULT_AGV2GG_COVERAGE_RADIUS,sub_range,self.base_prg,delta_type=1)
         scp.set_partition(self.cat_size) 
-        return scp.apply() 
-
-    def permute_uwpd(self,V): 
-        sub_range = self.active_ranges[int(self.base_prg()) % len(self.active_ranges)]
-        sup = SeqUWPDPermuter(V,uwpd_delta,sub_range,self.base_prg)
-        return sup.apply()
+        return scp.apply()
 
     def compare_with_previous(self,V): 
         if len(self.mvec) == 0: return None,None,None 

seqbuild-0.0.53/seqbuild/seqgen/lps_gen.py

@@ -0,0 +1,43 @@
+
+from ..desi.approximators import * 
+
+DEFAULT_LPSGEN_ADJTYPE_RATE_CHANGE_RANGE = [10,91] 
+
+"""
+Subclass of class<LPSValueOutputter>. Initialized with 1-3 PRNGs, all 
+of them outputting single real numbers at every call. Reformatted 
+to output lengths and ranges, before instantiating class<LPSValueOutputter>. 
+"""
+class LPSGen(LPSValueOutputter):
+
+    def __init__(self,prg1,prg2,prg3,adjustment_type_rate_change_range=DEFAULT_LPSGEN_ADJTYPE_RATE_CHANGE_RANGE): 
+        assert type(prg1) in {MethodType,FunctionType} 
+        assert is_valid_range(adjustment_type_rate_change_range,True,False)
+        assert adjustment_type_rate_change_range[0] > 0
+
+        prg1 = prg__single_to_nvec(prg1,2) 
+
+        if type(prg3) in {MethodType,FunctionType}: 
+            prg3 = prg__single_to_range_outputter(prg3) 
+    
+        super().__init__(prg1,prg2,prg3,\
+            adjustment_type=1)
+
+        self.atr_crange = adjustment_type_rate_change_range
+        self.change_threshold = self.atr_crange[0]  
+        self.c = 0 
+
+    def next_change_threshold(self,v): 
+        self.change_threshold = modulo_in_range(int(v),self.atr_crange) 
+
+    def __next__(self):
+
+        x = super().__next__() 
+
+        self.c += 1 
+        if self.c >= self.change_threshold: 
+            self.c = 0 
+            self.adj_type = modulo_in_range((self.adj_type + 1),[1,3])
+            self.next_change_threshold(x) 
+
+        return x 

seqbuild-0.0.53/seqbuild/seqgen/n2mv_gen.py

@@ -0,0 +1,91 @@
+from ..intigers.n2mvf_autogen import *
+from morebs2.numerical_generator import prg__LCG,prg__single_to_nvec
+from collections import deque 
+
+DEFAULT_N2MV_GEN_FILLER_PRG2_MODULO = 7891
+
+"""
+The PRNG `prg` is the primary generator: this generator uses `prg` 
+to produce input vectors of dimension n to output m-vectors from the 
+current <N2MVectorFunction>. 
+
+The main `__next__` function outputs values from its queue. 
+
+When `queue` is empty, generator has its <N2MVectorFunctionGen> produce 
+a <N2MVectorFunction> F. Then F outputs an m-vector. That m-vector is added 
+to `queue`. After some k >= (s in `update_frequency_range`) output values, 
+this generator instantiates another <N2MVectorFunctionGen>. 
+
+See file<intigers.n2mvf_autogen> for more details on 
+"""
+class N2MVGen: 
+
+    def __init__(self,nm_range,prg,prg2,update_frequency_range):
+        assert is_valid_range(nm_range,True,False) 
+        assert type(prg) in {FunctionType,MethodType} 
+        assert type(prg2) in {FunctionType,MethodType,type(None)} 
+        assert is_valid_range(update_frequency_range,True,False)
+
+        self.nm_range = nm_range 
+        self.prg = prg__single_to_int(prg) 
+
+        self.prg2 = prg2 
+        if type(self.prg2) != type(None):  
+            self.prg2 = prg__single_to_int(prg2)   
+
+        self.nvfg = None 
+
+        self.queue = deque() 
+
+        self.nvfg = None 
+        self.current_input_dim = None 
+
+        self.uf_range = update_frequency_range
+        self.update_threshold = None 
+        self.update_ctr = 0 
+        self.filler_prg2() 
+        self.next_NVMVFGen() 
+
+    def __next__(self): 
+        if len(self.queue) == 0: 
+            self.next_vector() 
+        return self.queue.popleft()
+
+    def next_NVMVFGen(self): 
+
+        n = modulo_in_range(int(self.prg()),self.nm_range) 
+        m = modulo_in_range(int(self.prg()),self.nm_range) 
+
+        nm = (n,m)
+        self.current_input_dim = n 
+
+        mode = "replace" if int(self.prg()) % 2 else "accumulate"
+        self.nvfg = N2MVectorFunctionGen(nm,self.prg,self.prg2,mode)
+
+        self.update_threshold = modulo_in_range(int(self.prg()),self.uf_range) 
+        self.update_ctr = 0 
+
+    def next_vector(self): 
+        q = prg__single_to_nvec(self.prg,self.current_input_dim)() 
+        F = self.nvfg.one_N2MVF() 
+        mvec = F.apply(q)
+
+        self.update_ctr += len(mvec)  
+
+        self.queue.extend(mvec)  
+
+        if self.update_ctr >= self.update_threshold: 
+            self.next_NVMVFGen()
+
+    """
+    an LCG, in cases where `prg2` is null.
+    """
+    def filler_prg2(self): 
+        if type(self.prg2) != type(None): 
+            return 
+
+        x = prg_unique_sequence(self.prg,4) 
+        if x[-1] == 0: 
+            x[-1] = DEFAULT_N2MV_GEN_FILLER_PRG2_MODULO
+        self.prg2 = prg__LCG(x[0],x[1],x[2],x[3]) 
+

{seqbuild-0.0.52 → seqbuild-0.0.53}/seqbuild.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqbuild
-Version: 0.0.52
+Version: 0.0.53
 Summary: A collection of algorithms for pseudo-random number generation.
 Home-page: https://github.com/Changissnz/seqbuild
 Author: Richard Pham

{seqbuild-0.0.52 → seqbuild-0.0.53}/seqbuild.egg-info/SOURCES.txt

@@ -106,9 +106,12 @@ seqbuild/mini_dm/nsfr.py
 seqbuild/mini_dm/puc.py
 seqbuild/mini_dm/sp_op.py
 seqbuild/seqgen/__init__.py
+seqbuild/seqgen/fit22_gen.py
 seqbuild/seqgen/gg_gen.py
 seqbuild/seqgen/idt_gen.py
+seqbuild/seqgen/lps_gen.py
 seqbuild/seqgen/mdr_gen.py
+seqbuild/seqgen/n2mv_gen.py
 seqbuild/seqgen/optri_gen.py
 seqbuild/seqgen/rch_gen.py
 seqbuild/seqgen/sb_crypt.py

{seqbuild-0.0.52 → seqbuild-0.0.53}/setup.py

@@ -5,7 +5,7 @@ with open('README.md') as f:
 
 setup(
     name='seqbuild',
-    version='0.0.52',
+    version='0.0.53',
     description='A collection of algorithms for pseudo-random number generation.',
     long_description=readme,
     author='Richard Pham',