seqbuild 0.0.3__tar.gz → 0.0.4__tar.gz

{seqbuild-0.0.3 → seqbuild-0.0.4}/PKG-INFO

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

{seqbuild-0.0.3 → seqbuild-0.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "seqbuild"
-version = "0.0.3" 
+version = "0.0.4" 
 authors = [
   { name="Richard Pham", email="phamrichard45@gmail.com" },
 ]

seqbuild-0.0.4/seqbuild/desi/approximators.py

@@ -0,0 +1,162 @@
+from .not_equals import * 
+from .fraction import * 
+from morebs2.poly_interpolation import * 
+
+DEFAULT_FIT22_PARTITION_SIZE_RANGE = (5,103) 
+
+DEFAULT_POLYNOMIAL_PARTITION_SIZE_RANGE = (50,1000)
+DEFAULT_POLYNOMIAL_POINT_SIZE_RANGE = (5,21) 
+
+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 point_conn_type in {1,2}
+        assert type(bool_outputter) in {MethodType,FunctionType}
+
+        self.px = px 
+        self.point_conn_type = point_conn_type
+        self.b_out = bool_outputter
+
+        self.p0 = None
+        self.p1 = None
+        self.H = None
+
+        self.x_ = None
+        self.x2_ = None
+        self.a_ = None
+        self.ax = None 
+        
+        super().__init__(length_outputter,range_outputter,adjustment_type)
+        return
+    
+    def set_next_value(self):
+        if type(self.x_) == type(None):
+            self.update_points() 
+        elif self.x_ > self.x2_: 
+            self.update_points() 
+        else: pass 
+
+        if self.ax: 
+            sx = self.H.f(self.x_)
+        else: 
+            sx = self.H.g(self.x_) 
+        self.x_ += self.a_ 
+
+        sx_ = float_to_string(sx,True,True)
+        self.s = sx_ 
+        return 
+    
+    def update_points(self):
+        # case: start 
+        if type(self.p0) == type(None):
+            self.p0 = self.px() 
+            self.p1 = self.px() 
+        # output 1 or 2 new points 
+        elif self.point_conn_type == 1:
+            self.p0 = self.p1
+            self.p1 = self.px()
+        else:
+            self.p0,self.p1 = self.px(),self.px() 
+
+        self.fix_equal_points()
+
+        # instantiate either <LogFit22> or <Exp2Fit22> 
+        mx = np.array([self.p0,self.p1]) if \
+            self.p0[1] < self.p1[1] else \
+            np.array([self.p1,self.p0])
+        lORe = self.b_out() % 2
+
+        if lORe:
+            self.H = LogFit22(mx,direction=[0,1]) 
+        else: 
+            self.H = Exp2Fit22(mx,direction=[0,1])
+
+        # set delta variables for exploring the fitter 
+        self.ax = self.b_out() % 2 
+
+        ax_ = (self.ax + 1) % 2        
+        self.x_ = min(self.H.ps[:,ax_])
+        self.x2_ = max(self.H.ps[:,ax_]) 
+
+        ap = modulo_in_range(self.l_out(),DEFAULT_FIT22_PARTITION_SIZE_RANGE) 
+        self.a_ = (self.x2_ - self.x_) / ap
+
+    
+    def fix_equal_points(self):
+
+        self.p0 = np.array(self.p0)
+        self.p1 = np.array(self.p1)
+
+        self.p0,self.p1 = \
+            not_equals__pairvec(self.p0,self.p1,self.px,indices=None)
+
+
+
+"""
+LPS stands for Lagrange Polynomial Solver, interpolation of a 
+polynomial's span of points using the Lagrange basis.  
+"""
+class LPSValueOutputter(GenericIntSeqOp):
+
+    def __init__(self,px,length_outputter,range_outputter,\
+        adjustment_type:int=1): 
+        
+        assert type(px) in {MethodType,FunctionType}
+        self.px = px 
+
+        self.p0,self.p1 = None,None 
+        self.adder_end,self.adder,self.adder_i = None,None,None
+
+        super().__init__(length_outputter,range_outputter,adjustment_type)
+
+    #--------------------------------------------------------------------------
+
+    def set_next_value(self):
+        if type(self.p0) == type(None):
+            self.update_points() 
+        elif self.adder_i > self.adder_end: 
+            self.update_points() 
+        else: pass 
+
+        x = self.p0 + (self.adder_i * self.adder)
+        sx = self.lps.output_by_lagrange_basis(x)
+        sx_ = float_to_string(sx,True,True)
+        self.s = sx_ 
+
+        self.adder_i += 1 
+
+        return 
+    
+    def update_points(self):
+
+        self.q = LPSValueOutputter.new_pointset(self.px,self.l_out) 
+
+        # assumes q is a proper set of points for 
+        # fitting via <LagrangePolySolver>
+        self.lps = LagrangePolySolver(self.q, prefetch = True)
+        self.p0,self.p1 = self.lps.minumum,self.lps.maximum 
+
+        self.adder_end = modulo_in_range(self.l_out(),DEFAULT_POLYNOMIAL_PARTITION_SIZE_RANGE)
+        self.adder = (self.p1 - self.p0) / self.adder_end 
+        self.adder_i = 0   
+
+    @staticmethod 
+    def new_pointset(px,l_out):
+
+        num_points = modulo_in_range(\
+            l_out(),DEFAULT_POLYNOMIAL_POINT_SIZE_RANGE) 
+
+        M = []
+        for _ in range(num_points):
+            x = px() 
+            assert type(x) in {list,tuple} or is_vector(x) 
+            assert len(x) == 2 
+            M.append(x) 
+        M = np.array(M) 
+
+        submat_type = l_out() % 4 
+        t = DEFAULT_SUBMAT_TYPES[submat_type]
+        return not_equals__matrix_whole(M,l_out,t)
+

seqbuild-0.0.4/seqbuild/desi/differentials.py

@@ -0,0 +1,88 @@
+from .approximators import * 
+
+class PointInterpolationContainer:
+
+    def __init__(self,pts,starting_fvec):
+        assert is_2dmatrix(pts)
+        pts = pts[np.argsort(pts[:,0])]
+        self.pts = pts
+        self.fvec = starting_fvec
+        self.init_structs() 
+
+    def init_structs(self):
+        self.lps = LagrangePolySolver(self.pts, prefetch = False)
+        self.cdc = ChainedDCurves(self.pts,self.fvec,0)
+        self.cdc.draw() 
+        self.x = self.cdc.amin 
+        self.x2 = self.cdc.amax 
+
+    def differential_at(self,x,lps_first:bool=True):
+        q = self.lps.output_by_lagrange_basis(x) 
+        q2 = self.cdc.fit(x) 
+
+        # BUG: CAUTION! 
+        if type(q) == type(None): 
+            q = self.pts[0,0] 
+        if type(q2) == type(None): 
+            q2 = self.pts[-1,0] 
+
+
+        if lps_first: return q - q2 
+        return q2 - q 
+    
+    def modulate_dcurve_of_point(self,x): 
+        index = self.cdc.point_to_dcurve(x)
+        assert index != -1
+        self.cdc.dcurve_seq[index].modulate_fit() 
+
+
+"""
+PID stands for Point Interpolation Differential. 
+"""
+class PIDValueOutputter(GenericIntSeqOp):
+
+    def __init__(self,px,frequency_outputter,\
+        length_outputter,range_outputter,adjustment_type):
+        assert type(px) in {MethodType,FunctionType}
+        
+        assert type(frequency_outputter) in {MethodType,FunctionType}
+
+        self.px = px
+        self.pts = None
+
+        self.f_out = frequency_outputter
+        super().__init__(length_outputter,range_outputter,adjustment_type)
+
+        self.adder_end,self.adder,self.adder_i = -1,None,0
+        self.pic = None 
+        return 
+    
+    def set_next_value(self):
+
+        if type(self.pic) == type(None) or self.adder_i > self.adder_end:
+            self.pts = LPSValueOutputter.new_pointset(self.px,self.l_out)
+            fvec = [self.f_out() % 2 for  _ in range(len(self.pts) - 1)] 
+            self.pic = PointInterpolationContainer(self.pts,fvec) 
+
+            self.adder_end = modulo_in_range(self.f_out(),\
+                DEFAULT_POLYNOMIAL_PARTITION_SIZE_RANGE)
+            self.adder = (self.pic.x2 - self.pic.x) / self.adder_end
+            self.adder_i = 0
+            self.fvec_frequency = modulo_in_range(\
+                self.f_out(),[1,max([2,ceil(self.adder_end / 5)])])
+        
+        x =  self.pic.x + (self.adder_i * self.adder)
+        stat = (self.adder_i % self.fvec_frequency) == 0
+
+        if stat:
+            self.pic.modulate_dcurve_of_point(x) 
+
+        q = self.pic.differential_at(x,lps_first=True)
+        self.adder_i += 1 
+
+        q_ = int(q) 
+        q -= q_
+
+        self.s += str(abs(q_)) 
+        self.s += float_to_string(abs(q),True,True)
+        return

seqbuild-0.0.4/seqbuild/desi/fraction.py

@@ -0,0 +1,102 @@
+from intigers.seq_struct import * 
+from intigers.extraneous import zero_div0  
+from morebs2.numerical_generator import modulo_in_range
+from morebs2.matrix_methods import is_valid_range,float_to_string 
+from types import MethodType,FunctionType
+
+class GenericIntSeqOp: 
+
+    def __init__(self,length_outputter,range_outputter,adjustment_type:int): 
+        assert type(length_outputter) in {MethodType,FunctionType}
+        assert type(range_outputter) in {MethodType,FunctionType}
+        assert adjustment_type in {1,2}
+        self.l_out = length_outputter
+        self.r_out = range_outputter
+        self.adj_type = adjustment_type
+        self.s = "" 
+
+
+    def __next__(self):
+        l = modulo_in_range(self.l_out(),[1,18]) 
+        assert type(l) in {int,np.int32,np.int64}
+
+        s_ = self.s[:l]
+        self.s = self.s[l:]
+
+        diff = l - len(s_) 
+        while diff > 0:
+            self.set_next_value() 
+            dx = diff if len(self.s) >= diff else len(self.s)
+            s_ = s_ + self.s[:dx]
+            diff = diff - dx
+            self.s = self.s[dx:]
+        
+        # BUG: CAUTION!!  
+        s1 = 5 
+        try: 
+            s1 = np.int64(s_)
+        except: 
+            pass 
+        return self.adjust_integer(s1) 
+
+    def set_next_value(self):
+        return -1 
+    
+    def adjust_integer(self,i):
+        assert type(i) in {int,np.int32,np.int64}
+
+        mrange = self.r_out()
+        assert is_valid_range(mrange,False,False)
+
+        if self.adj_type == 1:
+            return self.adjustment_type1(i,mrange)
+        return self.adjustment_type2(i,mrange)
+    
+    def adjustment_type1(self,i,mrange): 
+        return modulo_in_range(i,mrange)
+    
+    def adjustment_type2(self,i,mrange): 
+        diff = mrange[1] - mrange[0]
+        i = abs(i) 
+
+        while i >= diff:
+            i = i / 10
+        return mrange[0] + i
+    
+
+
+"""
+Outputs float values that originate from quotient outputs of pairs in `intseq`.
+
+index_selector := function|method, parameter-less. Outputs pairs of numbers that act 
+                  as 2-dimensional indices. 
+length_outputter := function|method, parameter-less. Outputs positive integers. 
+range_outputter := function|method, parameter-less. Outputs ordered pairs of 
+                    numbers. 
+"""
+class QValueOutputter(GenericIntSeqOp): 
+
+    def __init__(self,intseq,index_selector,length_outputter,range_outputter,\
+            adjustment_type:int):
+        assert type(intseq) == IntSeq 
+        assert len(intseq) >= 2 
+        assert type(index_selector) in {MethodType,FunctionType}
+        super().__init__(length_outputter,range_outputter,adjustment_type)
+
+        self.intseq = intseq
+        self.iselector = index_selector
+        return 
+
+    def change_adj_type(self):
+        self.adj_type = 1 if self.adj_type == 2 else 2 
+    
+    def set_next_value(self):
+        i1,i2 = self.iselector() 
+        i1 = i1 % len(self.intseq)
+        i2 = i2 % len(self.intseq)
+        
+        q = zero_div0(self.intseq[i1],self.intseq[i2])
+        q = float_to_string(abs(q),True,True)
+        self.s = q 
+        return q 
+