Initial version. Bios club

rb/__init__.py

+name = "rb"

rb/dubrova-teslenko.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Apr 26 09:39:47 2019
+
+@author: stan
+"""
+#%%
+#from red_booleana import RedBooleana
+#from truth_table import TruthTable
+from grammar.boolean.formula_parser import FormulaParser
+
+print(FormulaParser.parse("~x3&(x1|x2)"))
+ 
+#tablas = [
+#        TruthTable.from_formula("~x3&(x1|x2)","x1"),
+#        TruthTable.from_formula("x1&x3","x2"),
+#        TruthTable.from_formula("~x3|(x1&x2)","x3"),
+#        ]
+

rb/dubrova_teslenko.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue May  7 08:45:26 2019
+
+@author: stan
+"""
+from formula_parser import FormulaParser as parser
+from cnf import CNF
+from pysat.solvers import Glucose3
+class DubrovaTeslenko:
+    
+    def __init__(self,net):
+        self.net = net
+        self.solver = None
+        
+    def rename(self,var,t):
+        return var + "___" + str(t)
+        
+    def unfolding_formula(self,start,end=0):
+        T = []
+        for t in range(start,end):
+            net = self.net
+            nodes = net.vertices
+            for table in net.tablas:
+                formula = table.formulastr
+                for var in sorted(nodes,key=len,reverse=True):
+                    formula = formula.replace(var,self.rename(var,t+1))
+                T = T.append(
+                    '(' + self.rename(table.name,t) + '=' + formula +')')
+            return T.join("&")
+        
+    def Sat(self,F):
+        ##instancia del SAT sover
+        self.solver = Glucose3()
+        self.solver = solver
+        formula,variables = parser.parse(F)
+        converter = CNF(formula,variables)
+        self.converter = converter
+        f_equisatisfactible = converter.convert()
+        print(f_equisatisfactible)
+        for clause in converter.dimacs:
+            solver.add_clause(clause)
+        return solver.enum_models()
+            
+        
+    def compute_attractors(self):
+        i = min(n,100)
+        attractor_is_found = False
+        A = set()
+        F = self.unfolding_formula(i)
+        for model in Sat(F):
+            #asignación
+            a = {self.converter.decode[abs(i)]:i>0 for i in model} 
+            

rb/nk_rb.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Feb 15 09:39:16 2019
+
+@author: stan
+"""
+from random import randint
+from truth_table import TruthTable
+from red_booleana import RedBooleana
+from random import sample
+class NKRedBooleana(RedBooleana):
+    
+    def __init__(self,N,K):
+        self.N = N
+        self.K = K
+        self.variables = ['x'+str(i) for i in range(1,N+1)]
+        self.create_random_tables()
+        super().__init__(vertices=self.variables,
+                         aristas=None,
+                         reglas=None,
+                         tablas=self.tables)
+        
+    def create_random_tables(self):
+        self.tables = {
+                v:
+                TruthTable(
+                sorted(sample(self.variables,self.K)),
+                [randint(0,1)==1 for i in range(2**self.K)],v)
+                for v in self.variables}
+        
\ No newline at end of file

rb/red_booleana.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Feb  5 09:19:46 2019
+
+@author: stan
+"""
+from itertools import product
+
+class RedBooleana:
+    
+    def __init__(self,vertices,aristas,reglas,tablas=[]):
+        self.vertices = vertices
+        self.n = len(vertices)
+        self.aristas = aristas
+        self.reglas = reglas
+        self.tablas = tablas
+        self.st_table = None
+        self.estado = tuple(False for i in range(self.n))
+        self.pos = {vertices[i]:i for i in range(len(vertices))}
+        
+    
+    def set_estado(self,x):
+        self.estado = x
+        
+    def update(self,table,estado):
+        reg_vals = tuple(estado[self.pos[v]] for v in table.variables)
+        return table[reg_vals]
+        
+    def next_state(self,estado = None):
+        if not estado:
+            estado = self.estado
+        d = {v:s for v,s in zip(self.vertices,estado)}
+        if len(self.tablas)==0:
+            self.estado = tuple(r(d) for r in self.reglas)
+        else:
+            self.estado = \
+            tuple(self.update(t,estado)\
+                  for g,t in sorted(self.tablas.items(),\
+                                    key =lambda t:self.pos[t[0]]))
+        return self.estado
+        
+    @staticmethod
+    def state_as_string(s):
+        return "".join(map(lambda x:"1" if x else "0",s))
+        
+    def iterar(self,n):
+        for i in range(n):
+            print(RedBooleana.state_as_string(self.estado))
+            self.next_state()
+            
+    def compute_state_transition_table(self):
+        t = [False,True]
+        g = (t for i in range(len(self.vertices))) 
+        i = list(product(*g))
+        tabla = {izq:der for izq,der in zip(i,(self.next_state(s) for s in i))}
+        self.st_table = tabla
+        
+    def compute_fixed_point_attractors(self):
+        if not self.st_table:
+            self.compute_state_transition_table()
+        return [i for i,d in self.st_table.items() if i==d]
+    
+    
+    def get_attrs(self,trayectoria,rep_s):
+        trayectoria.reverse()
+        for indice,estado in enumerate(trayectoria):
+            if estado==rep_s:
+                attr = trayectoria[:indice+1]
+        attr.reverse()
+        trayectoria.reverse()
+        return tuple(attr)
+        
+    
+    
+    def compute_attractors(self):
+        if not self.st_table:
+            self.compute_state_transition_table()
+        cuencas = {}
+        visitados = set()
+        profundidad = {}
+        prede = {}
+        for i,d in self.st_table.items():
+            if d in prede:
+                prede[d].append(i)
+            else:
+                prede[d] = [i]
+            trayectoria = []
+            if i in visitados:
+                continue
+            visitados.add(i)
+            trayectoria.append(i)
+            while True:
+                if d in visitados:
+                    if d in trayectoria:
+                        attractor = self.get_attrs(trayectoria,d)
+                        cuencas.update({s:attractor for s in trayectoria}) 
+                        idx = trayectoria.index(d)
+                        profundidad.update(
+                                {trayectoria[i]:(idx-i if i<=idx else 0)\
+                                for i in range(len(trayectoria))})
+                        break
+                    else:
+                        attractor = cuencas[d]
+                        cuencas.update({s:attractor for s in trayectoria})
+                        idx = profundidad[d]+len(trayectoria)
+                        profundidad.update(
+                                {trayectoria[i]:(idx-i if i<=idx else 0)\
+                                for i in range(len(trayectoria))})
+                        break
+                trayectoria.append(d)
+                i = d
+                visitados.add(i)
+                d = self.st_table[i]
+                
+        resultado = {}
+        for estado,attr in cuencas.items():
+            if attr in resultado:
+                resultado[attr] += [estado]
+            else:
+                resultado[attr] = [estado]
+                
+        return (resultado,profundidad,prede)
+                
+        
+            
+    def get_truth_table(self):
+        s = ""
+        sep = " "
+        if not self.st_table:
+            self.compute_state_transition_table()
+        
+        encabezado = sep.join(self.vertices)
+        encabezado += sep+"|"+sep
+        encabezado += sep.join(self.vertices)
+        encabezado += "\n"
+        encabezado += "-"*len(encabezado)
+        encabezado += "\n"
+        s += encabezado
+        for tupla in sorted(self.st_table.items()):
+            l = ""
+            izq,der = tupla
+            l += sep.join("1" if i else "0" for i in izq)
+            l += sep+"|"+sep
+            l += sep.join("1" if i else "0" for i in der)
+            l += "\n"
+            s += l
+        return s
+    
+    @staticmethod
+    def find_regulations(tabla):
+        regulaciones= []
+        for p,v in enumerate(tabla.variables):
+            positiva = False
+            negativa = False
+            orden = sorted(tabla.table.items(),
+            key=lambda t:t[0][:p]+t[0][p+1:]+t[0][p:p+1])
+            for i in range(2**(tabla.n-1)):
+                f0 = tabla.table[orden[i*2][0]]
+                f1 = tabla.table[orden[i*2+1][0]]
+                # vemos si hay regulación positiva
+                if f1-f0 == 1 and not positiva:
+                    regulaciones.append((v,tabla.name,'+'))
+                    positiva = True
+                    if negativa:
+                        break
+                elif f1-f0 == -1 and not negativa:
+                    regulaciones.append((v,tabla.name,'-'))
+                    negativa = True
+                    if positiva:
+                        break
+        return regulaciones
+        
+    def __str__(self):
+        s = '( '
+        for nombre,valor in zip(self.vertices,self.estado):
+            s += nombre+'='+str(valor)+' '
+        s += ')'
+        return s
+    
+    def __repr__(self):
+        return str(self)
+        
+        
\ No newline at end of file

rb/visual_bn.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Mar  5 08:30:49 2019
+
+@author: stan
+"""
+import matplotlib.pyplot as plt
+import numpy as np
+class VisualRB:
+    
+    def __init__(self,cuencas,r=1):
+        """
+        :param cuencas: diccionario con las cuencas
+        la llave es el atractor y el valor la cuenca
+        """
+        self.cuencas = cuencas
+        self.r = r
+        self.pesos = {}
+        
+    def quitar_ciclos(self,predecesores,atractores):
+        pred = predecesores.copy()
+        for atractor in atractores:
+            for estado in atractor:
+                    pred[estado]=set(pred[estado])-set(atractor)
+                    if pred[estado]==None:
+                        del pred[estado]
+        return pred
+        
+    def peso(self,estado,predecesores,atractores):
+        """
+        :param estado: estado inicial
+        :param predecesores: lista de predecesores para cada estado
+        es un diccionario donde la llave es el estado
+        """
+        pred = self.quitar_ciclos(predecesores,atractores)
+        return self.peso_r(estado,pred,atractores)
+    
+    def peso_r(self,estado,predecesores,atractores):
+        """
+        :param estado: estado inicial
+        :param predecesores: lista de predecesores para cada estado
+        es un diccionario donde la llave es el estado
+        """
+        w = 0
+        if estado in self.pesos:
+            return self.pesos[estado]
+        if estado in predecesores:
+            for p in predecesores[estado]:
+                w += 1 + self.peso_r(p,predecesores,atractores)
+        self.pesos[estado] = w
+        return w
+        
+        
+    def coordenadas_r(self,
+                      conjunto,
+                      cuencas,
+                      predecesores,
+                      r=1,
+                      offset=0,
+                      angulo=2*np.pi,
+                      coor={}):
+        
+        angulo = np.pi if angulo > np.pi else angulo
+        suma = 0
+        for estado in conjunto:
+            if not estado in coor:
+                suma += self.peso(estado,predecesores,cuencas.keys())+1
+
+
+        for estado in conjunto:  
+            if estado not in coor:
+                peso = (self.peso(estado,predecesores,cuencas.keys())+1)
+                delta =(angulo/suma)*peso
+                x = r*np.cos(delta/2+offset)
+                y = r*np.sin(delta/2+offset)
+                coor[estado] = (x,y)
+                if estado in predecesores:
+                    coor = self.coordenadas_r(
+                            predecesores[estado],
+                            cuencas,
+                            predecesores,
+                            r+1,
+                            offset,
+                            delta,
+                            coor)
+                offset += delta
+                
+        return coor        
+        
+    def coordenadas(self,
+                    conjunto,
+                    cuencas,
+                    predecesores,
+                    r=1,
+                    offset=0,
+                    angulo=2*np.pi,
+                    coor={}):
+        
+        atractores = list(cuencas.keys())
+        pred = self.quitar_ciclos(predecesores,atractores)
+        return self.coordenadas_r(
+                conjunto,
+                cuencas,
+                pred,
+                r,
+                offset,
+                angulo,
+                coor)
+            
+    def show_coor(self,coor,atractor,basins,predecesores):
+        n = len(basins[atractor])
+
+        U = np.zeros((n,1))
+        V = np.zeros((n,1))
+        X = np.zeros((n,1))
+        Y = np.zeros((n,1))
+        idx = 0
+        for estado in basins[atractor]:
+            if estado in predecesores:
+                for p in predecesores[estado]:
+                    x_s,y_s = coor[estado]
+                    x,y = coor[p]
+                    U[idx] = x_s-x
+                    V[idx] = y_s-y
+                    X[idx] = x
+                    Y[idx] = y
+                    idx += 1
+                
+        plt.axis('equal')
+        plt.quiver(
+                X,
+                Y,
+                U,
+                V,
+                scale=1,
+                scale_units='xy',
+                width=0.005,
+                facecolor='lightgray')
+        plt.scatter(X,Y,color='blue')
+        X,Y = zip(*map(lambda x:coor[x],atractor))
+        plt.scatter(X,Y,color='red')
+        
+    
\ No newline at end of file

setup.py

+from setuptools import setup
+
+setup(name='rb',
+      version='0.1.0',
+      description='Análisis de Redes booleanas',
+      url='https://git.c3.unam.mx/biosis/rb.git',
+      author='Stan',
+      author_email='stalin.munoz@c3.unam.mx',
+      license='LGPL',
+      packages=['rb'],
+      zip_safe=False)

setup.py~

+from setuptools import setup
+
+setup(name='boolparse',
+      version='0.1.0',
+      description='Boolean sentence parser',
+      url='http://c3.unam.mx/',
+      author='Stan',
+      author_email='stalin.munoz@c3.unam.mx',
+      license='LGPL',
+      packages=['boolparse'],
+      zip_safe=False)