seqbuild 0.0.72__tar.gz → 0.0.74__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqbuild
-Version: 0.0.72
+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.72 → seqbuild-0.0.74}/pyproject.toml

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

{seqbuild-0.0.72 → 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.74/seqbuild/desi/cy_metric.py

@@ -0,0 +1,179 @@
+from ..mini_dm.ngram_ext import * 
+from morebs2.seq_repr import * 
+from types import MethodType,FunctionType
+from ..mini_dm.iseq import stdop_vec
+
+"""
+Used for Cycle Test, focused on qualities of forward permutations. Measures are 
+frequency-based on n-gram prefixes to m-gram suffixes of the next `num_iter` samples 
+from `prg`. 
+
+Important metrics per prefix: 
+[0] mcs_k, MCS k-complexity of the ordered concatenation of suffixes. 
+[1] cy_diff, mean cyclical kernel difference of ordered concatenation of suffixes. 
+[2] I_diff, set size for difference vector of prefix indices of occurrence.
+[3] var_norm, normalized variance of suffix frequency. 
+
+For metrics [0] + [1], there are an additional four categories of scores: 
+    seq -> ordered concatenation of literal suffixes,
+    set -> ordered concatenation of set form of suffixes,
+    valfreq -> ordered concatention of (suffix label,suffix frequency) pairs per suffix, 
+    l-seq -> ordered concatenation of labelled suffixes. 
+"""
+class CycleMetric: 
+
+    def __init__(self,prg,num_iter:int,pre_size:int,post_size:int,cast_func=cr):
+        assert type(prg) in {MethodType,FunctionType} 
+        assert num_iter > 0 and type(num_iter) == int  
+
+        self.prg = prg 
+        self.num_iter = num_iter 
+        self.pre_size = pre_size 
+        self.post_size = post_size 
+        self.cast_func = cast_func 
+
+        self.S = [] 
+        self.M_ = None  
+        self.M = [] 
+
+        #   prefix --> measure type --> (mcs_k, cy_diff)
+        self.prefix2mcs_map = dict()
+
+        #   prefix --> (I_diff, var_norm)
+        self.prefix2score_map = dict() 
+
+        self.preproc() 
+
+    def preproc(self): 
+        self.load_next_batch() 
+    
+    """
+    call this to update reference sequence to another 
+    one, before calling method<process>. 
+    """
+    def load_next_batch(self,num_iter=None):
+        if type(num_iter) != type(None): 
+            assert type(num_iter) == int and num_iter > 0 
+            self.num_iter = num_iter 
+
+        self.S.clear() 
+        self.S = [self.cast_func(self.prg()) for _ in range(self.num_iter)]  
+        
+        if type(self.M_) != type(None): 
+            self.M.append(self.M_)
+
+        self.M_ = SequencePrePostMap(self.S,self.pre_size,self.post_size) 
+        self.M_.process()
+
+        self.prefix2score_map.clear()
+        for k in self.M_.M.keys(): 
+            self.prefix2score_map[k] = dict() 
+    
+    """
+    main method
+    """
+    def process(self): 
+
+        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
+
+    """
+    [0] dict, measure type --> mean over prefixes
+    [1] mean of I_diff over prefixes 
+    [2] mean of normed variance over prefixes 
+    """
+    def summarize(self): 
+        D = dict() 
+        for m in DEFAULT_CYMETRIC_SUFFIX_MEASURE_TYPES: 
+            S = self.fetch_scores_by_type(m) 
+            M = np.array(list(S.values())) 
+            q = np.mean(M,axis=0) 
+            if np.isnan(q[0]): 
+                q[0] = float('inf')
+            D[m] = q 
+
+        M = np.array(list(self.prefix2score_map.values()))
+        idiff_mean,nvar_mean = np.mean(M,axis=0)
+        return D,idiff_mean,nvar_mean 
+
+    def fetch_scores_by_type(self,measure_type): 
+        assert measure_type in DEFAULT_CYMETRIC_SUFFIX_MEASURE_TYPES
+        D = dict() 
+        for k,v in self.prefix2mcs_map.items(): 
+            D[k] = v[measure_type]
+        return D 
+
+    def process_prefix(self,prefix): 
+        P = {} 
+        for l in DEFAULT_CYMETRIC_SUFFIX_MEASURE_TYPES: 
+            m_score,ck_score = self.mcs_complexity_at_prefix(prefix,l)
+            P[l] = (m_score,ck_score) 
+
+        d0 = self.index_of_occurrence_difference_setsize_at_prefix(prefix)
+        v0 = self.normalized_variance_of_suffix_frequency_at_prefix(prefix) 
+        return P,d0,v0
+
+    def index_of_occurrence_difference_setsize_at_prefix(self,prefix): 
+        indices = sorted(self.M_.M[prefix].keys())
+        V = stdop_vec(np.array(indices),sub,np.float32)
+        l = len(set(V))
+        if l == 0: return float('inf')
+        return l 
+
+    # NOTE: duplicate code? 
+    def normalized_variance_of_suffix_frequency_at_prefix(self,prefix): 
+
+        prefix_info = self.M_.key_to_seq_by_type(prefix,"valfreq") 
+        frequencies = np.array([prefix_info[i] for i in range(1,len(prefix_info),2)])
+
+        m = np.mean(frequencies)
+
+        f2 = np.abs(frequencies - m) 
+        mdiff = np.max(frequencies) - np.min(frequencies) 
+        if mdiff == 0: return 0 
+
+        return np.sum(f2) / (mdiff * len(f2))
+
+    """
+    [0] MCS k-complexity by averaging the four: 
+    - bool + contiguous|best + median|most frequent
+    [1] best cyclical kernel score 
+    """
+    def mcs_complexity_at_prefix(self,prefix,measure_type): 
+        assert measure_type in DEFAULT_CYMETRIC_SUFFIX_MEASURE_TYPES
+
+        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() 
+
+        m_score = self.mcs_complexity_at_prefix_(ms,prefix,measure_type)
+        
+        ck_score = ms.mean_cyclical_kernel_score()  
+        return m_score,ck_score
+
+    def mcs_complexity_at_prefix_(self,ms,prefix,measure_type): 
+        assert type(ms) == MCSSearch 
+
+        d0 = ms.default_kcomplexity(diff_type="bool",\
+            diff_type2="best",basis="median")
+
+        d1 = ms.default_kcomplexity(diff_type="bool",\
+            diff_type2="contiguous",basis="median")
+
+        d2 = ms.default_kcomplexity(diff_type="bool",\
+            diff_type2="best",basis="most frequent")
+
+        d3 = ms.default_kcomplexity(diff_type="bool",\
+            diff_type2="contiguous",basis="most frequent")
+
+        return (d0 + d1 + d2 + d3) / (4 * len(self.S)) 

{seqbuild-0.0.72 → 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.72 → seqbuild-0.0.74}/seqbuild/face/cmd_proc.py

@@ -7,6 +7,7 @@ from .make_cmd import *
 from morebs2.matrix_methods import cr 
 from ..mini_dm.nsfr import * 
 from ..intigers.mod_prng import * 
+from ..desi.cy_metric import * 
 
 import io 
 import pickle 
@@ -375,6 +376,35 @@ def CHAINTEST_proc(splitstr_cmd,var_map):
 
     return q2 
 
+def CYCLETEST_proc(splitstr_cmd,var_map): 
+    assert splitstr_cmd[0] == "cycletest" 
+
+    assert splitstr_cmd[1] in var_map
+    G = MAIN_method_for_object(var_map[splitstr_cmd[1]])
+
+    assert splitstr_cmd[2] == "with" 
+
+    qx = splitstr_cmd[3].split(',') 
+    assert len(qx) == 3 
+
+    num_iter = int(qx[0])
+    pre_size = int(qx[1]) 
+    post_size = int(qx[2])
+
+    C = CycleMetric(G,num_iter,pre_size,post_size) 
+
+    C.process() 
+    S,s0,s1 = C.summarize() 
+
+    keys = sorted(S.keys()) 
+
+    Q = ""
+    for k in keys: 
+        Q += k + " : mcs_k= {},cy_diff= {}\n".format(S[k][0],S[k][1]) 
+    Q += "idiff_mean: {}\n".format(s0)
+    Q += "nvar_mean: {}\n".format(s1) 
+    return Q 
+
 """
 reads a file containing a numerical sequence 
 --- 

{seqbuild-0.0.72 → seqbuild-0.0.74}/seqbuild/face/comm_lang.py

@@ -232,6 +232,10 @@ class CommLangParser:
             self.extra_commands.append(c) 
             return 
 
+        if c[0] == "cycletest": 
+            self.extra_commands.append(c) 
+            return 
+
         self.commond = [c_ for c_ in c if len(c_) > 0]
         return self.process_command_()
 

{seqbuild-0.0.72 → 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.72 → seqbuild-0.0.74}/seqbuild/face/prng_bool_cmp.py

@@ -10,7 +10,7 @@ repeat on the values of these two tests:
     categorical entropy: 0 <= x <= 1
     K-complexity of 1st order ternary difference 
     K-complexity of 2nd order ternary difference
-    K-complexity of (sequence - most common subsequence) 
+    complexity of (sequence - most common subsequence) 
 [1] factor modular k-complexity: 
         factor -> (1st order k-complexity, 2nd order k-complexity)  
 [2] element -> frequency map 
@@ -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.72 → 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): 
+        partition_size,absdiff:bool=True,output_prg_range=None,collect_variance_over_runs:bool=False): 
         
         assert len(input_prg_list) > 0 
         
@@ -137,36 +139,132 @@ class PRNGIOStats:
             assert type(x) in {MethodType,FunctionType}
         assert type(absdiff) == bool 
 
+        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 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 
 
         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:
-            G0 = PRNGStats(x,deepcopy(self.ngram_info),self.psize)
-            self.input_prng_stats.append(G0)
+        for (i,x) in enumerate(self.input_prg_list):
 
             G = deepcopy(self.output_prg_struct) 
             setattr(G,self.input_prg_varname,deepcopy(x))
-            G1 = PRNGStats(deepcopy(G.__next__),deepcopy(self.ngram_info),self.psize)
-            self.output_prng_stats.append(G1) 
+
+            x_ = x 
+            Q = deepcopy(G.__next__)
+            if type(self.output_prg_range) != type(None): 
+                x_ = wrap_ranged_modulo_over_generator(x_,self.output_prg_range)
+                Q = wrap_ranged_modulo_over_generator(Q,self.output_prg_range)
+
+            G0 = PRNGStats(x_,deepcopy(self.ngram_info),self.psize)
+            self.input_prng_stats.append(G0)
+
+            G1 = PRNGStats(Q,deepcopy(self.ngram_info),self.psize)
+            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 
@@ -267,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