Autómata Celular “El juego de la Vida”

Universidad Nacional Autónoma de Honduras

Maestrı́a en Matemáticas
MMM680

Aner Godoy1
1
anergogo7@gmail.com

April 18, 2019

Resumen
Se presenta en este trabajo una breve explicación de los autómatas celulares, algunas de sus caractristicas y elementos
que los componen.Tambien se presenta una descripción del autónama celular “El juego de la vida ”, de Conway, sus
reglas, algunas aplicaciones y su implementación en C++ aplicando la libreria OpenMP para paralelizar el codigo
fuente y asi observar la mejoria en la ejecución del programa.

Introducción
Un autómata celular es un modelo matemático para un sistema dinámico compuesto por un conjunto de celdas o
células que adquieren distintos estodos o valores. Estos estados son alternados de un sistema a otro en unidades de
tiempo discreto, es decir, que se pueden cuantificar con valores enteros o intervalos regulares. De esta manera este
conjunto de células logran una evolución según una determinada expresión matemática, que es sencible a los estados de
las células vecinas, y que se conoce como regla de transición local [1]. Para los matemáticos es fundamental el utilizar y
desarrollar herramientas, que expliquen los fenómenos que nos rodean. Esto se logra, a través de modelos matemáticos
que dan respuesta a dichos fenómenos. Ası́ lo señala el gran avance de los sistemas dinámicos, particularmente los
autómatas celulares.
La computación puede verse como la transformación de la información, donde al inicio de este proceso siempre hay
condiciones iniciales. Sin embargo, hay procesos de computo donde nuevas entradas de información pueden darse
dentro del proceso mismo. Esta información nueva a veces determina el resultado del proceso [3].
Un autómata celular(A.C) es un modelo matemático para un sistema dinámico que evoluciona en pasos discretos. Es
adecuado para modelar sistemas naturales que pueden ser descritos como una colección masiva de objetos simples que
interactuen localmente unos con otros.
Los autómatas celulares son herramientas útiles para modelar cualquier sistema en el universo. Puede considerarse
como una buena alternativa a las ecuaciones diferenaciles y han sido utilizados para modelar sistemas fisicos, como
iteraciones entre particulas, formación de galaxias, cinética de sistemas moleculares y crecimiento de cristales, ası́ como
diversos sistemas biológicos a nivel celular, molecular y poblacional[3]..

1
Autómata Celular “El juego de la Vida”

El juego de la vida de Conway

Descripción:
El juego de la vida de Conway es el autómata celular mas conocido y más estudiado, diseñado por el matemático John
Horton en 1970. El juego es un autómata celular bidimencional en el cuál cada celda (célula) puede estar en uno de los
dos estados posibles, viva o muerta. Partiendo de un estado inicial, la simulación va haciendo evolucionar el autómata
en base a unas sencillas funciones de transición. Una célula va a estar en un estado concreto, el cual será determinado
únicamente del estado inmediatamente anterior de las células vecinas y de la propia célula.

Reglas:
El conjunto básico inicial que propuso Conway se compone de tres reglas muy sencillas:

• Cada célula viva con dos o tres células vecinas vivas sobrevive a la siguiente genereción.
• Cada célula viva con ninguna, una, o mas de tres células vivas a su alrededor pasa a estar muerta(Soledad y
superpoblación).
• Cada célula muerta con tres células vecinas resusita en la siguiente generación.
Sin embargo se pueden realizar variaciones en estas reglas para obtener comportamientos distintos a los habituales.
La manera de representar las reglas es X/Y, donde X e Y son números enteros. Cada uno de los dı́gitos que forman
estos números representa un número de vecinos válido para nacer o continuar viviendo respectivamente [2].

Existen patrones que no cambien o solo tienen dos estados:

A estas formas se les llama patrones estáticos. Existen básicamente tres clases de patrones en el juego de la vida de
Conway. A continuación se enumeran algunas figuras con patrones estaticos:

• Patrones estáticos : Un conjunto de células vivas que se mantiene estático, sin que se produzcan nuevos naci-
mientos o muertes.

Figura 1: Patrón bloque (Block).

Figura 2: Patrón barco.

2
Autómata Celular “El juego de la Vida”

Patrones que se trasladan: Un conjunto de células vivas que permanece con la misma forma, pero que se desplaza por
el tablero.

Figura 3: Patrón Parpadeador.

Descripción del algoritmo

Se ha realizado una versión del juego de la vida de Conway utilizando el lenguaje C/C++. En esta version del algoritmo
se ha incluido la libreria OpenMP para hacer comparaciones con la versión secuencial del mismo algoritmo.

• Es necesario el analisis de la propuesta del programa a crear.

• Se necesita un medidor de tiemo de ejecución de las funciones que se ejecutan.
• Configuracion de las reglas del juego de la vida.

