Secciones de la página

cel. tol


Declaraciones


Constantes


Time oriented language


Árbol de ficheros

Tol

Artículos del sitio

Presentación de Tol

Todos los programas

Simuladores visuales

Sitios que me gustan

Por categorías

Algoritmia

Búsqueda y ordenación

Computación fisiológica

Editorial y edición

Gráficos de datos

Herramientas y utilidades

Hipertexto

Informática forense

Lectura óptica de datos

Metaprogramación

No determinista

Ofimática

Recursión e iteración

Reglas y restricciones

Series y estadística









cel.tol de ChRules.RandRecursive

Base de reglas y area de un automata celular que simula un juego de la vida. Los automatas celulares son modelos de sistemas dinamicos que evoluciona en forma de pasos discretos y que pueden modelizar sistemas naturales basados en un conjunto, mas o menos grande, de seres simples que interactuan unos con otros de forma local, por cercania. En la teoria, en la decada de los 40, los automatas celulares fueron plateados por Konrad Zuse y Stanislaw Ulam. En la practica, en los años 50 y dentro de la informatica, el concepto de automata celular fue planteado por John von Neumann. // Esta base de reglas emula a un automata celular donde un conjunto de celulas: a) se mueven de forma libre por el area, b) reproduciendose por parejas y engendrando entre 2 una nueva celula y c) tambien pueden morir cuando: - estan demasiado juntas (superpoblacion) o, por el contrario, - demasiado aisladas.

Declaraciones

Constantes

  • Set CelAre
    Area para un automata celular.
  • Set CelRul
    Base de reglas para probar el comportamiento de un automata celular.

Constantes

Set CelAre

//////////////////////////////////////////////////////////////////////////////
Set CelAre = AreaBuild(
[["···············",
  "···············",
  "···············",
  "······O·O······",
  "····O··O··O····",
  "······O·O······",
  "···············",
  "···············",
  "···············"]]);
//////////////////////////////////////////////////////////////////////////////
PutDescription("Area para un automata celular.", CelAre);
//////////////////////////////////////////////////////////////////////////////

Set CelRul

//////////////////////////////////////////////////////////////////////////////
Set CelRul = SetOfSet(
  RuleBuild([["OO => ··"]]),   // Muerte por superpoblacion

  RuleBuild([["O => ·",         
              "O    ·"]]),     // Muerte por superpoblacion

  RuleBuild([["··· => ···",    
              "·O·    ···", 
              "···    ···"]]), // Muerte por soledad

  RuleBuild([["O·O => ·O·",      
              "···    O·O"]]), // Reproduccion hacia abajo

  RuleBuild([["··· => O·O",      
              "O·O    ·O·"]]), // Reproduccion hacia arriba

  RuleBuild([["O· => ·O",        
              "··    O·",
              "O·    ·O"]]),   // Reproduccion lateral

  RuleBuild([["·O => O·",        
              "··    ·O",
              "·O    O·"]]),   // Reproduccion lateral

  RuleBuild([["O· => ··",        
              "··    ·O"]]),   // Movimiento diagonal

  RuleBuild([["·O => ··",        
              "··    O·"]]),   // Movimiento diagonal

  RuleBuild([["·· => ·O",        
              "O·    ··"]]),   // Movimiento diagonal

  RuleBuild([["·· => O·",        
              "·O    ··"]]));  // Movimiento diagonal
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Base de reglas para probar el comportamiento de un automata celular.",
CelAre);
//////////////////////////////////////////////////////////////////////////////

Time oriented language

//////////////////////////////////////////////////////////////////////////////
// FILE    : cel.tol
// AUTHOR  : http://www.asolver.com
// PURPOSE : Base de reglas y area de un automata celular que simula un juego
// de la vida.
// 
// Los automatas celulares son modelos de sistemas dinamicos que evoluciona en
// forma de pasos discretos y que pueden modelizar sistemas naturales basados
// en un conjunto, mas o menos grande, de seres simples que interactuan unos
// con otros de forma local, por cercania.
// 
// En la teoria, en la decada de los 40, los automatas celulares fueron
// plateados por Konrad Zuse y Stanislaw Ulam.
// 
// En la practica, en los años 50 y dentro de la informatica, el concepto de
// automata celular fue planteado por John von Neumann.
//
// Esta base de reglas emula a un automata celular donde un conjunto de
// celulas:
// a) se mueven de forma libre por el area,
// b) reproduciendose por parejas y engendrando entre 2 una nueva celula y
// c) tambien pueden morir cuando:
//    - estan demasiado juntas (superpoblacion) o, por el contrario,
//    - demasiado aisladas.
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
// CONSTANTS
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
Set CelAre = AreaBuild(
[["···············",
  "···············",
  "···············",
  "······O·O······",
  "····O··O··O····",
  "······O·O······",
  "···············",
  "···············",
  "···············"]]);
//////////////////////////////////////////////////////////////////////////////
PutDescription("Area para un automata celular.", CelAre);
//////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////////
Set CelRul = SetOfSet(
  RuleBuild([["OO => ··"]]),   // Muerte por superpoblacion

  RuleBuild([["O => ·",         
              "O    ·"]]),     // Muerte por superpoblacion

  RuleBuild([["··· => ···",    
              "·O·    ···", 
              "···    ···"]]), // Muerte por soledad

  RuleBuild([["O·O => ·O·",      
              "···    O·O"]]), // Reproduccion hacia abajo

  RuleBuild([["··· => O·O",      
              "O·O    ·O·"]]), // Reproduccion hacia arriba

  RuleBuild([["O· => ·O",        
              "··    O·",
              "O·    ·O"]]),   // Reproduccion lateral

  RuleBuild([["·O => O·",        
              "··    ·O",
              "·O    O·"]]),   // Reproduccion lateral

  RuleBuild([["O· => ··",        
              "··    ·O"]]),   // Movimiento diagonal

  RuleBuild([["·O => ··",        
              "··    O·"]]),   // Movimiento diagonal

  RuleBuild([["·· => ·O",        
              "O·    ··"]]),   // Movimiento diagonal

  RuleBuild([["·· => O·",        
              "·O    ··"]]));  // Movimiento diagonal
//////////////////////////////////////////////////////////////////////////////
PutDescription(
"Base de reglas para probar el comportamiento de un automata celular.",
CelAre);
//////////////////////////////////////////////////////////////////////////////

Árbol de ficheros

ChRules.RandRecursive programa de aplicacion de reglas de rectangulos de caracteres

  • make.tol aplica unas bases de reglas de reescritura a varios escenarios
  • make.bat mandato de ejecucion del programa de aplicacion de reglas
  • tol directorios que contienen fichero de codigo fuente Tol
    • app directorio con areas, bases de hechos, y con bases de reglas
      • rnd.tol test del comportamiento aleatorio del motor recursivo
      • cua.tol base de reglas para crecimiento cuadriaculando un area
      • cel.tol automata celular de movimiento, reproduccion y muerte
      • bat.tol batalla entre 2 frentes con pequeñas tacticas defensivas
      • wal.tol base de reglas fundamentalmete destructiva de su area
    • inc.tol para la inclusion de todas las bases de reglas del programa
  • simulator directorio del simulador del motor de reglas en Javascript
    • css directorio para css, Cascading Style Sheets, del simulador
      • simulator.css css para simular areas de aplicacion de las reglas
    • src directorio de codigo fuente Javascript del simulador de reglas
      • simulator.js simula el funcionamiento del motor de aplicacion de reglas
      • simulatorarray.js array con ejemplos de evolucion para cada base de reglas
  • startlog.txt log Tol de lectura de reglas y evolucion del automata celular
  • traceseg.txt traza de evolucion del automata celular casi en Javasript
  • simulator.html simulador del motor recursivo de reglas de areas de caracteres
  • chrules_randrecursive.pdf funciones del motor de aplicacion de reglas de caracteres

2015 asolver.com | Aviso legal | XHTML | Δ Θ Ξ | Creative Commons | Mapa y funciones del sitio

Tol