seqbuild 0.0.73__tar.gz → 0.0.74__tar.gz

{seqbuild-0.0.73/seqbuild.egg-info → seqbuild-0.0.74}/PKG-INFO

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

{seqbuild-0.0.73 → seqbuild-0.0.74}/pyproject.toml

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

{seqbuild-0.0.73 → seqbuild-0.0.74}/seqbuild/desi/approximators.py

@@ -186,8 +186,10 @@ class LPSValueOutputter(GenericIntSeqOp):
         return 
     
     def update_points(self):
+        # NOTE: add ranged moduli over PRNG to ensure timely Lagrange Polynomial solve. 
+        q = wrap_ranged_modulo_over_generator(self.px,[-100-2/3,100+1/3])
+        self.q = LPSValueOutputter.new_pointset(q,self.l_out) 
 
-        self.q = LPSValueOutputter.new_pointset(self.px,self.l_out) 
 
         # assumes q is a proper set of points for 
         # fitting via <LagrangePolySolver>

{seqbuild-0.0.73 → seqbuild-0.0.74}/seqbuild/desi/cy_metric.py

@@ -76,10 +76,13 @@ class CycleMetric:
 
         prefixes = set(self.M_.M.keys())
         S = dict() 
+        print("num prefixes: ",len(prefixes))
         for p in prefixes: 
+            print("processing: ",p)
             P,d0,v0 = self.process_prefix(p) 
             self.prefix2mcs_map[p] = P 
             self.prefix2score_map[p] = (d0,v0) 
+        print("")
         return
 
     """
@@ -149,6 +152,7 @@ class CycleMetric:
 
         prefix_info = self.M_.key_to_seq_by_type(prefix,measure_type) 
         ##print("PREFIX: ",prefix_info)
+        ## print("MCS LEN: ",len(prefix_info))
         ms = MCSSearch(prefix_info,self.cast_func)
         ms.search() 
 

{seqbuild-0.0.73 → seqbuild-0.0.74}/seqbuild/desi/differentials.py

@@ -75,7 +75,10 @@ class PIDValueOutputter(GenericIntSeqOp):
         stat = (self.adder_i % self.fvec_frequency) == 0
 
         if stat:
-            self.pic.modulate_dcurve_of_point(x) 
+            try: 
+                self.pic.modulate_dcurve_of_point(x) 
+            except: 
+                print("...strange...")
 
         q = self.pic.differential_at(x,lps_first=True)
         self.adder_i += 1 

seqbuild-0.0.74/seqbuild/face/chained_prng_cmp.py

@@ -0,0 +1,100 @@
+from .prng_stats import * 
+from .make_cmd import MAIN_method_for_object
+
+class ChainedPRNGComparator: 
+
+    def __init__(self,prng_struct_seq,prg_varname,ngram_info,partition_size,\
+        output_prg_range=None,do_embed_generators:bool=True): 
+
+        if type(output_prg_range) != type(None): 
+            assert is_valid_range(output_prg_range,True,False) or is_valid_range(output_prg_range,False,False)
+        assert len(prng_struct_seq) > 1 
+        assert type(do_embed_generators) == bool 
+
+        self.prng_struct_seq = prng_struct_seq
+        self.prg_varname = prg_varname 
+        self.ngram_info = ngram_info
+        self.psize = partition_size
+        self.output_prg_range = output_prg_range 
+        self.do_embed = do_embed_generators
+
+        self.pstat_seq = None 
+        self.preproc() 
+        self.processed = False 
+        return 
+
+    def preproc(self): 
+
+        # set every prng struct's parameter `prg_varname` to the previous prng. 
+        if self.do_embed: 
+            for i in range(1,len(self.prng_struct_seq)): 
+                q0 = deepcopy(self.prng_struct_seq[i-1]) 
+                prg = MAIN_method_for_object(q0) 
+                setattr(self.prng_struct_seq[i],self.prg_varname,prg) 
+
+        prgs = [MAIN_method_for_object(p) for p in self.prng_struct_seq] 
+
+        # apply modulii range if not None 
+        if type(self.output_prg_range) != type(None): 
+            prgs = [wrap_ranged_modulo_over_generator(p,self.output_prg_range) for p in \
+                prgs] 
+
+        # initialize PRNGStats for every generator 
+        self.pstat_seq = [PRNGStats(p,self.ngram_info,self.psize) for p in prgs] 
+
+    def run(self): 
+        for (i,x) in enumerate(self.pstat_seq):
+            print("* running input prng #{}".format(i))
+            x.run() 
+        self.processed = True 
+
+    # NOTE: duplicate code with <PRNGIOStats.cmp_matrix>. 
+    def cmp_matrix(self,metric_numbers:set = {1,2,3,4,5,6,7}): 
+        if not self.processed: 
+            print("[!] comparator has not processed all PRNGs") 
+            return 
+
+        M = np.zeros((len(self.prng_struct_seq),len(self.prng_struct_seq))) + np.nan
+
+        for i in range(len(self.pstat_seq) - 1): 
+            for j in range(i+1,len(self.pstat_seq)): 
+                b = self.boolcmp_stats(j,i,metric_numbers)
+                M[i,j] = b 
+        return M 
+
+
+    # NOTE: duplicate code of method<PRNGIOStats.boolcmp_stats> 
+    """
+    return: 
+    1(more random)|-1(less random)|0(equally random)
+    """
+    def boolcmp_stats(self,i0,i1,metric_numbers:set):
+
+        G0,G1 = self.pstat_seq[i0],self.pstat_seq[i1] 
+
+        q0,c0 = G0.latest_results() 
+        q1,c1 = G1.latest_results() 
+
+        return is_PRNG_more_QC_random((q0,c0),(q1,c1),metric_numbers)
+
+"""
+uses a unique copy of `prg` to generate every struct in `struct_name_list` 
+(no embedded generators). Then uses a <ChainedPRNGComparator> to produce a 
+cumulative comparison matrix over `num_iter` segments. 
+"""
+def prg_to_chained_PRNG_cmp_matrix(prg,struct_name_list,ngram_info=[8],partition_size=5,\
+    output_prg_range=[-50000,50000],num_iter=1,include_source_prg_in_cmp:bool=False): 
+
+    a = int(include_source_prg_in_cmp)
+    M = np.zeros((len(struct_name_list) + a,len(struct_name_list) + a))
+    S = [one_P_random_struct(l,deepcopy(prg)) for l in struct_name_list]  
+    if include_source_prg_in_cmp: S.insert(0,prg) 
+
+    X = ChainedPRNGComparator(S,"prg",ngram_info,partition_size,output_prg_range,do_embed_generators = False) 
+
+    for _ in range(num_iter):  
+        X.run() 
+        q = X.cmp_matrix() 
+        print("{}: {}".format(_,q))
+        M = M + q  
+    return M 

{seqbuild-0.0.73 → seqbuild-0.0.74}/seqbuild/face/easy_gen_struct.py

@@ -1102,22 +1102,31 @@ class TimeBasedCommLangFileGenerator:
 DEFAULT_TBCLF_TMP_FILE_PATH = os.path.join(BASE_COMM_LANG_FOLDER,"tmp_file_that_no_one_should_use__HIOTRNGINRE.txt")
 
 def one_T_random_struct(struct_name,tmp_filepath=DEFAULT_TBCLF_TMP_FILE_PATH):
+    return one_X_random_struct(struct_name,None,tmp_filepath) 
+
+"""
+outputs a PRNG generated by PRNG `prg` 
+"""
+def one_P_random_struct(struct_name,prg,tmp_filepath=DEFAULT_TBCLF_TMP_FILE_PATH):
+    return one_X_random_struct(struct_name,prg,tmp_filepath)
+
+def one_X_random_struct(struct_name,prg,tmp_filepath=DEFAULT_TBCLF_TMP_FILE_PATH):
 
     q = None 
 
     while not q: 
-        q = one_T_random_struct_(struct_name,tmp_filepath) 
+        q = one_X_random_struct_(struct_name,prg,tmp_filepath) 
     return q 
 
 """
 outputs a time-based pseudo-random generated PRNG Python object 
 """
-def one_T_random_struct_(struct_name,tmp_filepath=DEFAULT_TBCLF_TMP_FILE_PATH):
-
+def one_X_random_struct(struct_name,prg,tmp_filepath=DEFAULT_TBCLF_TMP_FILE_PATH):
     assert struct_name in DEFAULT_TBCLF_STRUCT_NAMES
+    is_gen_time = type(prg) == type(None)
 
     base_gen_name = "rxx"
-    use_prng_for_prng_pr = 0.5 
+    use_prng_for_prng_pr = 0.5 if is_gen_time == "t" else 0. 
     vector_files = [] 
     comm_lang_files = [] 
     consistent_prng_output = False 
@@ -1125,10 +1134,14 @@ def one_T_random_struct_(struct_name,tmp_filepath=DEFAULT_TBCLF_TMP_FILE_PATH):
 
     tbclf = TimeBasedCommLangFileGenerator(tmp_filepath,base_gen_name,use_prng_for_prng_pr,\
         vector_files,comm_lang_files,consistent_prng_output,verbose) 
-
-    for _ in range(3): 
-        S,g = tbclf.generate_CL_LCG_bunch() 
-        tbclf.update_CL_file(S) 
+    
+    if is_gen_time == "t": 
+        for _ in range(3): 
+            S,g = tbclf.generate_CL_LCG_bunch() 
+            tbclf.update_CL_file(S) 
+    else: 
+        assert type(prg) in {MethodType,FunctionType}
+        tbclf.pdd = prg 
 
     S,g = tbclf.generate_one_struct_(struct_name)
     tbclf.update_CL_file(S) 
@@ -1137,4 +1150,18 @@ def one_T_random_struct_(struct_name,tmp_filepath=DEFAULT_TBCLF_TMP_FILE_PATH):
     q = tbclf.clp.vartable[g] 
     tbclf.close() 
 
-    return q 
+    return q 
+
+#-------------------------------------------------------
+
+def chain_generate_P_random_structs(starting_prg,struct_name_list): 
+    prngs = [] 
+    q = deepcopy(starting_prg) 
+
+    for x in struct_name_list: 
+        q2 = one_P_random_struct(x,q) 
+        q = deepcopy(MAIN_method_for_object(q2)) 
+
+        prngs.append(q2) 
+
+    return prngs          

{seqbuild-0.0.73 → seqbuild-0.0.74}/seqbuild/face/prng_bool_cmp.py

@@ -54,6 +54,9 @@ class QCInfo:
 
         self.c = qc[1] 
 
+    def retrieve_all(self): 
+        return {t:self.retrieve(t) for t in SCORE_TERMS}
+
     def retrieve(self,term):
         assert term in SCORE_TERMS 
 

{seqbuild-0.0.73 → seqbuild-0.0.74}/seqbuild/face/prng_stats.py

@@ -5,7 +5,6 @@ from .prng_bool_cmp import *
 
 DEFAULT_QUALTEST_SEGMENT_LENGTH = 200 
 DEFAULT_CHAINTEST_SEGMENT_LENGTH = 1000 
-DEFAULT_CHAINTEST_RADIUS = 0.5 
 
 """
 Method<run> conducts QUALTEST and CHAINTEST for their respective 
@@ -45,9 +44,9 @@ class PRNGStats:
         return  
 
     def run(self):
-
         self.qtest() 
         self.ctest() 
+        print("============================================================")
         return
 
     def latest_results(self):
@@ -102,10 +101,13 @@ class PRNGStats:
             Q2 = self.cqueue
             s = DEFAULT_QUALTEST_SEGMENT_LENGTH
 
+        print("populating {}->{}".format(len(Q),s))
+
         while len(Q) < s: 
             x = self.prg() 
             Q.append(x) 
             Q2.append(x) 
+        print("done populating")
 
 '''
 A comparator class for input PRNGs, of `input_prg_list`, when they are each used as a 
@@ -129,7 +131,7 @@ boolean metrics from file<face.prng_bool_cmp> to use), these comparisons output
 class PRNGIOStats: 
 
     def __init__(self,input_prg_list,input_prg_varname,output_prg_struct,ngram_info,\
-        partition_size,absdiff:bool=True,output_prg_range=None): 
+        partition_size,absdiff:bool=True,output_prg_range=None,collect_variance_over_runs:bool=False): 
         
         assert len(input_prg_list) > 0 
         
@@ -141,9 +143,12 @@ class PRNGIOStats:
             assert is_valid_range(output_prg_range,True,False) or \
             is_valid_range(output_prg_range,False,False)
 
+        assert type(collect_variance_over_runs) == bool 
+
         self.input_prg_list = input_prg_list
         self.input_prg_varname = input_prg_varname
         self.output_prg_struct = output_prg_struct
+        self.cvar_over_runs = collect_variance_over_runs
         self.ngram_info = ngram_info 
         self.psize = partition_size
         self.absdiff = absdiff 
@@ -151,11 +156,16 @@ class PRNGIOStats:
         self.input_prng_stats = [] 
         self.output_prng_stats = []  
         self.output_prg_range = output_prg_range
+
+        # index -> score term -> list of values over runs 
+        self.input_prng_summary = defaultdict(None) 
+        self.output_prng_summary = defaultdict(None) 
         self.preproc() 
+
         return  
 
     def preproc(self):
-        for x in self.input_prg_list:
+        for (i,x) in enumerate(self.input_prg_list):
 
             G = deepcopy(self.output_prg_struct) 
             setattr(G,self.input_prg_varname,deepcopy(x))
@@ -170,16 +180,91 @@ class PRNGIOStats:
             self.input_prng_stats.append(G0)
 
             G1 = PRNGStats(Q,deepcopy(self.ngram_info),self.psize)
-            self.output_prng_stats.append(G1) 
+            self.output_prng_stats.append(G1)
+
+            self.input_prng_summary[i] = defaultdict(list)
+            self.output_prng_summary[i] = defaultdict(list)
+
+    def update_summary(self,index,is_input_prg:bool): 
+        assert type(is_input_prg) == bool 
+        assert 0 <= index < len(self.input_prg_list) 
+
+        x = self.input_prng_stats[index] if is_input_prg else \
+            self.output_prng_stats[index] 
+
+        q0,q1 = x.latest_results()
+        qc = QCInfo((q0,q1)) 
+
+        D = qc.retrieve_all() 
+        
+        D2 = self.input_prng_summary[index] if is_input_prg else \
+            self.output_prng_summary[index] 
+
+        for k,v in D.items(): 
+            D2[k].append(v) 
 
     def run(self): 
         for (i,x) in enumerate(self.input_prng_stats):
             print("* running input prng #{}".format(i))
             x.run() 
+            
+            if self.cvar_over_runs: self.update_summary(i,True)
 
         for (i,y) in enumerate(self.output_prng_stats):
             print("* running output prng #{}".format(i))
-            y.run() 
+            y.run()
+
+            if self.cvar_over_runs: self.update_summary(i,False)
+
+    """
+    Compares the intra-variance between two PRNGs. 
+
+    index_type_pair0 := (PRNG index, ?is input PRNG?)
+    index_type_pair1 := (PRNG index, ?is input PRNG?)
+    """
+    def cmp_var_over_runs(self,index_type_pair0,index_type_pair1): 
+        assert len(index_type_pair0) == len(index_type_pair1) == 2 
+ 
+        G0 = self.input_prng_summary[index_type_pair0[0]] if \
+            index_type_pair0[1] else self.output_prng_summary[index_type_pair0[0]]
+        G1 = self.input_prng_summary[index_type_pair1[0]] if \
+            index_type_pair1[1] else self.output_prng_summary[index_type_pair1[0]]
+
+        var0 = {k:np.var(v) for k,v in G0.items()}
+        var1 = {k:np.var(v) for k,v in G1.items()} 
+
+        D = dict()  
+
+        for k,v in var0.items(): 
+            r = to_trinary_relation(v,var1[k]) 
+            D[k] = r 
+        
+        print("** variance comparison")
+        Q = sorted(SCORE_TERMS) 
+        for q in Q: 
+            print("{} -> {}".format(q,D[q])) 
+
+        return to_trinary_relation_v2(sum(list(D.values())),None,True,False)
+
+    # TODO: test 
+    def cmp_matrix(self,cmp_type:str,metric_numbers:set=None): 
+        assert cmp_type in {"i","o","io"} 
+
+        l = len(self.input_prg_list)
+        M = np.zeros((l,l)) + np.nan 
+
+        if cmp_type == "i": 
+            F = self.input_cmp 
+        elif cmp_type == "o": 
+            F = self.output_cmp
+        else: 
+            F = self.pairwise_io_cmp 
+
+        for i in range(l - 1): 
+            for j in range(i+1,l): 
+                c = F(j,i,metric_numbers) 
+                M[i,j] = c 
+        return M 
 
     """
     input PRNG#0 - input PRNG#1 
@@ -280,4 +365,28 @@ class PRNGIOStats:
         q0,c0 = G0.latest_results() 
         q1,c1 = G1.latest_results() 
 
-        return is_PRNG_more_QC_random((q0,c0),(q1,c1),metric_numbers)
+        return is_PRNG_more_QC_random((q0,c0),(q1,c1),metric_numbers)
+
+def rank_prng_cmp_matrix(M,verbose=True): 
+    assert len(M.shape) == 2 
+    assert M.shape[0] == M.shape[1] 
+    
+    M_ = deepcopy(M)
+    M_[np.isnan(M_)] = 0. 
+
+    D = [] 
+
+    for i in range(M_.shape[0]): 
+        s0 = np.sum(M_[:,i]) 
+        s1 = np.sum(M_[i,:]) 
+        D.append((i,s0 - s1)) 
+
+    D = sorted(D,key=lambda x:x[1],reverse = True) 
+    I = [d[0] for d in D] 
+
+    for i in range(M_.shape[0]): 
+        x = I.index(i) 
+        y = D[x][1] 
+        if verbose: print("index {} -> {} -> {}".format(i,x,y))
+
+    return D  

{seqbuild-0.0.73 → seqbuild-0.0.74}/seqbuild/mini_dm/n2m_index.py

@@ -191,15 +191,18 @@ class N2MIndexMapGen:
         
         msize = int(modulo_in_range(self.prg(),self.ms_range)) 
         msize = min([msize,len(ai)])
+
+        prg_ = prg__single_to_int(self.prg)
         mset_index = prg_choose_n([i for i in range(len(ai))],\
-            msize,self.prg,is_unique_picker=True) 
+            msize,prg_,is_unique_picker=True) 
         mset = sorted([ai[mi] for mi in mset_index])
         mset = sorted(mset)
 
         # nset is from static even distribution 
         nsize = int(modulo_in_range(self.prg(),self.ns_range)) 
         sx = [i for i in range(self.nm[0])]
-        nset = prg_choose_n(sx,nsize,self.prg,is_unique_picker=True)
+
+        nset = prg_choose_n(sx,nsize,prg_,is_unique_picker=True)
         nset = sorted(nset) 
 
         # try adding the generated (nset,mset)

{seqbuild-0.0.73 → seqbuild-0.0.74}/seqbuild/seqgen/afs_gen.py

@@ -4,7 +4,8 @@ from collections import deque
 
 DEFAULT_AFSGEN_NUM_CENTROIDS = 5 
 
-DEFAULT_AFSGEN_CENTROID_UPDATE_RANGE = [2,13] 
+DEFAULT_AFSGEN_CENTROID_UPDATE_RANGE = [2,7]#13] 
+DEFAULT_AFSGEN_CENTROID_UPDATE_FREQUENCY = 12  
 
 """
 (A)ffine (F)it (S)earch (Gen)erator.
@@ -32,7 +33,8 @@ diff_mode := ~
 """
 class AFSGen: 
 
-    def __init__(self,prg,prg2,prg3,prg4,num_vectors,diff_mode:bool=True):
+    def __init__(self,prg,prg2,prg3,prg4,num_vectors,diff_mode:bool=True,\
+        update_frequency=DEFAULT_AFSGEN_CENTROID_UPDATE_FREQUENCY):
         assert type(prg) in {MethodType,FunctionType}
         assert type(prg2) in {MethodType,FunctionType,type(None)}
         assert type(prg3) in {MethodType,FunctionType,type(None)}
@@ -40,9 +42,11 @@ class AFSGen:
         
         assert type(num_vectors) == int and num_vectors > 0 
         assert type(diff_mode) == bool 
+        assert update_frequency > 0 and type(update_frequency) == int 
 
         self.num_vectors = num_vectors
         self.diff_mode = diff_mode 
+        self.update_frequency = update_frequency
 
         self.prg = prg 
         self.prg2 = prg2 
@@ -57,19 +61,25 @@ class AFSGen:
         self.instantiate_AFSearch()
 
         self.queue = deque() 
+
+        self.c = 0 
         return 
 
     def __next__(self): 
 
         if len(self.queue) == 0: 
             q = self.prg() 
+            ##print("mapping")
             x = self.afsearch.map_input(q)
+            ##print("got ",x)
             x = self.output_difference(x) 
             v = list(x.flatten()) 
             v = prg_seqsort(v,self.prg)
 
             self.queue.extend(v) 
+            ##print('adjusting')
             self.adjust_centroids() 
+            ##print('post')
         return self.queue.popleft() 
 
     def output_difference(self,q):
@@ -81,6 +91,12 @@ class AFSGen:
         return q - L 
 
     def adjust_centroids(self): 
+        self.c += 1 
+
+        if self.c % self.update_frequency: 
+            return 
+        self.c = 0 
+
         x = modulo_in_range(int(self.prg()),DEFAULT_AFSGEN_CENTROID_UPDATE_RANGE) 
         for _ in range(x): 
             next(self.afsearch)

{seqbuild-0.0.73 → seqbuild-0.0.74}/seqbuild/seqgen/cs_gen.py

@@ -43,9 +43,11 @@ class CongruenceShifterGen:
         if self.c == self.next_shift: 
             if x_ != self.prev: 
                 self.super_range = modrange_for_congruence(x_,self.prev,self.super_range)
-                if self.super_range[0] >= self.super_range[1]:
+                if self.super_range[0] > self.super_range[1]:
                     print("...strange...")
                     self.super_range = sorted(self.super_range)
+                elif self.super_range[0] == self.super_range[1]: 
+                    self.super_range = (self.super_range[0],self.super_range[1] + 5.0)
 
             self.c = 0
             self.set_next_shift() 
@@ -68,8 +70,12 @@ class CongruenceShifterGen:
 
             start = self.super_range[0] + (s0 * l / 2) 
             end = self.super_range[1] + (s1 * l / 2) 
+            
+            # NOTE: null range case 
+            if start == end: end += 5.0 
+
             ##print('before: ',self.super_range)
-            self.super_range = (start,end) 
+            self.super_range = (start,end)             
             ##print('after: ',self.super_range)
 
             self.c2 = 0 

{seqbuild-0.0.73 → seqbuild-0.0.74}/seqbuild/seqgen/gg_gen.py

@@ -69,7 +69,10 @@ class GaugeGuidedGen:
         self.allow_subrange_drift = allow_subrange_drift
 
         self.queue = deque() 
+
+        # element is (cov,uwpd)
         self.mvec = deque()  
+        # element is category 
         self.catvec = deque() 
 
         self.cat_size = None 

{seqbuild-0.0.73 → seqbuild-0.0.74}/seqbuild/seqgen/mdr_gen.py

@@ -224,8 +224,6 @@ class MDRGen:
         c2 = 0 
         while len(terminated_seeds) < len(intseed_cycle) and \
             c < max_sequences and c2 < max_sequences * 2.5: 
-            print("TT: ",terminated_seeds,len(intseed_cycle))
-            print("CC: ",c,max_sequences)
             r, stat = self.add_sequence__type_novelgen_(intseed_cycle[i])
 
             if not stat: 

{seqbuild-0.0.73 → seqbuild-0.0.74}/seqbuild/seqgen/rch_gen.py

@@ -139,6 +139,21 @@ class RCHAccuGen:
         else: 
             assert is_vector(x)
 
+        if self.verbose: 
+            print("\t\t** CHAIN VALUES W/: ",x) 
+
+            ## NOTE: for viewing input-output values before actual calculation 
+            """
+            x2 = x 
+            for s_ in self.rch.s: 
+                print(s_)
+                x2 = deepcopy(s_.f)(x2) 
+                x2_ = safe_npint32_value(x2) 
+                x2_ = modulo_in_range(x2_,self.output_range) 
+                print("$ $ $ $ $:      ",x2,x2_)  
+            #print("== ",self.rch.s[i]) 
+            """ 
+
         ##self.rch.vpath.clear() 
         try: 
             self.rch.apply(x)
@@ -150,16 +165,13 @@ class RCHAccuGen:
         tmp_queue = [] 
         last_length = 0 
 
-        if self.verbose: 
-            print("\t\t** CHAIN VALUES W/: ",x) 
-
-        for v in self.rch.vpath: 
+        for (i,v) in enumerate(self.rch.vpath): 
             if type(v) != np.ndarray: 
                 v = safe_npint32_value(v) 
                 v = modulo_in_range(v,self.output_range) 
 
                 if self.verbose: 
-                    print("-- ",v)
+                    print("-- {}: {}".format(i,v)) 
                 tmp_queue.append(v)
                 last_length = 1 
             else: 
@@ -169,7 +181,7 @@ class RCHAccuGen:
                     for v_ in v]
 
                 if self.verbose: 
-                    print("-- ",v) 
+                    print("-- {}: {}".format(i,v)) 
 
                 tmp_queue.extend(v) 
                 last_length = len(v) 
@@ -307,12 +319,13 @@ class RCHAccuGen:
         else:
             d = modulo_in_range(self.prg(),self.dim_range)
 
-        q1 = np.array(prg_choose_n(self.acc_queue,d,self.prg))
+        prg_ = prg__single_to_int(self.prg) 
+        q1 = np.array(prg_choose_n(self.acc_queue,d,prg_))
 
         # case: LinCombo, change both 'rf' and 'cf' 
         if type(mg.base_func) == LinCombo: 
             d2 = d - 1
-            q2 = np.array(prg_choose_n(self.acc_queue,d2,self.prg))
+            q2 = np.array(prg_choose_n(self.acc_queue,d2,prg_))
             self.tmpset_rch_updatepath(rci_index,q2)
             self.rch.s[rci_index].inst_update_var() 
 

{seqbuild-0.0.73 → seqbuild-0.0.74}/seqbuild/seqgen/udls_gen.py

@@ -47,6 +47,7 @@ class UDLSGen:
         self.verbose = verbose 
 
         self.udls = None 
+        self.udls_ = None 
 
         self.cache = deque()  
 
@@ -59,8 +60,15 @@ class UDLSGen:
         self.set_next_shift(2) 
 
     def __next__(self):
-        V = self.one_input_vector()
-        x = self.udls.apply(V)
+        V,x = None,None 
+
+        try: 
+            V = self.one_input_vector()
+            x = self.udls.apply(V)
+        # NOTE: for catching cases where `prg` cannot produce a UDLinSysSolver 
+        except: 
+            self.cache.append(self.prg())
+            return self.cache.popleft() 
 
         self.cache.extend(V) 
         self.cache.append(x) 
@@ -81,7 +89,8 @@ class UDLSGen:
     def load_udls(self,draw_from_cache:bool=False,num_attempts_remaining=3): 
 
         X,Y = self.new_XY_dataset(draw_from_cache)
-        
+        self.udls_ = deepcopy(self.udls) 
+
         if self.verbose: 
             print("\t\t** new dataset")
             print("-- input")
@@ -101,7 +110,8 @@ class UDLSGen:
         except: 
             if num_attempts_remaining > 0: 
                 return self.load_udls(draw_from_cache,num_attempts_remaining - 1) 
-            
+            else: 
+                self.udls = self.udls_ 
         return 
 
     def new_XY_dataset(self,draw_from_cache:bool=False): 

{seqbuild-0.0.73 → seqbuild-0.0.74/seqbuild.egg-info}/PKG-INFO

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

{seqbuild-0.0.73 → seqbuild-0.0.74}/seqbuild.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ seqbuild/desi/nvec_gen.py
 seqbuild/desi/prng_dec_delta.py
 seqbuild/desi/seqcov_perm.py
 seqbuild/face/__init__.py
+seqbuild/face/chained_prng_cmp.py
 seqbuild/face/cl_guide_parser.py
 seqbuild/face/cmd_proc.py
 seqbuild/face/comm_lang.py

{seqbuild-0.0.73 → seqbuild-0.0.74}/setup.py

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