Python - ayuda automata celular

   
Vista:

ayuda automata celular

Publicado por Eduardo (1 intervención) el 21/08/2015 15:47:10
Hola a todos, debo hacer una simulacion de automatas celulares, pero soy nuevo en cuanto a programacion en python. Me pasaron un codigo, pero hay un error que no puedo detectar.

Alguien podria ayudarme y explicarme porque las cadenas se van haciendo mas largas con cada interaccion?..al principio pense que el problema era en la parte de
1
nueva_cadena=primer_celda+nueva_cadena+ultima_celda

asi que la comente, pero ocurre que las cadenas se hacen mas pequeñas.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
import sys
 
# Imprimir resultado con el formato establecido: 0=blanco, 1=*.
#  Entrada: cadena
#  Salida: cadena con formato establecido (anexa guiones al principio y al final)
def imprime_resultado(cadena):
	resultado_formato = ''
	for caracter in cadena:
		if caracter == '1':
			resultado_formato = resultado_formato + 'x'
		else:
			resultado_formato = resultado_formato + '-'
        print (resultado_formato + "")
 
# Aplicar la regla con la ventana recibida.
#  Entrada: Ventana (coleccion de tres celdas, la central y dos vecinos a los lados)
#  Salida: 0 o 1, dependiendo de la regla utilizada
#  Regla 165: Vecinos con el mismo color=1, de otra manera=0
def procesa_ventana(ventana):
    if ventana[0] == ventana[2]:
        resultado = '1'
    else:
        resultado = '0'
    return resultado
 
 
# Generar una nueva cadena de acuerdo a una regla (0-255)
# Entrada: cadena actual (t=i)
# Salida: cadena nueva (t=i+1)
def recorre_cadena(cadena):
    nueva_cadena = ''
 
    for i in range(0,len(cadena)-2): #Es como un for(i=0;i<cadena.length;i++) en Java
        n = len(cadena)
        ventana = cadena[i:i+3]
        nueva_cadena = nueva_cadena+str(procesa_ventana(ventana))
 
        ultima_ventana = cadena[len(cadena)-2]+cadena[len(cadena)-1]+cadena[0]
        primera_ventana = cadena[len(cadena)-1]+cadena[0]+cadena[1]
 
        ultima_celda = str(procesa_ventana(ultima_ventana))
        primer_celda = str(procesa_ventana(primera_ventana))
 
        nueva_cadena = primer_celda+nueva_cadena+ultima_celda;
 
    return nueva_cadena
 
#-------------------------------------------------------------
# Main (parte principal del programa)
 
# Cadenas de prueba
#mi_cadena = "0000000000000000000000000000000000100000000000000000000000000000000000"
#mi_cadena="0010101110"
mi_cadena="01010111"
# Toma la cantidad de iteraciones como argumento de la linea de comando
iteraciones = 3 #sys.argv[1]
 
# Por la cantidad fijada de iteraciones:
#   Imprime la cadena actual
#   Genera una nueva cadena de acuerdo a la regla
#   Reemplaza la cadena actual por esta nueva cadena
for i in range(0,int(iteraciones)):
    imprime_resultado(mi_cadena)
    nueva_cadena = recorre_cadena(mi_cadena)
 
    mi_cadena = nueva_cadena


Necesito que la variable nueva_cadena sea del mismo tamaño en todas las interacciones, agradezco si alguien pudiera comentarme mi error.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

ayuda automata celular

Publicado por Rogelio Hdz (2 intervenciones) el 22/08/2015 06:41:04
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import sys
def imprime_resultado(cadena):
        resultado_formato="_"
        for caracter in cadena:
                if caracter=="1":
                        resultado_formato=resultado_formato + "+"
                        print resultado_formato+'_'
                else:
                        resultado_formato=resultado_formato + "o"
                        print resultado_formato+'_'
 
def recorre_cadena(cadena):
        nueva_cadena=''
        for i in range(0,len(cadena)-2):
                n=len(cadena)
                ventana=cadena[i:i+3]
                nueva_cadena=procesa_ventana(ventana)
                ultima_ventana=cadena[n-2] + cadena[n-1] + cadena[0]
                primera_ventana=cadena[n-1] + cadena[0] + cadena[1]
                ultima_celda=procesa_ventana(ultima_ventana)
                primer_celda=procesa_ventana(primera_ventana)
                nueva_cadena=primer_celda+nueva_cadena+ultima_celda
        return nueva_cadena
 