La aplicación muestra un tablero con una matriz de células (42x166), se eligió una matriz de estas dimenciones para
que cuando se manda a imprimir, se observe la matriz completa en la pantalla.
En principio todas las células cubiertas por espacios vacios (Muertas) y las células que contienen un número cero
(Vivas). Este programa genera una matriz aleatoria con ceros y espacios vacios en su interior de donde inicia el
proceso. Al ser aleatoria la eleccion de las células vivas y muertas, cada inicio es diferente.
Para modificar el tamaño de la matriz es necesario ir al codigo fuente y hacer el cambio, ası́ tambien para ver el
siguiente estado es necesario oprimir la tecla enter.

Implementación
Para la creación del juego de la vida en C++ se han implementado en tres etapas:

• El llamado de las librerias y funciones tanto como el Main en la primera etapa.

• Las funciones de análisis de las matrices que contienen las reglas del juego.
• Las funciones para desplegar las matrices en pantalla.

Se crean cinco funciones con las que el juego se ejecuta de manera correcta.
• Primero la función “MatAl”:
Crea una matriz aleatoria (n), llena con unos y ceros, los que indican que las células con el núnero uno son
células vivas, mientras que las células con en número cero indica una célula muerta.

• “MostrarN”:
Se crea una función que muestra en pantalla la matriz creada (n).
• “AnalizarN”:
Es una función que analiza la matriz creada (n) y escribe sobre otra matriz declarada en ceros (y), de acuerdo
a las reglas establecidas.

3
Autómata Celular “El juego de la Vida”

• “MostrarY”:
Función que imprime en pantalla esta nueva matriz (y).
• “AnalizarY”:
La función que analiza la matriz sobreescrita (y) y reescribe la primera matriz (n).
• “MostrarN”: imprime la primera matriz (n) y el ciclo se repite.
El código ejecuta primeramente el “main”, donde esta el llamado del las funciones en el siguiente orden:

• Crear una matriz (42x166) aleatoria (n).

• Imprimir en pantalla la matriz (n).
• Analizar la matriz (n).
• Imprimir en pantalla ma matriz (y);
• Analizar la matriz (y).
• Imprimir en pantalla la matriz (n).
• Continuar el ciclo.
La función “MatAl”, utiliza una función que pertenece a C++, llamada “srand”para generar las celulas que estaran
con cero o uno en la matriz (n). Utiliza dos ciclos “for.anidados para crear filas y columnas de la matriz (n) en un solo
arreglo.
La reglas del juego de la vida, se introducen en las funciones, “AnalizarN”, y “AnalizarY”. Se hace un recorrido por
cada célula de la matriz y en cada célula se evalúan las tres reglas.
Primero se suman (s) los valores de las celulas en la vecindad de la célula evaluada, luego, se hacen seis comparaciones:

• Si la célula evaluada contiene el número uno:

– La suma (s) es diferente de tres y dos, se escribe en la otra matriz para la misma posición de la matriz
evaluada, se le asigna cero.
– La suma (s) es igual de tres y dos, se escribe en la otra matriz para la misma posición de la matriz evaluada,
se le asigna uno.
• Si la célula evaluada contiene el número cero:

– La suma (s) es igual a tres, se escribe en la otra matriz para la misma posición de la matriz evaluada, se le
asigna uno.
– La suma (s) es diferente de tres, se escribe en la otra matriz para la misma posición de la matriz evaluada,
se le asigna cero.
Se prueban varios comandos de la libreria OpenMP y utilizando distints cantidades de hilos para los que el pro-
grama funcionó bien como ser:

• pragma omp parallel.

Forma un equipo de hilos y comienza la ejecución paralela.
• pragma omp parallel master.
Especifica un bloque estructurado que se ejecuta por el hilo maestro del equipo.
• pragma omp parallel for.
Atajo para especificar una construcción paralela que contiene uno o más bucles asociados y ninguna otra decla-
ración.

4
Autómata Celular “El juego de la Vida”

• pragma omp parallel for shared(y).

Todos los hilos participantes comparten la informacion de la matriz (y).
• pragma omp parallel for shared(n).
Todos los hilos participantes comparten la informacion de la matriz (n).

Resultados

Tiempo (Segundos)
Código Código
Código “El juego de la vida” “El juego de la vida” Código
Código
“El juego de la vida” Usando funciones de omp Usando funciones de omp “El juego de la vida”
Hilos “El juego de la vida”
usando funciones de omp parallel for shared parallel for shared Usando funciones de omp
secuencial
en la sección principal omp master omp sections omp parallel en (if)
omp critical omp critical
1 0.296 - 0.31 0.299 - 0.33 0.291 - 0.302 0.292 - 0.32 0.492 - 0.502
2 0.296 - 0.31 0.283 - 0.305 0.287 - 0.301 0.288 - 0.308 0.672 - 0.684
3 0.296 - 0.31 0.285 - 0.301 0.282 - 0.327 0.299 - 0.306 0.759 - 0.772
4 0.296 - 0.31 0.266 - 0.317 0.286 - 0.311 0.281 - 0.299 0.894 - 0.967

Se compara el desempeño con respecto al tiempo que tarda en ejecutarse el ciclo completo, de el juego de la vida y se
toman los valores minimos y maximos observados en pantalla.
Estas pruebas fueron realizadas en una computadora Dell, con un procesador intel(R) Core(TM) i5-7200U CPU
@2.50GHz, 2701 Mhz, 2 procesadores principales, 4 hilos, con una Sistema Operativo Microsoft Windows 10 Home
Single Language.

Figura 4: Grafica de valores tiempo minimo observados en las pruebas de códigos.

Conclusiones
• Claramente, existe una mejoria en el tiempo de ejecución de algunos algoritmos paralelizados con la librerı́a
OpenMP. Excepto cuando se paralelizo las estructura de control (if), que genero un buen funcionamiento del
programa pero un mal tiempo de ejecucuión, por lo que podemos concruir que la configuración de los comandos
de paralelización influyen directamente en el rendimiento de un programa.

5
REFERENCIAS REFERENCIAS

• La mejora en el rendimiento del tiempo de ejecución de los algoritmos paralelizados, no es tan notable a simple
vista, pero como podemos ver en la grafica 4, cuando utilizamos cuatro hilos, siempre se reduce el tiempo en que
se ejecuta el programa.

Referencias
[1] F. S. Caparrini. http://www.cs.us.es. Magazine Theme for PivotX by Windmill Web Work, 2009.

[2] G. R. T. Juan Ignacio Del Castillo Waters. El juego de la vida de conway. UNIVERSIDAD DE CASTILLA-LA
MANCHA, Dic. 2008.
[3] D. Reyes. Descripción y aplicaciones de los autómatas celulares. Puebla, México, 2011.

Anexos
// Código El juego de la vida//

#include<iostream>
#include<time.h>
#include<stdlib.h>
#include<conio.h>
#include <omp.h>

using namespace std;

void MatrAl();
void AnalizarN();
void MostrarN();
void MostrarY();
void AnalizarY();
int f=166,t=42;
int n[6972]={0},x=1,y[6972]={0};

int main (){

omp_set_num_threads(4);
#pragma omp parallel

MatrAl();

do{
double time = omp_get_wtime();
#pragma omp sections
{
#pragma omp section
MostrarN();
#pragma omp section
AnalizarN();
#pragma omp section
system("pause");
}
system("cls");
cout<<"\ntiempo: "<<omp_get_wtime()-time<<endl;
time = omp_get_wtime();
#pragma omp sections
{

6
REFERENCIAS REFERENCIAS

#pragma omp section

MostrarY();
#pragma omp section
AnalizarY();
}
system("pause");
system("cls");
cout<<"\ntiempo: "<<omp_get_wtime()-time<<endl;
}
while (x==1);
return 0;
}
void MatrAl(){ //numeros aleatorios
srand(time(NULL));
#pragma omp for
for (int i=0;i<t;i++){
for (int j=0;j<f;j++){
n[i*f+j]=0 + rand()%(2);
}
}
}
void AnalizarN(){
int s=0;
for (int i=0;i<t;i++){
#pragma omp parallel for shared(n)
for (int j=0;j<f;j++){
s=n[(i+1)*f+j]+n[(i-1)*f+j]+n[i*f+(j+1)]+n[i*f+(j-1)]+n[(i-1)*f+(j-1)]+n[(i-1)*f+(j+1)]+n[(i+1)*f+(j-1)]+n[(
if (n[i*f+j]==1){
if ((s!=3)&&(s!=2)){
y[i*f+j]=0;
}
if ((s==3)||(s==2)){
y[i*f+j]=1;
}
}
else if (n[i*f+j]==0){
if (s==3){
y[i*f+j]=1;
}
if (s!=3){
y[i*f+j]=0;
}
}
}
}
}
void AnalizarY(){
int s=0;
for (int i=0;i<t;i++){
#pragma omp parallel for shared(y)
for (int j=0;j<f;j++){
s=y[(i+1)*f+j]+y[(i-1)*f+j]+y[i*f+(j+1)]+y[i*f+(j-1)]+y[(i-1)*f+(j-1)]+y[(i-1)*f+(j+1)]+y[(i+1)*f+(j-1)]+y[(
if (y[i*f+j]==1){
if ((s!=3)&&(s!=2)){
n[i*f+j]=0;

7
REFERENCIAS REFERENCIAS

}
if ((s==3)||(s==2)){
n[i*f+j]=1;
}
}
else if (y[i*f+j]==0){
if (s==3){
n[i*f+j]=1;
}
if (s!=3){
n[i*f+j]=0;
}
}
}
}
}
void MostrarN(){
omp_set_nested(1);
#pragma omp critical
for (int i=0;i<t;i++){
for (int j=0;j<f;j++){
if (n[i*f+j]==1){
cout<<"0";
}
else if (n[i*f+j]==0){
cout<<’ ’;
}
}
cout<<endl;
}
}
void MostrarY(){
omp_set_nested(1);
#pragma omp critical
for (int i=0;i<t;i++){

for (int j=0;j<f;j++){

if (y[i*f+j]==1){
cout<<"0";
}
else if (y[i*f+j]==0){
cout<<’ ’;
}
}
cout<<endl;
}
}