def procesa_ventana(ventana):
        if ventana[0]==ventana[2]:
                resultado="1"
                return resultado
        else:
                resultado="0"
                return resultado
 
iteraciones=sys.argv[0]
 
mi_cadena="0000000000000000000000000000000000100000000000000000000000000000000000"
for i in range(0,len(iteraciones)):
        nueva_cadena=''
        imprime_resultado(mi_cadena)
        mi_cadena=nueva_cadena + recorre_cadena(mi_cadena)
        mi_cadena=nueva_cadena

Suerte.
Es el mismo código que me encargaron a mi y así lo resolví. aunque no logre crear el autómata completo porque el código solo hace una parte. NO está completo.
Como me dijo la Ingeniera: -Es que está hecho en MAC.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

ayuda automata celular

Publicado por Rogelio Hdz (2 intervenciones) el 22/08/2015 06:44:49
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
#!/usr/bin/python
 
import sys
try:
  import Image
except:
  print "You need python-imaging package"
  sys.exit()
import cStringIO
 
class Automaton:
  vector = []
  def __init__(self,rulesInput,initSize=256,defaultState='0',initialVector=None):
    self.numberRule = rulesInput
    n = Denary2Binary(rulesInput)
 
    self.createRule((8-len(n))*'0' + n)
 
    if initialVector == None:
      self.defaultState = defaultState
      self.size = initSize
      self.vector = [self.defaultState]*self.size
    else:
      self.vector = initialVector
      self.size = len(initialVector)
 
  def createRule(self,binary):
     self.rules = {"000": binary[7],"001":binary[6],"010":binary[5],"011":binary[4],
                    "100":binary[3],"101":binary[2],"110":binary[1],"111":binary[0]}
 
 
  def changeState(self):
    nextStep = self.vector[:]
    for i in xrange(self.size-1):
      nextStep[i] = str(self.rules[self.vector[i-1]+self.vector[i]+self.vector[i+1]])
 
    nextStep[-1] = str(self.rules[self.vector[-2]+self.vector[-1]+self.vector[0]])
 
    self.vector = nextStep
 
def Denary2Binary(n):
  if n == 0: return ''
  return Denary2Binary(n>>1) + str(n % 2)
 
class AutomatonImage:
  buffer = cStringIO.StringIO()
 
  width = 0
  height = 0
 
  def __init__(self,autoObj=None,iter=None):
 
    if autoObj != None and iter != None:
      self.name = "automata-rule%s.jpg" % autoObj.numberRule
      for i in xrange(iter):
       self.writeVector(autoObj.vector)
       autoObj.changeState()
      self.saveImage()
 
  def writeVector(self,vector):
 
    self.height = self.height + 1
    self.width = len(vector)
    for i in xrange(len(vector)):
      self.writePixel(vector[i])
 
  def writePixel(self,value):
 
    if value == '0':
      self.buffer.write('\xff\xff\xff')
    else:
      self.buffer.write('\x00\x00\x00')
 
  def saveImage(self):
    imagen = Image.fromstring("RGB",(self.width,self.height),self.buffer.getvalue())
    imagen.save(self.name,"JPEG")
 
 
if __name__ == "__main__":
  # Default size of the initial automata
  size = 500
  mVector = (' '.join('0'*size)).split()
  # The midle of the vector must be 1
  mVector[(size/2)+1]='1'
 
  if len(sys.argv) > 1:
    try:
      n = int(sys.argv[1])
    except:
      print "Second parameter must be an integer"
      sys.exit()
  else:
    n = raw_input("Rule number: ")
    try:
      n = int(n)
    except:
      print "Must be an integer"
      sys.exit()
 
  myAutom = Automaton(n,initialVector=mVector)
  AutomatonImage(myAutom,(size/2))

Puedes usar este código también.
Está más completo. Solo te pide el numero de la regla y te genera una imagen con el autómata.
Y tienes que instalar python-imaging package.
Saludos.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar